Skip to content

Agent Zero AI framework

Docker + SSH, AgentConfig class

frdelb74d05d6c2bf
diff --git a/agent.py b/agent.py
index 752104b8c..8b5993f17 100644
--- a/agent.py
+++ b/agent.py
@@ -1,58 +1,60 @@
+from dataclasses import dataclass, field
import time, importlib, inspect, os, json
import traceback
-from typing import Optional, Dict, TypedDict
-from tools.helpers import extract_tools, rate_limiter, files, errors
-from tools.helpers.print_style import PrintStyle
+from typing import Any, Optional, Dict, TypedDict
+from python.helpers import extract_tools, rate_limiter, files, errors
+from python.helpers.print_style import PrintStyle
from langchain.schema import AIMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.embeddings import Embeddings
-from tools.helpers.rate_limiter import RateLimiter
+from python.helpers.rate_limiter import RateLimiter
# rate_limit = rate_limiter.rate_limiter(30,160000) #TODO! implement properly
+@dataclass
+class AgentConfig:
+ agent_number: int
+ chat_model:BaseChatModel
+ embeddings_model:Embeddings
+ memory_subdir: str = ""
+ auto_memory_count: int = 3
+ auto_memory_skip: int = 2
+ rate_limit_seconds: int = 60
+ rate_limit_requests: int = 30
+ rate_limit_input_tokens: int = 0
+ rate_limit_output_tokens: int = 0
+ msgs_keep_max: int = 25
+ msgs_keep_start: int = 5
+ msgs_keep_end: int = 10
+ max_tool_response_length: int = 3000
+ code_exec_docker_enabled: bool = True
+ code_exec_docker_name: str = "agent-zero-exe"
+ code_exec_docker_image: str = "frdel/agent-zero-exe:latest"
+ code_exec_docker_ports: dict[str,int] = field(default_factory=lambda: {"22/tcp": 50022})
+ code_exec_docker_volumes: dict[str, dict[str, str]] = field(default_factory=lambda: {files.get_abs_path("work_dir"): {"bind": "/root", "mode": "rw"}})
+ code_exec_ssh_enabled: bool = True
+ code_exec_ssh_addr: str = "localhost"
+ code_exec_ssh_port: int = 50022
+ code_exec_ssh_user: str = "root"
+ code_exec_ssh_pass: str = "toor"
+ additional: Dict[str, Any] = field(default_factory=dict)
+
class Agent:
paused=False
streaming_agent=None
- def __init__(self,
- agent_number: int,
- chat_model:BaseChatModel,
- embeddings_model:Embeddings,
- memory_subdir: str = "",
- auto_memory_count: int = 3,
- auto_memory_skip: int = 2,
- rate_limit_seconds: int = 60,
- rate_limit_requests: int = 30,
- rate_limit_input_tokens: int = 0,
- rate_limit_output_tokens: int = 0,
- msgs_keep_max: int = 25,
- msgs_keep_start: int = 5,
- msgs_keep_end: int = 10,
- max_tool_response_length: int = 3000,
- **kwargs):
-
- # agent config
- self.agent_number = agent_number
- self.chat_model = chat_model
- self.embeddings_model = embeddings_model
- self.memory_subdir = memory_subdir
- self.auto_memory_count = auto_memory_count
- self.auto_memory_skip = auto_memory_skip
- self.rate_limit_seconds = rate_limit_seconds
- self.rate_limit_requests = rate_limit_requests
- self.rate_limit_input_tokens = rate_limit_input_tokens
- self.rate_limit_output_tokens = rate_limit_output_tokens
- self.msgs_keep_max = msgs_keep_max
- self.msgs_keep_start = msgs_keep_start
- self.msgs_keep_end = msgs_keep_end
- self.max_tool_response_length = max_tool_response_length
+ def __init__(self, number:int, config: AgentConfig):
+
+ # agent config
+ self.config = config
# non-config vars
- self.agent_name = f"Agent {self.agent_number}"
+ self.number = number
+ self.agent_name = f"Agent {self.config.agent_number}"
self.system_prompt = files.read_file("./prompts/agent.system.md").replace("{", "{{").replace("}", "}}")
self.tools_prompt = files.read_file("./prompts/agent.tools.md").replace("{", "{{").replace("}", "}}")
@@ -61,7 +63,7 @@ class Agent:
self.last_message = ""
self.intervention_message = ""
self.intervention_status = False
- self.rate_limiter = RateLimiter(max_calls=rate_limit_requests,max_input_tokens=rate_limit_input_tokens,max_output_tokens=rate_limit_output_tokens,window_seconds=rate_limit_seconds)
+ self.rate_limiter = RateLimiter(max_calls=self.config.rate_limit_requests,max_input_tokens=self.config.rate_limit_input_tokens,max_output_tokens=self.config.rate_limit_output_tokens,window_seconds=self.config.rate_limit_seconds)
self.data = {} # free data object all the tools can use
os.chdir(files.get_abs_path("./work_dir")) #change CWD to work_dir
@@ -90,7 +92,7 @@ class Agent:
MessagesPlaceholder(variable_name="messages") ])
inputs = {"messages": self.history}
- chain = prompt | self.chat_model
+ chain = prompt | self.config.chat_model
formatted_inputs = prompt.format(messages=self.history)
tokens = int(len(formatted_inputs)/4)
@@ -147,7 +149,7 @@ class Agent:
else:
new_message = HumanMessage(content=msg) if human else AIMessage(content=msg)
self.history.append(new_message)
- self.cleanup_history(self.msgs_keep_max, self.msgs_keep_start, self.msgs_keep_end)
+ self.cleanup_history(self.config.msgs_keep_max, self.config.msgs_keep_start, self.config.msgs_keep_end)
if message_type=="ai":
self.last_message = msg
@@ -159,7 +161,7 @@ class Agent:
SystemMessage(content=system),
HumanMessage(content=msg)])
- chain = prompt | self.chat_model
+ chain = prompt | self.config.chat_model
response = ""
printer = None
@@ -251,12 +253,12 @@ class Agent:
def get_tool(self, name: str, args: dict, message: str, **kwargs):
- from tools.unknown import Unknown
- from tools.helpers.tool import Tool
+ from python.tools.unknown import Unknown
+ from python.helpers.tool import Tool
tool_class = Unknown
- if files.exists("tools",f"{name}.py"):
- module = importlib.import_module("tools." + name) # Import the module
+ if files.exists("python/tools",f"{name}.py"):
+ module = importlib.import_module("python.tools." + name) # Import the module
class_list = inspect.getmembers(module, inspect.isclass) # Get all functions in the module
for cls in class_list:
@@ -267,14 +269,15 @@ class Agent:
return tool_class(agent=self, name=name, args=args, message=message, **kwargs)
def fetch_memories(self,reset_skip=False):
+ if self.config.auto_memory_count<=0: return ""
if reset_skip: self.memory_skip_counter = 0
if self.memory_skip_counter > 0:
self.memory_skip_counter-=1
return ""
else:
- self.memory_skip_counter = self.auto_memory_skip
- from tools import memory_tool
+ self.memory_skip_counter = self.config.auto_memory_skip
+ from python.tools import memory_tool
messages = self.concat_messages(self.history)
memories = memory_tool.process_query(self,messages,"load")
input = {
@@ -283,4 +286,7 @@ class Agent:
}
cleanup_prompt = files.read_file("./prompts/msg.memory_cleanup.md").replace("{", "{{")
clean_memories = self.send_adhoc_message(cleanup_prompt,json.dumps(input), output_label="Memory injection")
- return clean_memories
\ No newline at end of file
+ return clean_memories
+
+ def call_extension(self, name: str, **kwargs) -> Any:
+ pass
\ No newline at end of file
diff --git a/main.py b/main.py
index fe3d59b96..279477099 100644
--- a/main.py
+++ b/main.py
@@ -1,21 +1,20 @@
-import threading, sys, time, readline, models, os
+import threading, time, models, os
from ansio import application_keypad, mouse_input, raw_input
from ansio.input import InputEvent, get_input_event
-from agent import Agent
-from tools.helpers.print_style import PrintStyle
-from tools.helpers.files import read_file
+from agent import Agent, AgentConfig
+from python.helpers.print_style import PrintStyle
+from python.helpers.files import read_file
from pytimedinput import timedInput as timed_input
-from tools.helpers import files
+from python.helpers import files
input_lock = threading.Lock()
os.chdir(files.get_abs_path("./work_dir")) #change CWD to work_dir
-# Main conversation loop
-def chat():
- # chat model used for agents
+def initialize():
+ # chat model used by agents
# chat_llm = models.get_groq_llama70b(temperature=0.2)
# chat_llm = models.get_groq_llama70b_json(temperature=0.2)
# chat_llm = models.get_groq_llama8b(temperature=0.2)
@@ -30,29 +29,51 @@ def chat():
# embedding model used for memory
# embedding_llm = models.get_embedding_openai()
embedding_llm = models.get_embedding_hf()
+
+ # agent configuration
+ config = AgentConfig(
+ agent_number = 0,
+ chat_model = chat_llm,
+ embeddings_model = embedding_llm,
+ # memory_subdir = "",
+ auto_memory_count = 0,
+ # auto_memory_skip = 2,
+ # rate_limit_seconds = 60,
+ # rate_limit_requests = 30,
+ # rate_limit_input_tokens = 0,
+ # rate_limit_output_tokens = 0,
+ # msgs_keep_max = 25,
+ # msgs_keep_start = 5,
+ # msgs_keep_end = 10,
+ # max_tool_response_length = 3000,
+ code_exec_docker_enabled = True,
+ # code_exec_docker_name = "agent-zero-exe",
+ # code_exec_docker_image = "frdel/agent-zero-exe:latest",
+ # code_exec_docker_ports = { "22/tcp": 50022 }
+ # code_exec_docker_volumes = { files.get_abs_path("work_dir"): {"bind": "/root", "mode": "rw"} }
+ code_exec_ssh_enabled = True,
+ # code_exec_ssh_addr = "localhost",
+ # code_exec_ssh_port = 50022,
+ # code_exec_ssh_user = "root",
+ # code_exec_ssh_pass = "toor",
+ # additional = {},
+ )
# create the first agent
- agent0 = Agent( agent_number=0,
- chat_model=chat_llm,
- embeddings_model=embedding_llm,
- # memory_subdir = "",
- # auto_memory_count = 3,
- # auto_memory_skip = 2,
- # rate_limit_seconds = 60,
- rate_limit_requests = 30,
- rate_limit_input_tokens = 160000,
- rate_limit_output_tokens = 8000,
- # msgs_keep_max = 25,
- # msgs_keep_start = 5,
- # msgs_keep_end = 10,
- # max_tool_response_length = 3000,
- )
+ agent0 = Agent( number = 0, config = config )
+
+ # start the chat loop
+ chat(agent0)
+
+# Main conversation loop
+def chat(agent:Agent):
+
# start the conversation loop
while True:
# ask user for message
with input_lock:
- timeout = agent0.get_data("timeout") # how long the agent is willing to wait
+ timeout = agent.get_data("timeout") # how long the agent is willing to wait
if not timeout: # if agent wants to wait for user input forever
PrintStyle(background_color="#6C3483", font_color="white", bold=True, padding=True).print(f"User message ('exit' to leave):")
user_input = input("> ")
@@ -77,10 +98,10 @@ def chat():
if user_input.lower() == 'exit': break
# send message to agent0,
- assistant_response = agent0.message_loop(user_input)
+ assistant_response = agent.message_loop(user_input)
# print agent0 response
- PrintStyle(font_color="white",background_color="#1D8348", bold=True, padding=True).print(f"{agent0.agent_name}: reponse:")
+ PrintStyle(font_color="white",background_color="#1D8348", bold=True, padding=True).print(f"{agent.agent_name}: reponse:")
PrintStyle(font_color="white").print(f"{assistant_response}")
@@ -123,4 +144,4 @@ if __name__ == "__main__":
threading.Thread(target=capture_keys, daemon=True).start()
# Start the chat
- chat()
\ No newline at end of file
+ initialize()
\ No newline at end of file
diff --git a/tools/__init__.py b/python/__init__.py
similarity index 100%
rename from tools/__init__.py
rename to python/__init__.py
diff --git a/tools/helpers/dirty_json.py b/python/helpers/dirty_json.py
similarity index 100%
rename from tools/helpers/dirty_json.py
rename to python/helpers/dirty_json.py
diff --git a/python/helpers/docker.py b/python/helpers/docker.py
new file mode 100644
index 000000000..85a245c3f
--- /dev/null
+++ b/python/helpers/docker.py
@@ -0,0 +1,49 @@
+import time
+import docker
+import atexit
+from typing import Dict, Optional
+from python.helpers.files import get_abs_path
+
+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
+ self.volumes = volumes
+ self.container = None
+
+
+
+ def cleanup_container(self) -> None:
+ if self.container:
+ try:
+ self.container.stop()
+ 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}")
+
+ def start_container(self) -> None:
+ existing_container = None
+ for container in self.client.containers.list():
+ if container.name == self.name:
+ existing_container = container
+ break
+
+ if existing_container:
+ #print(f"Container with name '{self.name}' is already running with ID: {existing_container.id}")
+ pass
+ else:
+ print(f"Initializing docker container {self.name}...")
+ 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(1) # this helps to get SSH ready
+
diff --git a/tools/helpers/errors.py b/python/helpers/errors.py
similarity index 100%
rename from tools/helpers/errors.py
rename to python/helpers/errors.py
diff --git a/tools/helpers/extract_tools.py b/python/helpers/extract_tools.py
similarity index 100%
rename from tools/helpers/extract_tools.py
rename to python/helpers/extract_tools.py
diff --git a/tools/helpers/files.py b/python/helpers/files.py
similarity index 100%
rename from tools/helpers/files.py
rename to python/helpers/files.py
diff --git a/tools/helpers/messages.py b/python/helpers/messages.py
similarity index 100%
rename from tools/helpers/messages.py
rename to python/helpers/messages.py
diff --git a/tools/helpers/perplexity_search.py b/python/helpers/perplexity_search.py
similarity index 100%
rename from tools/helpers/perplexity_search.py
rename to python/helpers/perplexity_search.py
diff --git a/tools/helpers/print_style.py b/python/helpers/print_style.py
similarity index 97%
rename from tools/helpers/print_style.py
rename to python/helpers/print_style.py
index 0e2b5ac21..316e61cbd 100644
--- a/tools/helpers/print_style.py
+++ b/python/helpers/print_style.py
@@ -1,4 +1,5 @@
import os, webcolors, html
+import sys
from datetime import datetime
from . import files
@@ -112,6 +113,10 @@ class PrintStyle:
self._log_html(html_text)
PrintStyle.last_endline = False
+ def is_last_line_empty(self):
+ lines = sys.stdin.readlines()
+ return bool(lines) and not lines[-1].strip()
+
# Ensure HTML file is closed properly when the program exits
import atexit
atexit.register(PrintStyle._close_html_log)
diff --git a/tools/helpers/rate_limiter.py b/python/helpers/rate_limiter.py
similarity index 100%
rename from tools/helpers/rate_limiter.py
rename to python/helpers/rate_limiter.py
diff --git a/python/helpers/shell_local.py b/python/helpers/shell_local.py
new file mode 100644
index 000000000..8f389b764
--- /dev/null
+++ b/python/helpers/shell_local.py
@@ -0,0 +1,68 @@
+import select
+import subprocess
+import time
+import sys
+from typing import Optional, Tuple
+
+class LocalInteractiveSession:
+ def __init__(self):
+ self.process = None
+ self.full_output = ''
+
+ def connect(self):
+ # Start a new subprocess with the appropriate shell for the OS
+ if sys.platform.startswith('win'):
+ # Windows
+ self.process = subprocess.Popen(
+ ['cmd.exe'],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ text=True,
+ bufsize=1
+ )
+ else:
+ # macOS and Linux
+ self.process = subprocess.Popen(
+ ['/bin/bash'],
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE,
+ text=True,
+ bufsize=1
+ )
+
+ def close(self):
+ if self.process:
+ self.process.terminate()
+ self.process.wait()
+
+ def send_command(self, command: str):
+ if not self.process:
+ raise Exception("Shell not connected")
+ self.full_output = ""
+ self.process.stdin.write(command + '\n') # type: ignore
+ self.process.stdin.flush() # type: ignore
+
+ def read_output(self) -> Tuple[str, Optional[str]]:
+ if not self.process:
+ raise Exception("Shell not connected")
+
+ partial_output = ''
+ while True:
+ rlist, _, _ = select.select([self.process.stdout], [], [], 0.1)
+ if rlist:
+ line = self.process.stdout.readline() # type: ignore
+ if line:
+ partial_output += line
+ self.full_output += line
+ time.sleep(0.1)
+ else:
+ break # No more output
+ else:
+ break # No data available
+
+ if not partial_output:
+ return self.full_output, None
+
+ return self.full_output, partial_output
\ No newline at end of file
diff --git a/python/helpers/shell_ssh.py b/python/helpers/shell_ssh.py
new file mode 100644
index 000000000..fe3b7f88c
--- /dev/null
+++ b/python/helpers/shell_ssh.py
@@ -0,0 +1,71 @@
+import paramiko
+import time
+import re
+from typing import Optional, Tuple
+
+class SSHInteractiveSession:
+ def __init__(self, hostname: str, port: int, username: str, password: str):
+ self.hostname = hostname
+ self.port = port
+ self.username = username
+ self.password = password
+ self.client = paramiko.SSHClient()
+ self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+ self.shell = None
+ self.full_output = ''
+
+ def connect(self):
+ # try 3 times with wait and then except
+ errors = 0
+ while True:
+ try:
+ self.client.connect(self.hostname, self.port, self.username, self.password)
+ self.shell = self.client.invoke_shell()
+ while True: # wait for end of initial output
+ full, part = self.read_output()
+ if full and not part: return
+ time.sleep(0.1)
+ except Exception as e:
+ errors += 1
+ if errors < 3:
+ print(f"SSH Connection attempt {errors}...")
+ time.sleep(5)
+ else:
+ raise e
+
+ def close(self):
+ if self.shell:
+ self.shell.close()
+ if self.client:
+ self.client.close()
+
+ def send_command(self, command: str):
+ if not self.shell:
+ raise Exception("Shell not connected")
+ self.full_output = ""
+ self.shell.send((command + '\n').encode())
+
+ def read_output(self) -> Tuple[str, str]:
+ if not self.shell:
+ raise Exception("Shell not connected")
+
+ partial_output = ''
+ while self.shell.recv_ready():
+ data = self.shell.recv(1024).decode('utf-8')
+ data = self.clean_string(data)
+ partial_output += data
+ self.full_output += data
+ time.sleep(0.1) # Prevent busy waiting
+
+ self.full_output = self.clean_string(self.full_output)
+ return self.full_output, partial_output
+
+ def clean_string(self, input_string):
+ # Remove ANSI escape codes
+ ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+ cleaned = ansi_escape.sub('', input_string)
+
+ # Replace '\r\n' with '\n'
+ cleaned = cleaned.replace('\r\n', '\n')
+
+ return cleaned
\ No newline at end of file
diff --git a/tools/helpers/tool.py b/python/helpers/tool.py
similarity index 91%
rename from tools/helpers/tool.py
rename to python/helpers/tool.py
index 1b5979676..20e672dfd 100644
--- a/tools/helpers/tool.py
+++ b/python/helpers/tool.py
@@ -1,8 +1,8 @@
from abc import abstractmethod
from typing import TypedDict
from agent import Agent
-from tools.helpers.print_style import PrintStyle
-from tools.helpers import files, messages
+from python.helpers.print_style import PrintStyle
+from python.helpers import files, messages
class Response:
def __init__(self, message: str, break_loop: bool) -> None:
@@ -30,7 +30,7 @@ class Tool:
PrintStyle().print()
def after_execution(self, response: Response, **kwargs):
- text = messages.truncate_text(response.message.strip(), self.agent.max_tool_response_length)
+ text = messages.truncate_text(response.message.strip(), self.agent.config.max_tool_response_length)
msg_response = files.read_file("./prompts/fw.tool_response.md", tool_name=self.name, tool_response=text)
self.agent.append_message(msg_response, human=True)
PrintStyle(font_color="#1B4F72", background_color="white", padding=True, bold=True).print(f"{self.agent.agent_name}: Response from tool '{self.name}':")
diff --git a/tools/helpers/vector_db.py b/python/helpers/vector_db.py
similarity index 100%
rename from tools/helpers/vector_db.py
rename to python/helpers/vector_db.py
diff --git a/tools/call_subordinate.py b/python/tools/call_subordinate.py
similarity index 76%
rename from tools/call_subordinate.py
rename to python/tools/call_subordinate.py
index a0f55c211..2d2f4c5e9 100644
--- a/tools/call_subordinate.py
+++ b/python/tools/call_subordinate.py
@@ -1,7 +1,7 @@
from agent import Agent
-from tools.helpers.tool import Tool, Response
-from tools.helpers import files
-from tools.helpers.print_style import PrintStyle
+from python.helpers.tool import Tool, Response
+from python.helpers import files
+from python.helpers.print_style import PrintStyle
class Delegation(Tool):
@@ -10,7 +10,7 @@ class Delegation(Tool):
if self.agent.get_data("subordinate") is None or str(reset).lower().strip() == "true":
# subordinate = Agent(system_prompt=self.agent.system_prompt, tools_prompt=self.agent.tools_prompt, number=self.agent.number+1)
config = self.agent.__dict__.copy()
- config["agent_number"] = self.agent.agent_number+1
+ config["agent_number"] = self.agent.number+1
subordinate = Agent(**config)
subordinate.set_data("superior", self.agent)
self.agent.set_data("subordinate", subordinate)
diff --git a/python/tools/code_execution_tool.py b/python/tools/code_execution_tool.py
new file mode 100644
index 000000000..c64dc6bd3
--- /dev/null
+++ b/python/tools/code_execution_tool.py
@@ -0,0 +1,93 @@
+from dataclasses import dataclass
+import os, json, contextlib, subprocess, ast, shlex
+from io import StringIO
+import time
+from typing import Literal
+from python.helpers import files, messages
+from agent import Agent
+from python.helpers.tool import Tool, Response
+from python.helpers import files
+from python.helpers.print_style import PrintStyle
+from python.helpers.shell_local import LocalInteractiveSession
+from python.helpers.shell_ssh import SSHInteractiveSession
+from python.helpers.docker import DockerContainerManager
+
+@dataclass
+class State:
+ shell: LocalInteractiveSession | SSHInteractiveSession
+ docker: DockerContainerManager | None
+
+
+class CodeExecution(Tool):
+
+ def execute(self,**kwargs):
+ self.prepare_state()
+
+ # os.chdir(files.get_abs_path("./work_dir")) #change CWD to work_dir
+
+ runtime = self.args["runtime"].lower().strip()
+ if runtime == "python":
+ response = self.execute_python_code(self.args["code"])
+ elif runtime == "nodejs":
+ response = self.execute_nodejs_code(self.args["code"])
+ elif runtime == "terminal":
+ response = self.execute_terminal_command(self.args["code"])
+ else:
+ response = files.read_file("./prompts/fw.code_runtime_wrong.md", runtime=runtime)
+
+ if not response: response = files.read_file("./prompts/fw.code_no_output.md")
+ return Response(message=response, break_loop=False)
+
+ def after_execution(self, response, **kwargs):
+ msg_response = files.read_file("./prompts/fw.tool_response.md", tool_name=self.name, tool_response=response.message)
+ self.agent.append_message(msg_response, human=True)
+
+ def prepare_state(self):
+ self.state = self.agent.get_data("cot_state")
+ if not self.state:
+
+ #initialize docker container if execution in docker is configured
+ if self.agent.config.code_exec_docker_enabled:
+ docker = DockerContainerManager(name=self.agent.config.code_exec_docker_name, image=self.agent.config.code_exec_docker_image, ports=self.agent.config.code_exec_docker_ports, volumes=self.agent.config.code_exec_docker_volumes)
+ docker.start_container()
+ else: docker = None
+
+ #initialize local or remote interactive shell insterface
+ if self.agent.config.code_exec_ssh_enabled:
+ shell = SSHInteractiveSession(self.agent.config.code_exec_ssh_addr,self.agent.config.code_exec_ssh_port,self.agent.config.code_exec_ssh_user,self.agent.config.code_exec_ssh_pass)
+ else: shell = LocalInteractiveSession()
+
+ self.state = State(shell=shell,docker=docker)
+ shell.connect()
+ self.agent.set_data("cot_state", self.state)
+
+ def execute_python_code(self, code):
+ escaped_code = shlex.quote(code)
+ command = f'python3 -c {escaped_code}'
+ return self.terminal_session(command)
+
+ def execute_nodejs_code(self, code):
+ escaped_code = shlex.quote(code)
+ command = f'node -e {escaped_code}'
+ return self.terminal_session(command)
+
+ def execute_terminal_command(self, command):
+ return self.terminal_session(command)
+
+ def terminal_session(self, command):
+ self.state.shell.send_command(command)
+
+ PrintStyle(background_color="white",font_color="#85C1E9",bold=True).print(f"{self.agent.agent_name} code execution output:")
+
+ idle=0
+ while True:
+ time.sleep(0.1) # Wait for some output to be generated
+ full_output, partial_output = self.state.shell.read_output()
+
+ if partial_output:
+ PrintStyle(font_color="#85C1E9").stream(partial_output)
+ idle=0
+ else:
+ idle+=1
+ if ( full_output and idle > 30 ) or ( not full_output and idle > 100 ): return full_output
+
\ No newline at end of file
diff --git a/tools/knowledge_tool.py b/python/tools/knowledge_tool.py
similarity index 84%
rename from tools/knowledge_tool.py
rename to python/tools/knowledge_tool.py
index 062d159ee..b7b574f10 100644
--- a/tools/knowledge_tool.py
+++ b/python/tools/knowledge_tool.py
@@ -5,8 +5,8 @@ import concurrent.futures
-from tools.helpers.tool import Tool, Response
-from tools.helpers import files
+from python.helpers.tool import Tool, Response
+from python.helpers import files
class Knowledge(Tool):
def execute(self, question="", **kwargs):
diff --git a/tools/memorize.py b/python/tools/memorize.py
similarity index 70%
rename from tools/memorize.py
rename to python/tools/memorize.py
index a535d7151..bdef2032c 100644
--- a/tools/memorize.py
+++ b/python/tools/memorize.py
@@ -1,7 +1,7 @@
from agent import Agent
-from tools.helpers import files
-from tools.helpers.tool import Tool, Response
-from tools import memory_tool
+from python.helpers import files
+from python.helpers.tool import Tool, Response
+import memory_tool
class Memorize(Tool):
def execute(self,**kwargs):
diff --git a/tools/memory_tool.py b/python/tools/memory_tool.py
similarity index 76%
rename from tools/memory_tool.py
rename to python/tools/memory_tool.py
index 73117079d..31eb1ec7f 100644
--- a/tools/memory_tool.py
+++ b/python/tools/memory_tool.py
@@ -1,16 +1,15 @@
from agent import Agent
-from tools.helpers.vector_db import VectorDB, Document
-from tools.helpers import files
+from python.helpers.vector_db import VectorDB, Document
+from python.helpers import files
import os, json
-from tools.helpers.tool import Tool, Response
-from tools.helpers.print_style import PrintStyle
+from python.helpers.tool import Tool, Response
+from python.helpers.print_style import PrintStyle
db: VectorDB | None = None
class Memory(Tool):
def execute(self,**kwargs):
- #TODO separate param for memory tool result count
- result = process_query(self.agent, self.args["memory"],self.args["action"], result_count=self.agent.auto_memory_count)
+ result = process_query(self.agent, self.args["memory"],self.args["action"], result_count=self.agent.config.auto_memory_count)
return Response(message="\n\n".join(result), break_loop=False)
@@ -21,7 +20,7 @@ def initialize(embeddings_model, subdir=""):
def process_query(agent:Agent, message: str, action: str = "load", result_count: int = 3, **kwargs):
- if not db: initialize(agent.embeddings_model, subdir=agent.memory_subdir)
+ if not db: initialize(agent.config.embeddings_model, subdir=agent.config.memory_subdir)
if action.strip().lower() == "save":
id = db.insert_document(str(message)) # type: ignore
diff --git a/tools/online_knowledge_tool.py b/python/tools/online_knowledge_tool.py
similarity index 61%
rename from tools/online_knowledge_tool.py
rename to python/tools/online_knowledge_tool.py
index 8c30bd4ee..852116e25 100644
--- a/tools/online_knowledge_tool.py
+++ b/python/tools/online_knowledge_tool.py
@@ -1,6 +1,6 @@
from agent import Agent
-from tools.helpers import perplexity_search
-from tools.helpers.tool import Tool, Response
+from python.helpers import perplexity_search
+from python.helpers.tool import Tool, Response
class OnlineKnowledge(Tool):
def execute(self,**kwargs):
diff --git a/tools/response.py b/python/tools/response.py
similarity index 57%
rename from tools/response.py
rename to python/tools/response.py
index e5325bc72..1f89c9072 100644
--- a/tools/response.py
+++ b/python/tools/response.py
@@ -1,11 +1,11 @@
from agent import Agent
-from tools.helpers import files
-from tools.helpers.print_style import PrintStyle
+from python.helpers import files
+from python.helpers.print_style import PrintStyle
from agent import Agent
-from tools.helpers.tool import Tool, Response
-from tools.helpers import files
-from tools.helpers.print_style import PrintStyle
+from python.helpers.tool import Tool, Response
+from python.helpers import files
+from python.helpers.print_style import PrintStyle
class ResponseTool(Tool):
diff --git a/tools/task_done.py b/python/tools/task_done.py
similarity index 57%
rename from tools/task_done.py
rename to python/tools/task_done.py
index bea54a139..46de1ac8d 100644
--- a/tools/task_done.py
+++ b/python/tools/task_done.py
@@ -1,11 +1,11 @@
from agent import Agent
-from tools.helpers import files
-from tools.helpers.print_style import PrintStyle
+from python.helpers import files
+from python.helpers.print_style import PrintStyle
from agent import Agent
-from tools.helpers.tool import Tool, Response
-from tools.helpers import files
-from tools.helpers.print_style import PrintStyle
+from python.helpers.tool import Tool, Response
+from python.helpers import files
+from python.helpers.print_style import PrintStyle
class TaskDone(Tool):
diff --git a/tools/unknown.py b/python/tools/unknown.py
similarity index 81%
rename from tools/unknown.py
rename to python/tools/unknown.py
index 47e110e79..d0a1552de 100644
--- a/tools/unknown.py
+++ b/python/tools/unknown.py
@@ -1,5 +1,5 @@
-from tools.helpers.tool import Tool, Response
-from tools.helpers import files
+from python.helpers.tool import Tool, Response
+from python.helpers import files
class Unknown(Tool):
def execute(self, **kwargs):
diff --git a/requirements.txt b/requirements.txt
index bff52ad79..0906b25b7 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -9,3 +9,5 @@ langchain-chroma==0.1.1
webcolors==24.6.0
sentence-transformers==3.0.1
pytimedinput==2.0.1
+docker==7.1.0
+paramiko==3.4.0
diff --git a/tools/code_execution_tool.py b/tools/code_execution_tool.py
deleted file mode 100644
index 7012c8ae8..000000000
--- a/tools/code_execution_tool.py
+++ /dev/null
@@ -1,38 +0,0 @@
-import os, json, contextlib, subprocess, ast, shlex
-from io import StringIO
-from tools.helpers import files, messages
-from agent import Agent
-from tools.helpers.tool import Tool, Response
-from tools.helpers import files
-from tools.helpers.print_style import PrintStyle
-
-class CodeExecution(Tool):
-
- def execute(self,**kwargs):
-
- # os.chdir(files.get_abs_path("./work_dir")) #change CWD to work_dir
-
- runtime = self.args["runtime"].lower().strip()
- if runtime == "python":
- response = self.execute_python_code(self.args["code"])
- elif runtime == "nodejs":
- response = self.execute_nodejs_code(self.args["code"])
- elif runtime == "terminal":
- response = self.execute_terminal_command(self.args["code"])
- else:
- response = files.read_file("./prompts/fw.code_runtime_wrong.md", runtime=runtime)
-
- if not response: response = files.read_file("./prompts/fw.code_no_output.md")
- return Response(message=response, break_loop=False)
-
- def execute_python_code(self, code, input_data="y\n"):
- result = subprocess.run(['python', '-c', code], capture_output=True, text=True, input=input_data)
- return result.stdout + result.stderr
-
- def execute_nodejs_code(self, code, input_data="y\n"):
- result = subprocess.run(['node', '-e', code], capture_output=True, text=True, input=input_data)
- return result.stdout + result.stderr
-
- def execute_terminal_command(self, command, input_data="y\n"):
- result = subprocess.run(command, shell=True, capture_output=True, text=True, input=input_data)
- return result.stdout + result.stderr
\ No newline at end of file