camel-ai 0.2.62__tar.gz → 0.2.64__tar.gz

{camel_ai-0.2.62 → camel_ai-0.2.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.62
+Version: 0.2.64
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -66,6 +66,7 @@ Requires-Dist: ibm-watsonx-ai>=1.3.11; extra == 'all'
 Requires-Dist: imageio[pyav]<3,>=2.34.2; extra == 'all'
 Requires-Dist: ipykernel<7,>=6.0.0; extra == 'all'
 Requires-Dist: jupyter-client<9,>=8.6.2; extra == 'all'
+Requires-Dist: langfuse>=2.60.5; extra == 'all'
 Requires-Dist: linkup-sdk<0.3,>=0.2.1; extra == 'all'
 Requires-Dist: litellm<2,>=1.38.1; extra == 'all'
 Requires-Dist: markitdown==0.1.1; extra == 'all'
@@ -136,6 +137,7 @@ Requires-Dist: types-requests<3,>=2.31.0; extra == 'all'
 Requires-Dist: types-setuptools<70,>=69.2.0; extra == 'all'
 Requires-Dist: types-tqdm<5,>=4.66.0; extra == 'all'
 Requires-Dist: unstructured==0.16.20; extra == 'all'
+Requires-Dist: weaviate-client>=4.15.0; extra == 'all'
 Requires-Dist: wikipedia<2,>=1; extra == 'all'
 Requires-Dist: wolframalpha<6,>=5.0.0; extra == 'all'
 Requires-Dist: xls2xlsx>=0.2.0; extra == 'all'
@@ -184,6 +186,7 @@ Requires-Dist: docker<8,>=7.1.0; extra == 'dev-tools'
 Requires-Dist: e2b-code-interpreter<2,>=1.0.3; extra == 'dev-tools'
 Requires-Dist: ipykernel<7,>=6.0.0; extra == 'dev-tools'
 Requires-Dist: jupyter-client<9,>=8.6.2; extra == 'dev-tools'
+Requires-Dist: langfuse>=2.60.5; extra == 'dev-tools'
 Requires-Dist: mcp>=1.3.0; extra == 'dev-tools'
 Requires-Dist: tree-sitter-python<0.24,>=0.23.6; extra == 'dev-tools'
 Requires-Dist: tree-sitter<0.24,>=0.23.2; extra == 'dev-tools'
@@ -303,6 +306,7 @@ Requires-Dist: qdrant-client<2,>=1.9.0; extra == 'rag'
 Requires-Dist: rank-bm25<0.3,>=0.2.2; extra == 'rag'
 Requires-Dist: sentence-transformers<4,>=3.0.1; extra == 'rag'
 Requires-Dist: unstructured==0.16.20; extra == 'rag'
+Requires-Dist: weaviate-client>=4.15.0; extra == 'rag'
 Provides-Extra: research-tools
 Requires-Dist: arxiv2text<0.2,>=0.1.14; extra == 'research-tools'
 Requires-Dist: arxiv<3,>=2.1.3; extra == 'research-tools'
@@ -320,6 +324,7 @@ Requires-Dist: pyobvector>=0.1.18; extra == 'storage'
 Requires-Dist: pytidb-experimental==0.0.1.dev4; extra == 'storage'
 Requires-Dist: qdrant-client<2,>=1.9.0; extra == 'storage'
 Requires-Dist: redis<6,>=5.0.6; extra == 'storage'
+Requires-Dist: weaviate-client>=4.15.0; extra == 'storage'
 Provides-Extra: test
 Requires-Dist: mock<6,>=5; extra == 'test'
 Requires-Dist: pytest-asyncio<0.24,>=0.23.0; extra == 'test'

{camel_ai-0.2.62 → camel_ai-0.2.64}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.62'
+__version__ = '0.2.64'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.62 → camel_ai-0.2.64}/camel/agents/chat_agent.py

@@ -19,7 +19,6 @@ import textwrap
 import threading
 import uuid
 from collections import defaultdict
-from datetime import datetime
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -79,6 +78,7 @@ from camel.utils import (
     get_model_encoding,
     model_from_json_schema,
 )
+from camel.utils.commons import dependencies_required
 
 if TYPE_CHECKING:
     from camel.terminators import ResponseTerminator
@@ -96,6 +96,15 @@ try:
 except (ImportError, AttributeError):
     from camel.utils import track_agent
 
+# Langfuse decorator setting
+if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
+    try:
+        from langfuse.decorators import observe
+    except ImportError:
+        from camel.utils import observe
+else:
+    from camel.utils import observe
+
 
 SIMPLE_FORMAT_PROMPT = TextPrompt(
     textwrap.dedent(
@@ -204,7 +213,7 @@ class ChatAgent(BaseAgent):
         self.model_type = self.model_backend.model_type
 
         # Assign unique ID
-        self.agent_id = agent_id if agent_id else str(uuid.uuid4())[:6]
+        self.agent_id = agent_id if agent_id else str(uuid.uuid4())
 
         # Set up memory
         context_creator = ScoreBasedContextCreator(
@@ -509,7 +518,7 @@ class ChatAgent(BaseAgent):
                 memory record. If None, current timestamp will be used.
                 (default: :obj:`None`)
         """
-        from datetime import timezone
+        import time
 
         self.memory.write_record(
             MemoryRecord(
@@ -517,7 +526,7 @@ class ChatAgent(BaseAgent):
                 role_at_backend=role,
                 timestamp=timestamp
                 if timestamp is not None
-                else datetime.now(timezone.utc).timestamp(),
+                else time.time_ns() / 1_000_000_000,  # Nanosecond precision
                 agent_id=self.agent_id,
             )
         )
@@ -731,6 +740,7 @@ class ChatAgent(BaseAgent):
             message.content = response.output_messages[0].content
             self._try_format_message(message, response_format)
 
+    @observe()
     def step(
         self,
         input_message: Union[BaseMessage, str],
@@ -753,6 +763,14 @@ class ChatAgent(BaseAgent):
                 flag, and session information.
         """
 
+        # Set Langfuse session_id using agent_id for trace grouping
+        try:
+            from camel.utils.langfuse import set_current_agent_session_id
+
+            set_current_agent_session_id(self.agent_id)
+        except ImportError:
+            pass  # Langfuse not available
+
         # Convert input message to BaseMessage if necessary
         if isinstance(input_message, str):
             input_message = BaseMessage.make_user_message(
@@ -847,6 +865,7 @@ class ChatAgent(BaseAgent):
         openai_messages, _ = self.memory.get_context()
         return openai_messages
 
+    @observe()
     async def astep(
         self,
         input_message: Union[BaseMessage, str],
@@ -873,6 +892,13 @@ class ChatAgent(BaseAgent):
                 a boolean indicating whether the chat session has terminated,
                 and information about the chat session.
         """
+        try:
+            from camel.utils.langfuse import set_current_agent_session_id
+
+            set_current_agent_session_id(self.agent_id)
+        except ImportError:
+            pass  # Langfuse not available
+
         if isinstance(input_message, str):
             input_message = BaseMessage.make_user_message(
                 role_name="User", content=input_message
@@ -1331,6 +1357,13 @@ class ChatAgent(BaseAgent):
         """
         output_messages: List[BaseMessage] = []
         for choice in response.choices:
+            # Skip messages with no meaningful content
+            if (
+                choice.message.content is None
+                or choice.message.content.strip() == ""
+            ) and not choice.message.tool_calls:
+                continue
+
             meta_dict = {}
             if logprobs_info := handle_logprobs(choice):
                 meta_dict["logprobs_info"] = logprobs_info
@@ -1560,8 +1593,32 @@ class ChatAgent(BaseAgent):
         args = tool_call_request.args
         tool_call_id = tool_call_request.tool_call_id
         tool = self._internal_tools[func_name]
+        import asyncio
+
         try:
-            result = await tool.async_call(**args)
+            # Try different invocation paths in order of preference
+            if hasattr(tool, 'func') and hasattr(tool.func, 'async_call'):
+                # Case: FunctionTool wrapping an MCP tool
+                result = await tool.func.async_call(**args)
+
+            elif hasattr(tool, 'async_call') and callable(tool.async_call):
+                # Case: tool itself has async_call
+                result = await tool.async_call(**args)
+
+            elif hasattr(tool, 'func') and asyncio.iscoroutinefunction(
+                tool.func
+            ):
+                # Case: tool wraps a direct async function
+                result = await tool.func(**args)
+
+            elif asyncio.iscoroutinefunction(tool):
+                # Case: tool is itself a coroutine function
+                result = await tool(**args)
+
+            else:
+                # Fallback: synchronous call
+                result = tool(**args)
+
         except Exception as e:
             # Capture the error message to prevent framework crash
             error_msg = f"Error executing async tool '{func_name}': {e!s}"
@@ -1599,17 +1656,24 @@ class ChatAgent(BaseAgent):
             tool_call_id=tool_call_id,
         )
 
-        # Use slightly different timestamps to ensure correct ordering
+        # Use precise timestamps to ensure correct ordering
         # This ensures the assistant message (tool call) always appears before
         # the function message (tool result) in the conversation context
-        current_time = datetime.now().timestamp()
+        # Use time.time_ns() for nanosecond precision to avoid collisions
+        import time
+
+        current_time_ns = time.time_ns()
+        base_timestamp = current_time_ns / 1_000_000_000  # Convert to seconds
+
         self.update_memory(
-            assist_msg, OpenAIBackendRole.ASSISTANT, timestamp=current_time
+            assist_msg, OpenAIBackendRole.ASSISTANT, timestamp=base_timestamp
         )
+
+        # Add minimal increment to ensure function message comes after
         self.update_memory(
             func_msg,
             OpenAIBackendRole.FUNCTION,
-            timestamp=current_time + 0.001,
+            timestamp=base_timestamp + 1e-6,
         )
 
         # Record information about this tool call
@@ -1714,6 +1778,7 @@ class ChatAgent(BaseAgent):
             f"ChatAgent({self.role_name}, {self.role_type}, {self.model_type})"
         )
 
+    @dependencies_required("mcp")
     def to_mcp(
         self,
         name: str = "CAMEL-ChatAgent",
@@ -1740,13 +1805,7 @@ class ChatAgent(BaseAgent):
         Returns:
             FastMCP: An MCP server instance that can be run.
         """
-        try:
-            from mcp.server.fastmcp import FastMCP
-        except ImportError:
-            raise ImportError(
-                "The 'mcp' package is required to use the to_mcp method. "
-                "Install it with 'pip install mcp'."
-            )
+        from mcp.server.fastmcp import FastMCP
 
         # Combine dependencies
         all_dependencies = ["camel-ai[all]"]
@@ -1837,7 +1896,7 @@ class ChatAgent(BaseAgent):
                     "description": tool.get_function_description() or "",
                     "parameters": [
                         {"name": param_name, "type": str(param_type)}
-                        for param_name, param_type in tool.get_parameters().items()  # noqa: E501
+                        for param_name, param_type in tool.parameters.items()
                     ],
                 }
             return tool_info

{camel_ai-0.2.62 → camel_ai-0.2.64}/camel/agents/mcp_agent.py

@@ -125,6 +125,7 @@ class MCPAgent(ChatAgent):
         local_config_path: Optional[str] = None,
         tools: Optional[List[Union[FunctionTool, Callable]]] = None,
         function_calling_available: bool = True,
+        strict: bool = False,
         **kwargs,
     ):
         if model is None:
@@ -144,6 +145,7 @@ class MCPAgent(ChatAgent):
 
         self.local_config = local_config
         self.function_calling_available = function_calling_available
+        self.strict = strict
 
         if function_calling_available:
             sys_msg_content = "You are a helpful assistant, and you prefer "
@@ -177,7 +179,7 @@ class MCPAgent(ChatAgent):
         if self.local_config:
             config_dict.update(self.local_config)
 
-        return MCPToolkit(config_dict=config_dict)
+        return MCPToolkit(config_dict=config_dict, strict=self.strict)
 
     def add_registry(self, registry_config: BaseMCPRegistryConfig) -> None:
         r"""Add a new registry configuration to the agent.
@@ -211,6 +213,7 @@ class MCPAgent(ChatAgent):
         ] = None,
         model: Optional[BaseModelBackend] = None,
         function_calling_available: bool = False,
+        strict: bool = False,
         **kwargs,
     ) -> "MCPAgent":
         r"""Create and connect an MCPAgent instance.
@@ -276,6 +279,7 @@ class MCPAgent(ChatAgent):
             registry_configs=final_registry_configs,
             model=model,
             function_calling_available=function_calling_available,
+            strict=strict,
             **kwargs,
         )
 

{camel_ai-0.2.62 → camel_ai-0.2.64}/camel/configs/__init__.py

@@ -16,6 +16,7 @@ from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
 from .bedrock_config import BEDROCK_API_PARAMS, BedrockConfig
 from .cohere_config import COHERE_API_PARAMS, CohereConfig
+from .crynux_config import CRYNUX_API_PARAMS, CrynuxConfig
 from .deepseek_config import DEEPSEEK_API_PARAMS, DeepSeekConfig
 from .gemini_config import Gemini_API_PARAMS, GeminiConfig
 from .groq_config import GROQ_API_PARAMS, GroqConfig
@@ -112,4 +113,6 @@ __all__ = [
     'LMStudioConfig',
     'WatsonXConfig',
     'WATSONX_API_PARAMS',
+    'CrynuxConfig',
+    'CRYNUX_API_PARAMS',
 ]

camel_ai-0.2.64/camel/configs/crynux_config.py

@@ -0,0 +1,94 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+from __future__ import annotations
+
+from typing import Dict, Optional, Sequence, Type, Union
+
+from pydantic import BaseModel
+
+from camel.configs.base_config import BaseConfig
+
+
+class CrynuxConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    OpenAI API.
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`None`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`None`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`None`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`None`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`None`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`None`)
+        logit_bias (dict, optional): Modify the likelihood of specified tokens
+            appearing in the completion. Accepts a json object that maps tokens
+            (specified by their token ID in the tokenizer) to an associated
+            bias value from :obj:`-100` to :obj:`100`. Mathematically, the bias
+            is added to the logits generated by the model prior to sampling.
+            The exact effect will vary per model, but values between:obj:` -1`
+            and :obj:`1` should decrease or increase likelihood of selection;
+            values like :obj:`-100` or :obj:`100` should result in a ban or
+            exclusive selection of the relevant token. (default: :obj:`None`)
+    """
+
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    n: Optional[int] = None
+    stream: Optional[bool] = None
+    stop: Optional[Union[str, Sequence[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    response_format: Optional[Union[Type[BaseModel], Dict]] = None
+    frequency_penalty: Optional[float] = None
+    logit_bias: Optional[Dict] = None
+
+
+CRYNUX_API_PARAMS = {param for param in CrynuxConfig.model_fields.keys()}

{camel_ai-0.2.62 → camel_ai-0.2.64}/camel/interpreters/base.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Tuple, Union
 
 
 class BaseInterpreter(ABC):
@@ -47,3 +47,16 @@ class BaseInterpreter(ABC):
     def update_action_space(self, action_space: Dict[str, Any]) -> None:
         r"""Updates action space for *python* interpreter"""
         pass
+
+    @abstractmethod
+    def execute_command(self, command: str) -> Union[str, Tuple[str, str]]:
+        r"""Executes a command in the interpreter.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            Tuple[str, str]: A tuple containing the stdout and stderr of the
+                command execution.
+        """
+        pass

camel_ai-0.2.64/camel/interpreters/docker/Dockerfile

@@ -0,0 +1,68 @@
+# syntax=docker/dockerfile:1
+
+FROM ubuntu:22.04
+
+# Set environment variable to avoid interactive prompts
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Update and install base utilities
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    software-properties-common \
+    curl \
+    wget \
+    git \
+    git-lfs \
+    netcat \
+    sudo \
+    tzdata \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean \
+    && apt-get autoremove -y
+
+# Install Python 3.10 and its dependencies
+RUN add-apt-repository ppa:deadsnakes/ppa && \
+    apt-get update && \
+    apt-get install -y \
+        python3.10 \
+        python3.10-venv \
+        python3.10-dev \
+        python3.10-distutils \
+        python3-pip \
+    && ln -s /usr/bin/python3.10 /usr/bin/python \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean \
+    && apt-get autoremove -y
+
+# Install R
+RUN apt-get update && \
+    apt-get install -y r-base && \
+    rm -rf /var/lib/apt/lists/* && \
+    apt-get clean && \
+    apt-get autoremove -y
+
+# Install NodeJS 22.x
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+    apt-get install -y nodejs && \
+    rm -rf /var/lib/apt/lists/* && \
+    apt-get clean && \
+    apt-get autoremove -y
+
+# Install Poetry
+RUN curl -fsSL https://install.python-poetry.org | python3.10 - && \
+    ln -s ~/.local/bin/poetry /usr/local/bin/poetry
+
+# Upgrade pip and install base Python packages
+RUN python3.10 -m pip install --upgrade pip setuptools wheel
+
+# Install uv
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    mv /root/.local/bin/uv /usr/local/bin/uv && \
+    mv /root/.local/bin/uvx /usr/local/bin/uvx && \
+    chmod +x /usr/local/bin/uv /usr/local/bin/uvx
+
+# Setup working directory
+WORKDIR /workspace
+
+# Set default shell
+CMD ["/bin/bash"]

{camel_ai-0.2.62 → camel_ai-0.2.64}/camel/interpreters/docker_interpreter.py

@@ -53,12 +53,14 @@ class DockerInterpreter(BaseInterpreter):
         "python": "python {file_name}",
         "bash": "bash {file_name}",
         "r": "Rscript {file_name}",
+        "node": "node {file_name}",
     }
 
     _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
         "python": "py",
         "bash": "sh",
         "r": "R",
+        "node": "js",
     }
 
     _CODE_TYPE_MAPPING: ClassVar[Dict[str, str]] = {
@@ -71,6 +73,11 @@ class DockerInterpreter(BaseInterpreter):
         "sh": "bash",
         "r": "r",
         "R": "r",
+        "node": "node",
+        "js": "node",
+        "javascript": "node",
+        "typescript": "node",
+        "ts": "node",
     }
 
     def __init__(
@@ -92,8 +99,11 @@ class DockerInterpreter(BaseInterpreter):
         This method ensures that the Docker container is removed when the
         interpreter is deleted.
         """
-        if self._container is not None:
-            self._container.remove(force=True)
+        try:
+            if self._container is not None:
+                self.cleanup()
+        except ImportError as e:
+            logger.warning(f"Error during container cleanup: {e}")
 
     def _initialize_if_needed(self) -> None:
         if self._container is not None:
@@ -180,10 +190,24 @@ class DockerInterpreter(BaseInterpreter):
         exec_result += f"(stderr: {stderr.decode()})" if stderr else ""
         return exec_result
 
+    def cleanup(self) -> None:
+        r"""Explicitly stops and removes the Docker container.
+
+        This method should be called when you're done with the interpreter
+        to ensure proper cleanup of Docker resources.
+        """
+        try:
+            if self._container is not None:
+                self._container.stop()
+                self._container.remove(force=True)
+                self._container = None
+        except Exception as e:
+            logger.error(f"Error during container cleanup: {e}")
+
     def run(
         self,
         code: str,
-        code_type: str,
+        code_type: str = "python",
     ) -> str:
         r"""Executes the given code in the container attached to the
         interpreter, and captures the stdout and stderr streams.
@@ -191,7 +215,7 @@ class DockerInterpreter(BaseInterpreter):
         Args:
             code (str): The code string to execute.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured stdout and stderr of the
@@ -229,13 +253,16 @@ class DockerInterpreter(BaseInterpreter):
         try:
             temp_file_path = self._create_file_in_container(code)
             result = self._run_file_in_container(temp_file_path, code_type)
+            # Clean up after execution
         except docker.errors.APIError as e:
+            self.cleanup()
             raise InterpreterError(
                 f"Execution halted due to docker API error: {e.explanation}. "
                 "This choice stops the current operation and any "
                 "further code execution."
             ) from e
         except docker.errors.DockerException as e:
+            self.cleanup()  # Clean up even if there's an error
             raise InterpreterError(
                 f"Execution halted due to docker exceptoin: {e}. "
                 "This choice stops the current operation and any "
@@ -258,6 +285,37 @@ class DockerInterpreter(BaseInterpreter):
 
     def update_action_space(self, action_space: Dict[str, Any]) -> None:
         r"""Updates action space for *python* interpreter"""
-        raise RuntimeError(
-            "SubprocessInterpreter doesn't support " "`action_space`."
-        )
+        raise RuntimeError("DockerInterpreter doesn't support `action_space`.")
+
+    def execute_command(self, command: str) -> str:
+        r"""Executes a command in the Docker container and returns its output.
+
+        Args:
+            command (str): The command to execute in the container.
+
+        Returns:
+            str: A string containing the captured stdout and stderr of the
+                executed command.
+
+        Raises:
+            InterpreterError: If the container is not initialized or there is
+                an error executing the command.
+        """
+        self._initialize_if_needed()
+
+        if self._container is None:
+            raise InterpreterError(
+                "Container is not initialized. Try running the command again."
+            )
+
+        try:
+            stdout, stderr = self._container.exec_run(
+                command,
+                demux=True,
+            ).output
+            exec_result = f"{stdout.decode()}" if stdout else ""
+            exec_result += f"(stderr: {stderr.decode()})" if stderr else ""
+            return exec_result
+
+        except Exception as e:
+            raise InterpreterError(f"Failed to execute command: {e!s}") from e