convert codeact agent into a compatible agent

agenthub/codeact_agent/README.md

@@ -5,9 +5,11 @@ This folder implements the [CodeAct idea](https://arxiv.org/abs/2402.13463) that
 A minimalistic exmaple can be found at [research/codeact/examples/run_flask_server_with_bash.py](./examples/run_flask_server_with_bash.py):
 
 ```bash
-python3 examples/run_flask_server_with_bash.py
+mkdir workspace
+PYTHONPATH=`pwd`:$PYTHONPATH python3 opendevin/main.py -d ./workspace -c CodeActAgent -t "Please write a flask app that returns 'Hello, World\!' at the root URL, then start the app on port 5000. python3 has already been installed for you."
 ```
 
+
 Example: prompts `gpt-3.5-turbo-0125` to write a flask server, install `flask` library, and start the server.
 
 <img width="951" alt="image" src="https://github.com/OpenDevin/OpenDevin/assets/38853559/325c3115-a343-4cc5-a92b-f1e5d552a077">

agenthub/codeact_agent/__init__.py

@@ -5,7 +5,7 @@
 from termcolor import colored
 from typing import List, Dict
 
-from opendevin.agent import Agent, Message
+from opendevin.agent import Agent, Message, Role
 from opendevin.sandbox.docker import DockerInteractive
 
 assert (
@@ -50,20 +50,25 @@ def parse_response(response) -> str:
 
 
 class CodeActAgent(Agent):
-    def __init__(self, instruction: str, max_steps: int = 100) -> None:
+    def __init__(
+        self,
+        instruction: str,
+        workspace_dir: str,
+        model_name: str,
+        max_steps: int = 100
+    ) -> None:
         """
         Initializes a new instance of the CodeActAgent class.
 
         Parameters:
         - instruction (str): The instruction for the agent to execute.
         - max_steps (int): The maximum number of steps to run the agent.
         """
-        super().__init__(instruction, max_steps)
-        self._history = [Message(Agent.SYSTEM, SYSTEM_MESSAGE)]
-        self._history.append(Message(Agent.USER, instruction))
-        self.env = DockerInteractive("opendevin/sandbox:latest")
-
-        self.model_name = "gpt-3.5-turbo-0125"  # TODO: hard-coded here, will need to accept this as an argument in future PR
+        super().__init__(instruction, workspace_dir, model_name, max_steps)
+        self._history = [Message(Role.SYSTEM, SYSTEM_MESSAGE)]
+        self._history.append(Message(Role.USER, instruction))
+        self.env = DockerInteractive(workspace_dir=workspace_dir)
+        print(colored("===USER:===\n" + instruction, "green"))
 
     def _history_to_messages(self) -> List[Dict]:
         return [message.to_dict() for message in self._history]
@@ -73,7 +78,7 @@ def run(self) -> None:
         Starts the execution of the assigned instruction. This method should
         be implemented by subclasses to define the specific execution logic.
         """
-        for _ in range(self.max_turns):
+        for _ in range(self.max_steps):
             response = completion(
                 messages=self._history_to_messages(),
                 model=self.model_name,
@@ -82,7 +87,7 @@ def run(self) -> None:
                 seed=42,
             )
             action = parse_response(response)
-            self._history.append(Message(Agent.ASSISTANT, action))
+            self._history.append(Message(Role.ASSISTANT, action))
             print(colored("===ASSISTANT:===\n" + action, "yellow"))
 
             command = re.search(r"<execute>(.*)</execute>", action, re.DOTALL)
@@ -94,13 +99,13 @@ def run(self) -> None:
                     break
                 # execute the code
                 observation = self.env.execute(command)
-                self._history.append(Message(Agent.ASSISTANT, observation))
+                self._history.append(Message(Role.ASSISTANT, observation))
                 print(colored("===ENV OBSERVATION:===\n" + observation, "blue"))
             else:
                 # we could provide a error message for the model to continue similar to
                 # https://github.com/xingyaoww/mint-bench/blob/main/mint/envs/general_env.py#L18-L23
                 observation = INVALID_INPUT_MESSAGE
-                self._history.append(Message(Agent.ASSISTANT, observation))
+                self._history.append(Message(Role.ASSISTANT, observation))
                 print(colored("===ENV OBSERVATION:===\n" + observation, "blue"))
 
         self.env.close()

opendevin/agent.py

@@ -41,16 +41,25 @@ class Agent(ABC):
     executing a specific instruction and allowing human interaction with the
     agent during execution.
     It tracks the execution status and maintains a history of interactions.
+
+    :param instruction: The instruction for the agent to execute.
+    :param workspace_dir: The working directory for the agent.
+    :param model_name: The litellm name of the model to use for the agent.
+    :param max_steps: The maximum number of steps to run the agent.
     """
 
     _registry: Dict[str, Type['Agent']] = {}
 
     def __init__(
         self,
         instruction: str,
+        workspace_dir: str,
+        model_name: str,
         max_steps: int = 100
     ):
         self.instruction = instruction
+        self.workspace_dir = workspace_dir
+        self.model_name = model_name
         self.max_steps = max_steps
 
         self._complete = False
@@ -119,18 +128,16 @@ def register(cls, name: str, agent_cls: Type['Agent']):
         cls._registry[name] = agent_cls
 
     @classmethod
-    def create_instance(cls, name: str, instruction: str) -> 'Agent':
+    def get_cls(cls, name: str) -> Type['Agent']:
         """
-        Creates an instance of a registered agent class based on the given name.
+        Retrieves an agent class from the registry.
 
         Parameters:
-        - name (str): The name of the agent class to instantiate.
-        - instruction (str): The instruction for the new agent instance.
+        - name (str): The name of the class to retrieve
 
         Returns:
-        - An instance of the specified agent class.
+        - agent_cls (Type['Agent']): The class registered under the specified name.
         """
         if name not in cls._registry:
             raise ValueError(f"No agent class registered under '{name}'.")
-        agent_cls = cls._registry[name]
-        return agent_cls(instruction)
+        return cls._registry[name]

opendevin/main.py

@@ -9,10 +9,13 @@
     parser.add_argument("-d", "--directory", required=True, type=str, help="The working directory for the agent")
     parser.add_argument("-t", "--task", required=True, type=str, help="The task for the agent to perform")
     parser.add_argument("-c", "--agent-cls", default="LangchainsAgent", type=str, help="The agent class to use")
+    parser.add_argument("-m", "--model-name", default="gpt-3.5-turbo-0125", type=str, help="The (litellm) model name to use")
     args = parser.parse_args()
 
-    print("Working in directory:", args.directory)
-    os.chdir(args.directory)
-
-    agent = Agent.create_instance(args.agent_cls, args.task)
+    AgentCls: Agent = Agent.get_cls(args.agent_cls)
+    agent = AgentCls(
+        instruction=args.task,
+        workspace_dir=args.directory,
+        model_name=args.model_name
+    )
     agent.run()