Merge remote-tracking branch 'upstream/main' into MemGPT

agenthub/codeact_agent/codeact_agent.py

@@ -1,5 +1,3 @@
-#######
-
 from litellm.exceptions import ContextWindowExceededError
 
 from agenthub.codeact_agent.action_parser import CodeActResponseParser
@@ -12,7 +10,6 @@
 )
 from opendevin.controller.agent import Agent
 from opendevin.controller.state.state import State
-from opendevin.core.config import config
 from opendevin.core.exceptions import (
     ContextWindowLimitExceededError,
     SummarizeError,
@@ -44,72 +41,9 @@
 )
 from opendevin.runtime.tools import RuntimeTool
 
-#######
-
 ENABLE_GITHUB = True
 
 
-def action_to_str(action: Action) -> str:
-    if isinstance(action, CmdRunAction):
-        return f'{action.thought}\n<execute_bash>\n{action.command}\n</execute_bash>'
-    elif isinstance(action, IPythonRunCellAction):
-        return f'{action.thought}\n<execute_ipython>\n{action.code}\n</execute_ipython>'
-    elif isinstance(action, AgentDelegateAction):
-        return f'{action.thought}\n<execute_browse>\n{action.inputs["task"]}\n</execute_browse>'
-    elif isinstance(action, MessageAction):
-        return action.content
-    elif isinstance(action, AgentSummarizeAction):
-        return action.summarized_actions
-    return ''
-
-
-def get_action_message(action: Action) -> dict[str, str] | None:
-    if (
-        isinstance(action, AgentDelegateAction)
-        or isinstance(action, CmdRunAction)
-        or isinstance(action, IPythonRunCellAction)
-        or isinstance(action, MessageAction)
-        or isinstance(action, AgentSummarizeAction)
-    ):
-        return {
-            'role': 'user' if action.source == 'user' else 'assistant',
-            'content': action_to_str(action),
-        }
-    return None
-
-
-def get_observation_message(obs) -> dict[str, str] | None:
-    max_message_chars = config.get_llm_config_from_agent(
-        'CodeActAgent'
-    ).max_message_chars
-    if isinstance(obs, CmdOutputObservation):
-        content = 'OBSERVATION:\n' + truncate_content(obs.content, max_message_chars)
-        content += (
-            f'\n[Command {obs.command_id} finished with exit code {obs.exit_code}]'
-        )
-        return {'role': 'user', 'content': content}
-    elif isinstance(obs, IPythonRunCellObservation):
-        content = 'OBSERVATION:\n' + obs.content
-        # replace base64 images with a placeholder
-        splitted = content.split('\n')
-        for i, line in enumerate(splitted):
-            if '![image](data:image/png;base64,' in line:
-                splitted[i] = (
-                    '![image](data:image/png;base64, ...) already displayed to user'
-                )
-        content = '\n'.join(splitted)
-        content = truncate_content(content, max_message_chars)
-        return {'role': 'user', 'content': content}
-    elif isinstance(obs, AgentDelegateObservation):
-        content = 'OBSERVATION:\n' + truncate_content(
-            str(obs.outputs), max_message_chars
-        )
-        return {'role': 'user', 'content': content}
-    elif isinstance(obs, AgentSummarizeAction):
-        return {'role': 'user', 'content': obs.summarized_observations}
-    return None
-
-
 # FIXME: We can tweak these two settings to create MicroAgents specialized toward different area
 def get_system_message() -> str:
     if ENABLE_GITHUB:
@@ -199,6 +133,14 @@ def action_to_str(self, action: Action) -> str:
             return f'{action.thought}\n<execute_browse>\n{action.inputs["task"]}\n</execute_browse>'
         elif isinstance(action, MessageAction):
             return action.content
+        elif isinstance(action, AgentSummarizeAction):
+            return (
+                'Summary of all Action and Observations till now. \n'
+                + 'Action: '
+                + action.summarized_actions
+                + '\n Observation: '
+                + action.summarized_observations
+            )
         return ''
 
     def get_action_message(self, action: Action) -> dict[str, str] | None:
@@ -207,6 +149,7 @@ def get_action_message(self, action: Action) -> dict[str, str] | None:
             or isinstance(action, CmdRunAction)
             or isinstance(action, IPythonRunCellAction)
             or isinstance(action, MessageAction)
+            or isinstance(action, AgentSummarizeAction)
         ):
             return {
                 'role': 'user' if action.source == 'user' else 'assistant',
@@ -325,21 +268,17 @@ def condense(
         for event in history.get_events():
             if event.id >= history.last_summarized_event_id:
                 if isinstance(event, AgentSummarizeAction):
-                    action_message = get_action_message(event)
+                    action_message = self.get_action_message(event)
                     if action_message:
                         candidate_messages_to_summarize.append(action_message)
                         tokens_so_far += self.llm.get_token_count([action_message])
-                    observation_message = get_observation_message(event)
-                    if observation_message:
-                        candidate_messages_to_summarize.append(observation_message)
-                        tokens_so_far += self.llm.get_token_count([observation_message])
-                    continue
                 else:
-                    message = (
-                        get_action_message(event)
-                        if isinstance(event, Action)
-                        else get_observation_message(event)
-                    )
+                    if isinstance(event, Action):
+                        message = self.get_action_message(event)
+                    elif isinstance(event, Observation):
+                        message = self.get_observation_message(event)
+                    else:
+                        raise ValueError(f'Unknown event type: {type(event)}')
                     if message:
                         candidate_messages_to_summarize.append(message)
                         tokens_so_far += self.llm.get_token_count([message])
@@ -401,24 +340,21 @@ def _get_messages(self, state: State) -> list[dict[str, str]]:
         for event in state.history.get_events():
             if event.id >= state.history.last_summarized_event_id:
                 if isinstance(event, AgentSummarizeAction):
-                    action_message = get_action_message(event)
+                    action_message = self.get_action_message(event)
                     if action_message:
                         messages.append(action_message)
-                    observation_message = get_observation_message(event)
-                    if observation_message:
-                        messages.append(observation_message)
-                    continue
-
-                # create a regular message from an event
-                message = (
-                    get_action_message(event)
-                    if isinstance(event, Action)
-                    else get_observation_message(event)
-                )
-
-                # add regular message
-                if message:
-                    messages.append(message)
+                else:
+                    # create a regular message from an event
+                    if isinstance(event, Action):
+                        message = self.get_action_message(event)
+                    elif isinstance(event, Observation):
+                        message = self.get_observation_message(event)
+                    else:
+                        raise ValueError(f'Unknown event type: {type(event)}')
+
+                    # add regular message
+                    if message:
+                        messages.append(message)
 
         # the latest user message is important:
         # we want to remind the agent of the environment constraints

opendevin/core/config.py

@@ -61,7 +61,8 @@ class LLMConfig:
     aws_access_key_id: str | None = None
     aws_secret_access_key: str | None = None
     aws_region_name: str | None = None
-    num_retries: int = 15
+    num_retries: int = 10
+    retry_multiplier: float = 2
     retry_min_wait: int = 3
     retry_max_wait: int = 300
     timeout: int | None = None

opendevin/llm/llm.py

@@ -53,22 +53,9 @@ def __init__(
             config: The LLM configuration
         """
 
-        logger.info(f'Initializing LLM with model: {model}')
-        self.model_name = model
-        self.api_key = api_key
-        self.base_url = base_url
-        self.api_version = api_version
-        self.max_input_tokens = max_input_tokens
-        ###############
-        # self.max_input_tokens = 6000
-        ###############
-        self.max_output_tokens = max_output_tokens
-        self.input_cost_per_token = input_cost_per_token
-        self.output_cost_per_token = output_cost_per_token
-        self.llm_timeout = llm_timeout
-        self.custom_llm_provider = custom_llm_provider
-        self.metrics = metrics
-        self.cost_metric_supported = cost_metric_supported
+        self.config = copy.deepcopy(config)
+        self.metrics = metrics if metrics is not None else Metrics()
+        self.cost_metric_supported = True
 
         # litellm actually uses base Exception here for unknown model
         self.model_info = None
@@ -92,7 +79,7 @@ def __init__(
             else:
                 # Max input tokens for gpt3.5, so this is a safe fallback for any potentially viable model
                 self.config.max_input_tokens = 4096
-
+        self.config.max_input_tokens = 6000
         if config.max_output_tokens is None:
             if (
                 self.model_info is not None
@@ -203,9 +190,9 @@ def get_token_count(self, messages):
             int: The number of tokens.
         """
         if isinstance(messages, list):
-            return litellm.token_counter(model=self.model_name, messages=messages)
+            return litellm.token_counter(model=self.config.model, messages=messages)
         elif isinstance(messages, str):
-            return litellm.token_counter(model=self.model_name, text=messages)
+            return litellm.token_counter(model=self.config.model, text=messages)
 
     def is_local(self):
         """Determines if the system is using a locally running LLM.
@@ -282,10 +269,10 @@ def is_over_token_limit(self, messages: list[dict]) -> bool:
         # max_input_tokens will always be set in init to some sensible default
         # 0 in config.llm disables the check
         MAX_TOKEN_COUNT_PADDING = 512
-        if not self.max_input_tokens:
+        if not self.config.max_input_tokens:
             return False
         token_count = (
-            litellm.token_counter(model=self.model_name, messages=messages)
+            litellm.token_counter(model=self.config.model, messages=messages)
             + MAX_TOKEN_COUNT_PADDING
         )
-        return token_count >= self.max_input_tokens
+        return token_count >= self.config.max_input_tokens

opendevin/memory/condenser.py

@@ -38,11 +38,12 @@ def _format_summary_history(self, message_history: list[dict]):
 
     def summarize_messages(self, message_sequence_to_summarize: list[dict]):
         """Summarize a message sequence using LLM"""
-        context_window = self.llm.max_input_tokens
+        context_window = self.llm.config.max_input_tokens
         summary_prompt = SUMMARY_PROMPT_SYSTEM
         summary_input = self._format_summary_history(message_sequence_to_summarize)
         summary_input_tkns = self.llm.get_token_count(summary_input)
-
+        if context_window is None:
+            raise ValueError('context_window should not be None')
         if summary_input_tkns > MESSAGE_SUMMARY_WARNING_FRAC * context_window:
             trunc_ratio = (
                 MESSAGE_SUMMARY_WARNING_FRAC * context_window / summary_input_tkns