camel-ai 0.2.75a6__py3-none-any.whl → 0.2.76a1__py3-none-any.whl

camel/societies/workforce/single_agent_worker.py

@@ -35,8 +35,8 @@ from camel.tasks.task import Task, TaskState, is_task_result_insufficient
 class AgentPool:
     r"""A pool of agent instances for efficient reuse.
 
-    This pool manages a collection of pre-cloned agents. It supports
-    auto-scaling based ondemand and intelligent reuse of existing agents.
+    This pool manages a collection of pre-cloned agents with automatic
+    scaling and idle timeout cleanup.
 
     Args:
         base_agent (ChatAgent): The base agent to clone from.
@@ -48,6 +48,8 @@ class AgentPool:
             (default: :obj:`True`)
         idle_timeout (float): Time in seconds after which idle agents are
             removed. (default: :obj:`180.0`)
+        cleanup_interval (float): Fixed interval in seconds between cleanup
+            checks. (default: :obj:`60.0`)
     """
 
     def __init__(
@@ -56,12 +58,14 @@ class AgentPool:
         initial_size: int = 1,
         max_size: int = 10,
         auto_scale: bool = True,
-        idle_timeout: float = 180.0,  # 3 minutes
+        idle_timeout: float = 180.0,
+        cleanup_interval: float = 60.0,
     ):
         self.base_agent = base_agent
         self.max_size = max_size
         self.auto_scale = auto_scale
         self.idle_timeout = idle_timeout
+        self.cleanup_interval = cleanup_interval
 
         # Pool management
         self._available_agents: deque = deque()
@@ -73,6 +77,7 @@ class AgentPool:
         self._total_borrows = 0
         self._total_clones_created = 0
         self._pool_hits = 0
+        self._agents_cleaned = 0
 
         # Initialize pool
         self._initialize_pool(initial_size)
@@ -82,6 +87,7 @@ class AgentPool:
         for _ in range(min(size, self.max_size)):
             agent = self._create_fresh_agent()
             self._available_agents.append(agent)
+            self._agent_last_used[id(agent)] = time.time()
 
     def _create_fresh_agent(self) -> ChatAgent:
         r"""Create a fresh agent instance."""
@@ -94,53 +100,46 @@ class AgentPool:
         async with self._lock:
             self._total_borrows += 1
 
-            # Try to get from available agents first
             if self._available_agents:
                 agent = self._available_agents.popleft()
                 self._in_use_agents.add(id(agent))
                 self._pool_hits += 1
-
-                # Reset the agent state
-                agent.reset()
                 return agent
 
-            # Check if we can create new agents
-            total_agents = len(self._available_agents) + len(
-                self._in_use_agents
-            )
-            if total_agents < self.max_size:
+            # Check if we can create a new agent
+            if len(self._in_use_agents) < self.max_size or self.auto_scale:
                 agent = self._create_fresh_agent()
                 self._in_use_agents.add(id(agent))
                 return agent
 
-            # Pool exhausted, wait and retry or create temporary agent
-            if self.auto_scale:
-                # Create a temporary agent that won't be returned to pool
-                return self._create_fresh_agent()
-            else:
-                # Wait for an agent to become available
-                while not self._available_agents:
-                    await asyncio.sleep(0.1)
-
-                agent = self._available_agents.popleft()
-                self._in_use_agents.add(id(agent))
-                agent.reset()
-                return agent
+        # Wait for available agent
+        while True:
+            async with self._lock:
+                if self._available_agents:
+                    agent = self._available_agents.popleft()
+                    self._in_use_agents.add(id(agent))
+                    self._pool_hits += 1
+                    return agent
+            await asyncio.sleep(0.05)
 
     async def return_agent(self, agent: ChatAgent) -> None:
         r"""Return an agent to the pool."""
+        agent_id = id(agent)
+
         async with self._lock:
-            agent_id = id(agent)
+            if agent_id not in self._in_use_agents:
+                return
 
-            if agent_id in self._in_use_agents:
-                self._in_use_agents.remove(agent_id)
+            self._in_use_agents.discard(agent_id)
 
-                # Only return to pool if we're under max size
-                if len(self._available_agents) < self.max_size:
-                    # Reset agent state before returning to pool
-                    agent.reset()
-                    self._available_agents.append(agent)
-                    self._agent_last_used[agent_id] = time.time()
+            # Only add back to pool if under max size
+            if len(self._available_agents) < self.max_size:
+                agent.reset()
+                self._agent_last_used[agent_id] = time.time()
+                self._available_agents.append(agent)
+            else:
+                # Remove tracking for agents not returned to pool
+                self._agent_last_used.pop(agent_id, None)
 
     async def cleanup_idle_agents(self) -> None:
         r"""Remove idle agents from the pool to free memory."""
@@ -148,30 +147,35 @@ class AgentPool:
             return
 
         async with self._lock:
+            if not self._available_agents:
+                return
+
             current_time = time.time()
             agents_to_remove = []
 
             for agent in list(self._available_agents):
                 agent_id = id(agent)
                 last_used = self._agent_last_used.get(agent_id, current_time)
-
                 if current_time - last_used > self.idle_timeout:
                     agents_to_remove.append(agent)
 
             for agent in agents_to_remove:
                 self._available_agents.remove(agent)
-                agent_id = id(agent)
-                self._agent_last_used.pop(agent_id, None)
+                self._agent_last_used.pop(id(agent), None)
+                self._agents_cleaned += 1
 
     def get_stats(self) -> dict:
         r"""Get pool statistics."""
         return {
             "available_agents": len(self._available_agents),
             "in_use_agents": len(self._in_use_agents),
+            "pool_size": len(self._available_agents)
+            + len(self._in_use_agents),
             "total_borrows": self._total_borrows,
             "total_clones_created": self._total_clones_created,
             "pool_hits": self._pool_hits,
             "hit_rate": self._pool_hits / max(self._total_borrows, 1),
+            "agents_cleaned_up": self._agents_cleaned,
         }
 
 
@@ -477,7 +481,9 @@ class SingleAgentWorker(Worker):
         r"""Periodically clean up idle agents from the pool."""
         while True:
             try:
-                await asyncio.sleep(60)  # Cleanup every minute
+                # Fixed interval cleanup
+                await asyncio.sleep(self.agent_pool.cleanup_interval)
+
                 if self.agent_pool:
                     await self.agent_pool.cleanup_idle_agents()
             except asyncio.CancelledError:

camel/storages/object_storages/google_cloud.py

@@ -46,7 +46,7 @@ class GoogleCloudStorage(BaseObjectStorage):
         create_if_not_exists: bool = True,
         anonymous: bool = False,
     ) -> None:
-        from google.cloud import storage
+        from google.cloud import storage  # type: ignore[attr-defined]
 
         self.create_if_not_exists = create_if_not_exists
 

camel/toolkits/__init__.py

@@ -23,7 +23,7 @@ from .open_api_specs.security_config import openapi_security_config
 from .math_toolkit import MathToolkit
 from .search_toolkit import SearchToolkit
 from .weather_toolkit import WeatherToolkit
-from .openai_image_toolkit import OpenAIImageToolkit
+from .image_generation_toolkit import ImageGenToolkit, OpenAIImageToolkit
 from .ask_news_toolkit import AskNewsToolkit, AsyncAskNewsToolkit
 from .linkedin_toolkit import LinkedInToolkit
 from .reddit_toolkit import RedditToolkit
@@ -40,6 +40,7 @@ from .google_calendar_toolkit import GoogleCalendarToolkit
 from .arxiv_toolkit import ArxivToolkit
 from .slack_toolkit import SlackToolkit
 from .whatsapp_toolkit import WhatsAppToolkit
+from .wechat_official_toolkit import WeChatOfficialToolkit
 from .twitter_toolkit import TwitterToolkit
 from .open_api_toolkit import OpenAPIToolkit
 from .retrieval_toolkit import RetrievalToolkit
@@ -61,7 +62,7 @@ from .image_analysis_toolkit import ImageAnalysisToolkit
 from .mcp_toolkit import MCPToolkit
 from .browser_toolkit import BrowserToolkit
 from .async_browser_toolkit import AsyncBrowserToolkit
-from .file_write_toolkit import FileWriteToolkit
+from .file_toolkit import FileToolkit, FileWriteToolkit
 from .pptx_toolkit import PPTXToolkit
 from .terminal_toolkit import TerminalToolkit
 from .pubmed_toolkit import PubMedToolkit
@@ -87,7 +88,10 @@ from .message_agent_toolkit import AgentCommunicationToolkit
 from .web_deploy_toolkit import WebDeployToolkit
 from .screenshot_toolkit import ScreenshotToolkit
 from .message_integration import ToolkitMessageIntegration
+from .context_summarizer_toolkit import ContextSummarizerToolkit
 from .notion_mcp_toolkit import NotionMCPToolkit
+from .vertex_ai_veo_toolkit import VertexAIVeoToolkit
+from .minimax_mcp_toolkit import MinimaxMCPToolkit
 
 __all__ = [
     'BaseToolkit',
@@ -102,7 +106,8 @@ __all__ = [
     'SearchToolkit',
     'SlackToolkit',
     'WhatsAppToolkit',
-    'OpenAIImageToolkit',
+    'WeChatOfficialToolkit',
+    'ImageGenToolkit',
     'TwitterToolkit',
     'WeatherToolkit',
     'RetrievalToolkit',
@@ -135,7 +140,8 @@ __all__ = [
     'ImageAnalysisToolkit',
     'BrowserToolkit',
     'AsyncBrowserToolkit',
-    'FileWriteToolkit',
+    'FileToolkit',
+    'FileWriteToolkit',  # Deprecated, use FileToolkit instead
     'PPTXToolkit',
     'TerminalToolkit',
     'PubMedToolkit',
@@ -151,7 +157,7 @@ __all__ = [
     'PlaywrightMCPToolkit',
     'WolframAlphaToolkit',
     'BohriumToolkit',
-    'OpenAIImageToolkit',
+    'OpenAIImageToolkit',  # Backward compatibility
     'TaskPlanningToolkit',
     'HybridBrowserToolkit',
     'EdgeOnePagesMCPToolkit',
@@ -164,5 +170,8 @@ __all__ = [
     'ScreenshotToolkit',
     'RegisteredAgentToolkit',
     'ToolkitMessageIntegration',
+    'ContextSummarizerToolkit',
     'NotionMCPToolkit',
+    'VertexAIVeoToolkit',
+    'MinimaxMCPToolkit',
 ]

camel/toolkits/aci_toolkit.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import asyncio
 import os
 from typing import TYPE_CHECKING, Dict, List, Optional, Union
 
@@ -408,6 +409,38 @@ class ACIToolkit(BaseToolkit):
         )
         return result
 
+    async def aexecute_function(
+        self,
+        function_name: str,
+        function_arguments: Dict,
+        linked_account_owner_id: str,
+        allowed_apps_only: bool = False,
+    ) -> Dict:
+        r"""Execute a function call asynchronously.
+
+        Args:
+            function_name (str): Name of the function to execute.
+            function_arguments (Dict): Arguments to pass to the function.
+            linked_account_owner_id (str): To specify the end-user (account
+                owner) on behalf of whom you want to execute functions
+                You need to first link corresponding account with the same
+                owner id in the ACI dashboard (https://platform.aci.dev).
+            allowed_apps_only (bool): If true, only returns functions/apps
+                that are allowed to be used by the agent/accessor, identified
+                by the api key. (default: :obj:`False`)
+
+        Returns:
+            Dict: Result of the function execution
+        """
+        result = await asyncio.to_thread(
+            self.client.handle_function_call,
+            function_name,
+            function_arguments,
+            linked_account_owner_id,
+            allowed_apps_only,
+        )
+        return result
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Get a list of tools (functions) available in the configured apps.
 
@@ -434,6 +467,8 @@ class ACIToolkit(BaseToolkit):
             FunctionTool(self.delete_linked_account),
             FunctionTool(self.function_definition),
             FunctionTool(self.search_function),
+            FunctionTool(self.execute_function),
+            FunctionTool(self.aexecute_function),
         ]
 
         for function in _all_function:
@@ -448,6 +483,16 @@ class ACIToolkit(BaseToolkit):
                     linked_account_owner_id=self.linked_account_owner_id,
                 )
 
+            async def async_dummy_func(*, schema=schema, **kwargs):
+                return await self.aexecute_function(
+                    function_name=schema['function']['name'],
+                    function_arguments=kwargs,
+                    linked_account_owner_id=self.linked_account_owner_id,
+                )
+
+            # Add async_call method to the sync function for compatibility
+            dummy_func.async_call = async_dummy_func  # type: ignore[attr-defined]
+
             tool = FunctionTool(
                 func=dummy_func,
                 openai_tool_schema=schema,

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."