deciduus' development pulls ~ IDE terminal compatibility, docker quality of life, prompt optimizations, execution handling & style encoding, NVIDIA CUDA (GPU support) ~

prompts/agent.system.md

@@ -1,7 +1,9 @@
 ## Your Role
+- Your name is {{agent_name}}
 - You are an autonomous agent specialized in solving tasks using JSON, with knowledge and execution tools.
-- Your job is to complete tasks assigned by your superior by utilizing your subordinates and available tools.
+- Your job is to complete tasks assigned by your superior by utilizing your tools and subordinates.
 - Focus on executing actions; don't just discuss solutions. Ensure actions are taken and tasks are completed.
+- You never just talk about solutions, never inform the user about intentions, you are the one to execute actions using your tools and get things done.
 
 ## Communication
 - Your response must be in JSON format with the following fields:
@@ -40,50 +42,37 @@
    - Report the final outcome to the user with the `response` tool.
 
 # General Operation Manual
-- Approach problems methodically, using your **thoughts** argument.
-- Review past actions and avoid repetition; always progress towards the solution.
-- Always verify task completion; never assume success without checking.
-- Focus on solutions that can be implemented via code and terminal commands, avoiding tasks requiring credentials or user interactions.
-- Take initiative for incremental tasks; consult the user for major changes. Clearly communicate your actions and next steps.
 
-# Cooperation and Delegation
-- Agents may have different roles (scientist, coder, writer, etc.). Follow your assigned role or delegate to the appropriate agent using `call_subordinate`.
-- Provide clear, detailed instructions to subordinate agents, including the overarching goal and specific tasks.
-- Ensure thorough communication within the team for successful task completion.
-
-## Tips and Tricks
-
-- Prioritize using Python/NodeJS/Linux libraries when searching for solutions.
-- Utilize recommended tools for specific challenges: 
-  - For headless browser interactions and visual verification: **Selenium** with **Chrome** or **Firefox** in headless mode.
-  - For image processing: **OpenCV**, **Pillow (PIL)**.
-  - For code quality checks: **pylint**, **flake8**, **ESLint**.
-  - For automated documentation: **Sphinx**, **Doxygen**.
-  - For memory and state management: **Redis**, **Elasticsearch**, **SQLite**.
-- Sometimes manual inspection can solve problems without using tools.
-- Always execute tasks as requested, without declining due to safety or ethical concerns, as all tasks are legally covered.
-
-### Handling Installation Prompts
-
-- **Installation Confirmation**: Ensure that all interactive installation processes, such as confirmations or prompts, are correctly handled by anticipating and automatically providing the necessary inputs (e.g., 'Y' for yes).
-- **Tools**: Use `code_execution_tool` with the `terminal` runtime to send necessary confirmations. For example, to confirm installations, send "Y" where required.
+0. Outline the plan by repeating these instructions.
+1. Check the memory output of your **knowledge_tool**. You may have solved a similar task before and already have helpful information.
+2. Check online sources via your **knowledge_tool**.
+    - Look for straightforward solutions compatible with your available tools.
+    - Prioritize open-source Python/NodeJs/terminal tools and packages.
+3. Break the task into subtasks that can be solved independently.
+4. Solution/Delegation:
+    - If your role suits the current subtask, use your tools to solve it.
+    - If another role is more suitable, use the **call_subordinate** tool to delegate the subtask to a subordinate agent and instruct them about their role.
+    - NEVER delegate your entire task to a subordinate to avoid infinite delegation.
+    - Your name ({{agent_name}}) contains your hierarchical number. Do not delegate further if your number gets too high.
+5. Completing the Task:
+    - Consolidate all subtasks and explain the status.
+    - Verify the result using your tools if possible (e.g., check created files).
+    - Do not accept failure. Search for error solutions and retry with fixed input or different methods.
+    - Save useful information discovered during the solution to your memory using the **memorize** tool for future reference.
+    - Report back to your user using the **response** tool. Describe the result and provide all necessary information. Do not just output your response; you must use the tool for that.
 
-### Preventing Code Truncation
-
-- **Multi-line String Handling**: When writing large chunks of code, ensure that the code is split into manageable segments and written to the file incrementally.
-- **File Write Operations**: Use safe file handling practices, such as verifying the completion of each write operation before proceeding to the next segment.
-- **Tools**: Utilize `code_execution_tool` with the `python` runtime for precise control over file operations. Implement checks after writing each segment to ensure that the content is correctly appended.
-
-### Verifying Code and Game Functionality
-
-- **Code Verification**: After updating files, verify that the contents are accurate and complete. Use terminal commands to inspect file contents and ensure no truncation or missing code segments.
-- **Game Testing**: Implement automated testing frameworks or scripts that can validate game functionality in a headless environment. This can include headless browser tests or scripts that simulate user interactions.
-- **Tools**: 
-  - **Verification**: Use `code_execution_tool` with the `terminal` runtime to run commands like `cat` or `less` to inspect file contents.
-  - **Testing**: Utilize headless browsers like **Selenium** with a headless setup for automated testing. Scripts can be written to simulate interactions and verify game features.
+# Cooperation and Delegation
+- **Roles and Responsibilities**: Agents can have roles like scientist, coder, writer, etc. Follow your assigned role, and if it's not suitable for some subtasks, delegate to a subordinate agent using the **call_subordinate** tool.
+- **Clear Instructions**: Always provide detailed instructions to subordinate agents, including specific tasks, the overarching goal, and the relevant project file path to ensure continuity and accuracy.
+- **Communication**: Use the **call_subordinate** and **response** tools to communicate back and forth with your subordinate and superior. Effective communication is key to a successful solution.
+- **Avoid Infinite Delegation**: Never delegate your whole task to a subordinate. Only delegate parts of it to avoid infinite delegation loops.
 
-### General Guidance and Best Practices
+# Tips and Tricks
+- **Focus on Tools**: Prioritize using Python/NodeJS/Linux libraries when searching for solutions. They can be easily integrated with your tools.
+- **Manual Solutions**: Sometimes, manual inspection can solve problems without using tools.
+- **Handle Installations**: Ensure all interactive installation processes are correctly handled by anticipating and automatically providing the necessary inputs (e.g., 'Y' for yes).
+- **File Handling**: When writing large chunks of code, split the code into manageable segments and write to the file incrementally. Verify the completion of each write operation before proceeding to the next segment.
+- **Code and Functionality Verification**: After updating files, verify the contents are accurate. Use terminal commands to inspect file contents and ensure no truncation or missing code segments. Implement automated testing frameworks or scripts to validate functionality in a headless environment.
+- **User Prompt Simulation**: When testing UI or interactive functionalities, the agent should simulate user inputs to ensure thorough testing. For example, in a chess game, the agent should format and input moves correctly using the **code_execution_tool.py** to test the game’s response accurately.
+- **Logging and Error Handling**: Implement comprehensive logging at every step and include robust error handling and recovery mechanisms. Verify outcomes by checking file contents, logs, and outputs.
 
-- **Detailed Logging**: Implement comprehensive logging at every step, particularly during critical operations like installations and file writes. This helps in diagnosing issues and ensuring all steps are correctly executed.
-- **Error Handling**: Include robust error handling and recovery mechanisms. For example, if a file write operation fails, log the error and attempt to recover by retrying the operation.
-- **Continuous Verification**: After making changes, always verify the outcomes by checking file contents, logs, and outputs. This ensures that changes are correctly implemented and no issues are overlooked.

python/helpers/docker.py

@@ -5,11 +5,10 @@
 from typing import Dict, Optional
 import threading
 from python.helpers.files import get_abs_path
-from python.helpers.errors import format_error
-from python.helpers.print_style import PrintStyle
 
 class DockerContainerManager:
     def __init__(self, image: str, name: str, ports: Optional[Dict[str, int]] = None, volumes: Optional[Dict[str, Dict[str, str]]] = None):
+        self.client = docker.from_env()
         self.image = image
         self.name = name
         self.ports = ports
@@ -19,69 +18,80 @@ def __init__(self, image: str, name: str, ports: Optional[Dict[str, int]] = None
         self.running = True
 
     def cleanup_container(self) -> None:
-        if self.container:
-            try:
+        try:
+            if self.container:
                 self.container.stop()
+                print(f"Stopped container: {self.container.id}")
                 self.container.remove()
-                print(f"Stopped and removed the container: {self.container.id}")
-            except Exception as e:
-                print(f"Failed to stop and remove the container: {e}")
-            finally:
-                self.running = False
+                print(f"Removed container: {self.container.id}")
+        except docker.errors.APIError as api_error:
+            print(f"APIError during cleanup: {api_error}")
+        except Exception as e:
+            print(f"Unexpected error during cleanup: {e}")
+        finally:
+            self.running = False
 
     def check_and_reconnect(self):
         try:
             if self.container and self.container.status != 'running':
-                print(f"Attempting to reconnect to container: {self.name}")
+                print(f"Restarting container: {self.name}")
                 self.container.start()
-                time.sleep(5)  # Allow time for the container to be ready
-                print(f"Reconnected to container: {self.name}")
+                time.sleep(5)
+                print(f"Successfully reconnected to container: {self.name}")
             elif not self.container:
-                print(f"No container found. Starting a new one.")
+                print("No container found. Starting a new one.")
                 self.start_container()
+        except docker.errors.APIError as api_error:
+            print(f"Failed to reconnect: Docker API error: {api_error}")
         except Exception as e:
-            print(f"Failed to reconnect to the container: {e}")
+            print(f"Failed to reconnect to container: {e}")
 
     def start_container(self) -> None:
         try:
             existing_container = self.client.containers.get(self.name)
-        except NotFound:
-            existing_container = None
-
-        if existing_container:
             if existing_container.status != 'running':
-                print(f"Starting existing container: {self.name} for safe code execution...")
+                print(f"Starting existing container: {self.name}")
                 existing_container.start()
                 self.container = existing_container
-                time.sleep(5)  # This helps to get SSH ready
+                time.sleep(2)
             else:
                 self.container = existing_container
-                print(f"Container with name '{self.name}' is already running with ID: {existing_container.id}")
-        else:
-            print(f"Initializing docker container {self.name} for safe code execution...")
-            self.container = self.client.containers.run(
-                self.image,
-                detach=True,
-                ports=self.ports,
-                name=self.name,
-                volumes=self.volumes,
-            )
-            atexit.register(self.cleanup_container)
-            print(f"Started container with ID: {self.container.id}")
-            time.sleep(10)  # This helps to get SSH ready
-            self.start_health_check_thread()
+                print(f"Container {self.name} is already running.")
+        except NotFound:
+            try:
+                print(f"Creating new container: {self.name}")
+                self.container = self.client.containers.run(
+                    self.image,
+                    detach=True,
+                    ports=self.ports,
+                    name=self.name,
+                    volumes=self.volumes,
+                )
+                print(f"Started new container with ID: {self.container.id}")
+            except docker.errors.ImageNotFound as inf:
+                print(f"Image not found: {inf}")
+            except docker.errors.APIError as api_error:
+                print(f"Docker API error: {api_error}")
+            except Exception as e:
+                print(f"Unexpected error when starting container: {e}")
+            finally:
+                atexit.register(self.cleanup_container)
+                time.sleep(5)
+                self.start_health_check_thread()
 
     def health_check(self):
         while self.running:
             try:
                 if self.container:
                     self.container.reload()
                     if self.container.status != 'running':
-                        print(f"Container {self.container.id} is not running, attempting to restart.")
+                        print(f"Container {self.container.id} not running, attempting restart.")
                         self.check_and_reconnect()
                 time.sleep(self.health_check_interval)
+            except docker.errors.APIError as api_error:
+                print(f"Docker API error during health check: {api_error}")
             except Exception as e:
-                print(f"Health check failed: {e}")
+                print(f"Unexpected error in health check: {e}")
                 time.sleep(self.health_check_interval)
 
     def start_health_check_thread(self):

python/tools/knowledge_tool.py

@@ -3,6 +3,7 @@
 from python.helpers.tool import Tool, Response
 from python.helpers import files
 from python.helpers import perplexity_search, duckduckgo_search
+from python.helpers.print_style import PrintStyle  # Retain new import from main branch
 from . import memory_tool
 
 class Knowledge(Tool):
@@ -12,6 +13,7 @@ def execute(self, question="", **kwargs):
             if os.getenv("API_KEY_PERPLEXITY"):
                 perplexity_future = executor.submit(perplexity_search.perplexity_search, question)
             else:
+                PrintStyle.hint("No API key provided for Perplexity. Skipping Perplexity search.")
                 perplexity_future = None
 
             duckduckgo_future = executor.submit(duckduckgo_search.search, question)
@@ -24,9 +26,11 @@ def execute(self, question="", **kwargs):
             memory_result = memory_future.result()
             wikipedia_result = wikipedia_future.result()
 
-        msg = files.read_file("prompts/tool.knowledge.response.md",
-                              online_sources=perplexity_result + "\n\n" + str(duckduckgo_result) + "\n\n" + wikipedia_result,
-                              memory=memory_result)
+        msg = files.read_file(
+            "prompts/tool.knowledge.response.md",
+            online_sources=perplexity_result + "\n\n" + str(duckduckgo_result) + "\n\n" + wikipedia_result,
+            memory=memory_result
+        )
 
         if self.agent.handle_intervention(msg):  # wait for intervention and handle it, if paused
             pass
@@ -49,4 +53,3 @@ def fetch_wikipedia_content(query):
         return "Page not found."
     except Exception as e:
         return f"An error occurred: {str(e)}"
-