camel-ai 0.2.67__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/toolkits/arxiv_toolkit.py

@@ -49,9 +49,9 @@ class ArxivToolkit(BaseToolkit):
             query (str): The search query string used to search for papers on
                 arXiv.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default: :obj: `None`)
+                IDs to search for. (default: :obj:`None`)
             max_results (int, optional): The maximum number of search results
-                to retrieve. (default: :obj: `5`)
+                to retrieve. (default: :obj:`5`)
 
         Returns:
             Generator: A generator that yields results from the arXiv search
@@ -80,9 +80,9 @@ class ArxivToolkit(BaseToolkit):
         Args:
             query (str): The search query string.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to search for. (default: :obj: `None`)
+                IDs to search for. (default: :obj:`None`)
             max_results (int, optional): The maximum number of search results
-                to return. (default: :obj: `5`)
+                to return. (default: :obj:`5`)
 
         Returns:
             List[Dict[str, str]]: A list of dictionaries, each containing
@@ -138,9 +138,9 @@ class ArxivToolkit(BaseToolkit):
         Args:
             query (str): The search query string.
             paper_ids (List[str], optional): A list of specific arXiv paper
-                IDs to download. (default: :obj: `None`)
+                IDs to download. (default: :obj:`None`)
             max_results (int, optional): The maximum number of search results
-                to download. (default: :obj: `5`)
+                to download. (default: :obj:`5`)
             output_dir (str, optional): The directory to save the downloaded
                 PDFs. Defaults to the current directory.
 

camel/toolkits/base.py

@@ -12,10 +12,17 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-from typing import List, Literal, Optional
+from typing import TYPE_CHECKING, List, Literal, Optional
 
+from camel.logger import get_logger
 from camel.toolkits import FunctionTool
-from camel.utils import AgentOpsMeta, with_timeout
+from camel.utils import AgentOpsMeta, Constants, with_timeout
+
+if TYPE_CHECKING:
+    from camel.agents import ChatAgent
+
+
+logger = get_logger(__name__)
 
 
 class BaseToolkit(metaclass=AgentOpsMeta):
@@ -28,9 +35,9 @@ class BaseToolkit(metaclass=AgentOpsMeta):
     from mcp.server import FastMCP
 
     mcp: FastMCP
-    timeout: Optional[float] = None
+    timeout: Optional[float] = Constants.TIMEOUT_THRESHOLD
 
-    def __init__(self, timeout: Optional[float] = None):
+    def __init__(self, timeout: Optional[float] = Constants.TIMEOUT_THRESHOLD):
         # check if timeout is a positive number
         if timeout is not None and timeout <= 0:
             raise ValueError("Timeout must be a positive number.")
@@ -41,7 +48,9 @@ class BaseToolkit(metaclass=AgentOpsMeta):
         super().__init_subclass__(**kwargs)
         for attr_name, attr_value in cls.__dict__.items():
             if callable(attr_value) and not attr_name.startswith("__"):
-                setattr(cls, attr_name, with_timeout(attr_value))
+                # Skip methods that have manual timeout management
+                if not getattr(attr_value, '_manual_timeout', False):
+                    setattr(cls, attr_name, with_timeout(attr_value))
 
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
@@ -63,3 +72,52 @@ class BaseToolkit(metaclass=AgentOpsMeta):
                 the MCP server in.
         """
         self.mcp.run(mode)
+
+
+class RegisteredAgentToolkit:
+    r"""Mixin class for toolkits that need to register a ChatAgent.
+
+    This mixin provides a standard interface for toolkits that require
+    a reference to a ChatAgent instance. The ChatAgent will check if a
+    toolkit has this mixin and automatically register itself.
+    """
+
+    def __init__(self):
+        self._agent: Optional["ChatAgent"] = None
+
+    @property
+    def agent(self) -> Optional["ChatAgent"]:
+        r"""Get the registered ChatAgent instance.
+
+        Returns:
+            Optional[ChatAgent]: The registered agent, or None if not
+                registered.
+
+        Note:
+            If None is returned, it means the toolkit has not been registered
+            with a ChatAgent yet. Make sure to pass this toolkit to a ChatAgent
+            via the toolkits parameter during initialization.
+        """
+        if self._agent is None:
+            logger.warning(
+                f"{self.__class__.__name__} does not have a "
+                f"registered ChatAgent. "
+                f"Please ensure this toolkit is passed to a ChatAgent via the "
+                f"'toolkits_to_register_agent' parameter during ChatAgent "
+                f"initialization if you want to use the tools that require a "
+                f"registered agent."
+            )
+        return self._agent
+
+    def register_agent(self, agent: "ChatAgent") -> None:
+        r"""Register a ChatAgent with this toolkit.
+
+        This method allows registering an agent after initialization. The
+        ChatAgent will automatically call this method if the toolkit to
+        register inherits from RegisteredAgentToolkit.
+
+        Args:
+            agent (ChatAgent): The ChatAgent instance to register.
+        """
+        self._agent = agent
+        logger.info(f"Agent registered with {self.__class__.__name__}")

camel/toolkits/code_execution.py

@@ -18,6 +18,7 @@ from camel.interpreters import (
     E2BInterpreter,
     InternalPythonInterpreter,
     JupyterKernelInterpreter,
+    MicrosandboxInterpreter,
     SubprocessInterpreter,
 )
 from camel.logger import get_logger
@@ -43,18 +44,31 @@ class CodeExecutionToolkit(BaseToolkit):
             (default: :obj:`None`)
         require_confirm (bool): Whether to require confirmation before
             executing code. (default: :obj:`False`)
+        timeout (Optional[float]): General timeout for toolkit operations.
+            (default: :obj:`None`)
+        microsandbox_config (Optional[dict]): Configuration for microsandbox
+            interpreter. Available keys: 'server_url', 'api_key',
+            'namespace', 'sandbox_name', 'timeout'.
+            If None, uses default configuration. (default: :obj:`None`)
     """
 
     def __init__(
         self,
         sandbox: Literal[
-            "internal_python", "jupyter", "docker", "subprocess", "e2b"
+            "internal_python",
+            "jupyter",
+            "docker",
+            "subprocess",
+            "e2b",
+            "microsandbox",
         ] = "subprocess",
         verbose: bool = False,
         unsafe_mode: bool = False,
         import_white_list: Optional[List[str]] = None,
         require_confirm: bool = False,
         timeout: Optional[float] = None,
+        # Microsandbox configuration dictionary
+        microsandbox_config: Optional[dict] = None,
     ) -> None:
         super().__init__(timeout=timeout)
         self.verbose = verbose
@@ -68,6 +82,7 @@ class CodeExecutionToolkit(BaseToolkit):
             DockerInterpreter,
             SubprocessInterpreter,
             E2BInterpreter,
+            MicrosandboxInterpreter,
         ]
 
         if sandbox == "internal_python":
@@ -95,6 +110,18 @@ class CodeExecutionToolkit(BaseToolkit):
             )
         elif sandbox == "e2b":
             self.interpreter = E2BInterpreter(require_confirm=require_confirm)
+        elif sandbox == "microsandbox":
+            # Extract parameters with proper types for microsandbox
+            config = microsandbox_config or {}
+
+            self.interpreter = MicrosandboxInterpreter(
+                require_confirm=require_confirm,
+                server_url=config.get("server_url"),
+                api_key=config.get("api_key"),
+                namespace=config.get("namespace", "default"),
+                sandbox_name=config.get("sandbox_name"),
+                timeout=config.get("timeout", 30),
+            )
         else:
             raise RuntimeError(
                 f"The sandbox type `{sandbox}` is not supported."