camel-ai 0.2.75a5__py3-none-any.whl → 0.2.76__py3-none-any.whl

camel/societies/workforce/workforce_logger.py

@@ -495,6 +495,11 @@ class WorkforceLogger:
 
         tasks_handled_by_worker: Dict[str, int] = {}
 
+        # Track unique task final states to avoid double-counting
+        task_final_states: Dict[
+            str, str
+        ] = {}  # task_id -> 'completed' or 'failed'
+
         # Helper function to check if a task is the main task (has no parent)
         def is_main_task(task_id: str) -> bool:
             return (
@@ -528,7 +533,9 @@ class WorkforceLogger:
             elif event_type == 'task_completed':
                 # Exclude main task from total count
                 if not is_main_task(task_id):
-                    kpis['total_tasks_completed'] += 1
+                    # Track final state - a completed task overwrites any
+                    # previous failed state
+                    task_final_states[task_id] = 'completed'
                     # Count tasks handled by worker (only for non-main tasks)
                     if 'worker_id' in entry and entry['worker_id'] is not None:
                         worker_id = entry['worker_id']
@@ -550,7 +557,11 @@ class WorkforceLogger:
             elif event_type == 'task_failed':
                 # Exclude main task from total count
                 if not is_main_task(task_id):
-                    kpis['total_tasks_failed'] += 1
+                    # Only track as failed if not already completed
+                    # (in case of retries, the final completion overwrites
+                    # failed state)
+                    if task_final_states.get(task_id) != 'completed':
+                        task_final_states[task_id] = 'failed'
                     # Count tasks handled by worker (only for non-main tasks)
                     if 'worker_id' in entry and entry['worker_id'] is not None:
                         worker_id = entry['worker_id']
@@ -565,6 +576,14 @@ class WorkforceLogger:
             kpis['total_workforce_running_time_seconds'] = (
                 last_timestamp - first_timestamp
             ).total_seconds()
+
+        # Count unique tasks by final state
+        for _task_id, state in task_final_states.items():
+            if state == 'completed':
+                kpis['total_tasks_completed'] += 1
+            elif state == 'failed':
+                kpis['total_tasks_failed'] += 1
+
         # Calculate worker utilization based on proportion of tasks handled
         total_tasks_processed_for_utilization = (
             kpis['total_tasks_completed'] + kpis['total_tasks_failed']
@@ -610,9 +629,9 @@ class WorkforceLogger:
 
         kpis['total_workers_created'] = len(self._worker_information)
 
-        # Current pending tasks (simplified)
-        kpis['current_pending_tasks'] = kpis['total_tasks_created'] - (
-            kpis['total_tasks_completed'] + kpis['total_tasks_failed']
+        # Current pending tasks - tasks created but not yet completed or failed
+        kpis['current_pending_tasks'] = kpis['total_tasks_created'] - len(
+            task_final_states
         )
 
         return kpis

camel/storages/key_value_storages/json.py

@@ -17,6 +17,8 @@ from enum import EnumMeta
 from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Optional
 
+from pydantic import BaseModel
+
 from camel.storages.key_value_storages import BaseKeyValueStorage
 from camel.types import (
     ModelType,
@@ -27,8 +29,13 @@ from camel.types import (
 
 
 class CamelJSONEncoder(json.JSONEncoder):
-    r"""A custom JSON encoder for serializing specifically enumerated types.
-    Ensures enumerated types can be stored in and retrieved from JSON format.
+    r"""A custom JSON encoder for serializing CAMEL-specific types.
+
+    Handles serialization of:
+    - Enumerated types (RoleType, TaskType, ModelType, OpenAIBackendRole)
+    - Pydantic BaseModel objects (from structured outputs)
+
+    Ensures these types can be stored in and retrieved from JSON format.
     """
 
     CAMEL_ENUMS: ClassVar[Dict[str, EnumMeta]] = {
@@ -39,8 +46,14 @@ class CamelJSONEncoder(json.JSONEncoder):
     }
 
     def default(self, obj) -> Any:
+        # Handle CAMEL enum types
         if type(obj) in self.CAMEL_ENUMS.values():
             return {"__enum__": str(obj)}
+
+        # Handle Pydantic BaseModel objects (e.g., from structured outputs)
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
+
         # Let the base class default method raise the TypeError
         return json.JSONEncoder.default(self, obj)
 

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/storages/vectordb_storages/oceanbase.py

@@ -74,7 +74,6 @@ class OceanBaseStorage(BaseVectorStorage):
             ObVecClient,
         )
         from pyobvector.client.index_param import (
-            IndexParam,
             IndexParams,
         )
         from pyobvector.schema import VECTOR
@@ -112,19 +111,19 @@ class OceanBaseStorage(BaseVectorStorage):
 
             # Create vector index
             index_params: IndexParams = IndexParams()
-            index_params.add_index_param(
-                IndexParam(
-                    index_name="embedding_idx",
-                    field_name="embedding",
-                    distance=self.distance,
-                    type="hnsw",
-                    m=16,
-                    ef_construction=256,
-                )
+            index_params.add_index(
+                field_name="embedding",
+                index_type="hnsw",
+                index_name="embedding_idx",
+                distance=self.distance,
+                m=16,
+                ef_construction=256,
             )
 
+            # Get the first index parameter
+            first_index_param = next(iter(index_params))
             self._client.create_vidx_with_vec_index_param(
-                table_name=self.table_name, vidx_param=index_params.params[0]
+                table_name=self.table_name, vidx_param=first_index_param
             )
 
             logger.info(f"Created table {self.table_name} with vector index")

camel/storages/vectordb_storages/tidb.py

@@ -44,7 +44,7 @@ class TiDBStorage(BaseVectorStorage):
     r"""An implementation of the `BaseVectorStorage` for interacting with TiDB.
 
     The detailed information about TiDB is available at:
-    `TiDB Vector Search <https://ai.pingcap.com/>`_
+    `TiDB Vector Search <https://pingcap.com/ai>`_
 
     Args:
         vector_dim (int): The dimension of storing vectors.
@@ -107,10 +107,10 @@ class TiDBStorage(BaseVectorStorage):
         )
 
     def _get_table_model(self, collection_name: str) -> Any:
+        from pytidb.datatype import JSON
         from pytidb.schema import Field, TableModel, VectorField
-        from sqlalchemy import JSON
 
-        class VectorDBRecord(TableModel):
+        class VectorDBRecordBase(TableModel, table=False):
             id: Optional[str] = Field(None, primary_key=True)
             vector: list[float] = VectorField(self.vector_dim)
             payload: Optional[dict[str, Any]] = Field(None, sa_type=JSON)
@@ -119,7 +119,7 @@ class TiDBStorage(BaseVectorStorage):
         # class names.
         return type(
             f"VectorDBRecord_{collection_name}",
-            (VectorDBRecord,),
+            (VectorDBRecordBase,),
             {"__tablename__": collection_name},
             table=True,
         )
@@ -128,8 +128,9 @@ class TiDBStorage(BaseVectorStorage):
         r"""Opens an existing table or creates a new table in TiDB."""
         table = self._client.open_table(self.collection_name)
         if table is None:
+            table_model = self._get_table_model(self.collection_name)
             table = self._client.create_table(
-                schema=self._get_table_model(self.collection_name)
+                schema=table_model, if_exists="skip"
             )
         return table
 
@@ -166,6 +167,7 @@ class TiDBStorage(BaseVectorStorage):
                 table.
         """
         vector_count = self._table.rows()
+
         # Get vector dimension from table schema
         columns = self._table.columns()
         dim_value = None
@@ -303,7 +305,7 @@ class TiDBStorage(BaseVectorStorage):
         for row in rows:
             query_results.append(
                 VectorDBQueryResult.create(
-                    similarity=float(row['similarity_score']),
+                    similarity=float(row['_score']),
                     id=str(row['id']),
                     payload=row['payload'],
                     vector=row['vector'],

camel/tasks/task.py

@@ -237,8 +237,9 @@ class Task(BaseModel):
             (default: :obj:`[]`)
         additional_info (Optional[Dict[str, Any]]): Additional information for
             the task. (default: :obj:`None`)
-        image_list (Optional[List[Image.Image]]): Optional list of PIL Image
-            objects associated with the task. (default: :obj:`None`)
+        image_list (Optional[List[Union[Image.Image, str]]]): Optional list
+            of PIL Image objects or image URLs (strings) associated with the
+            task. (default: :obj:`None`)
         image_detail (Literal["auto", "low", "high"]): Detail level of the
             images associated with the task. (default: :obj:`auto`)
         video_bytes (Optional[bytes]): Optional bytes of a video associated
@@ -271,7 +272,7 @@ class Task(BaseModel):
 
     additional_info: Optional[Dict[str, Any]] = None
 
-    image_list: Optional[List[Image.Image]] = None
+    image_list: Optional[List[Union[Image.Image, str]]] = None
 
     image_detail: Literal["auto", "low", "high"] = "auto"
 

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,8 @@ 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 .dingtalk import DingtalkToolkit
 from .twitter_toolkit import TwitterToolkit
 from .open_api_toolkit import OpenAPIToolkit
 from .retrieval_toolkit import RetrievalToolkit
@@ -61,7 +63,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
@@ -75,6 +77,7 @@ from .klavis_toolkit import KlavisToolkit
 from .aci_toolkit import ACIToolkit
 from .origene_mcp_toolkit import OrigeneToolkit
 from .playwright_mcp_toolkit import PlaywrightMCPToolkit
+from .resend_toolkit import ResendToolkit
 from .wolfram_alpha_toolkit import WolframAlphaToolkit
 from .task_planning_toolkit import TaskPlanningToolkit
 from .hybrid_browser_toolkit import HybridBrowserToolkit
@@ -87,7 +90,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 +108,9 @@ __all__ = [
     'SearchToolkit',
     'SlackToolkit',
     'WhatsAppToolkit',
-    'OpenAIImageToolkit',
+    'WeChatOfficialToolkit',
+    'DingtalkToolkit',
+    'ImageGenToolkit',
     'TwitterToolkit',
     'WeatherToolkit',
     'RetrievalToolkit',
@@ -135,7 +143,8 @@ __all__ = [
     'ImageAnalysisToolkit',
     'BrowserToolkit',
     'AsyncBrowserToolkit',
-    'FileWriteToolkit',
+    'FileToolkit',
+    'FileWriteToolkit',  # Deprecated, use FileToolkit instead
     'PPTXToolkit',
     'TerminalToolkit',
     'PubMedToolkit',
@@ -149,9 +158,10 @@ __all__ = [
     'KlavisToolkit',
     'ACIToolkit',
     'PlaywrightMCPToolkit',
+    'ResendToolkit',
     'WolframAlphaToolkit',
     'BohriumToolkit',
-    'OpenAIImageToolkit',
+    'OpenAIImageToolkit',  # Backward compatibility
     'TaskPlanningToolkit',
     'HybridBrowserToolkit',
     'EdgeOnePagesMCPToolkit',
@@ -164,5 +174,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."