camel-ai 0.2.73a4__py3-none-any.whl → 0.2.80a2__py3-none-any.whl

camel/storages/key_value_storages/mem0_cloud.py

@@ -103,34 +103,6 @@ class Mem0Storage(BaseKeyValueStorage):
         }
         return {k: v for k, v in options.items() if v is not None}
 
-    def _prepare_filters(
-        self,
-        agent_id: Optional[str] = None,
-        user_id: Optional[str] = None,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        r"""Helper method to prepare filters for Mem0 API calls.
-
-        Args:
-            agent_id (Optional[str], optional): Agent ID to filter by
-                (default: :obj:`None`).
-            user_id (Optional[str], optional): User ID to filter by (default:
-                :obj:`None`).
-            filters (Optional[Dict[str, Any]], optional): Additional filters
-                (default: :obj:`None`).
-
-        Returns:
-            Dict[str, Any]: Prepared filters dictionary for API calls.
-        """
-        base_filters: Dict[str, Any] = {"AND": []}
-        if filters:
-            base_filters["AND"].append(filters)
-        if agent_id or self.agent_id:
-            base_filters["AND"].append({"agent_id": agent_id or self.agent_id})
-        if user_id or self.user_id:
-            base_filters["AND"].append({"user_id": user_id or self.user_id})
-        return base_filters if base_filters["AND"] else {}
-
     def _prepare_messages(
         self,
         records: List[Dict[str, Any]],
@@ -164,11 +136,11 @@ class Mem0Storage(BaseKeyValueStorage):
                 agent_id=self.agent_id,
                 user_id=self.user_id,
                 metadata=self.metadata,
+                version="v2",
             )
             self.client.add(messages, **options)
         except Exception as e:
             logger.error(f"Error adding memory: {e}")
-            logger.error(f"Error: {e}")
 
     def load(self) -> List[Dict[str, Any]]:
         r"""Loads all stored records from the Mem0 storage system.
@@ -178,47 +150,76 @@ class Mem0Storage(BaseKeyValueStorage):
                 represents a stored record.
         """
         try:
-            filters = self._prepare_filters(
-                agent_id=self.agent_id,
-                user_id=self.user_id,
-            )
-            results = self.client.get_all(version="v2", **filters)
+            # Build filters for get_all using proper Mem0 filter format
+            filters = {}
+            if self.agent_id:
+                filters = {"AND": [{"user_id": self.agent_id}]}
+            if self.user_id:
+                filters = {"AND": [{"user_id": self.user_id}]}
+
+            results = self.client.get_all(version="v2", filters=filters)
 
             # Transform results into MemoryRecord objects
             transformed_results = []
             for result in results:
+                # Ensure metadata is a dictionary, not None
+                metadata = result.get("metadata") or {}
+
                 memory_record = MemoryRecord(
                     uuid=UUID(result["id"]),
                     message=BaseMessage(
-                        role_name="user",
+                        role_name="memory",
                         role_type=RoleType.USER,
-                        meta_dict={},
+                        meta_dict=metadata,
                         content=result["memory"],
                     ),
                     role_at_backend=OpenAIBackendRole.USER,
-                    extra_info=result.get("metadata", {}),
+                    extra_info=metadata,
                     timestamp=datetime.fromisoformat(
-                        result["created_at"]
+                        result["created_at"].replace('Z', '+00:00')
                     ).timestamp(),
-                    agent_id=result.get("agent_id", ""),
+                    agent_id=result.get("agent_id", self.agent_id or ""),
                 )
                 transformed_results.append(memory_record.to_dict())
 
             return transformed_results
         except Exception as e:
-            logger.error(f"Error searching memories: {e}")
+            logger.error(f"Error loading memories: {e}")
             return []
 
     def clear(
         self,
+        agent_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> None:
-        r"""Removes all records from the Mem0 storage system."""
+        r"""Removes all records from the Mem0 storage system.
+
+        Args:
+            agent_id (Optional[str]): Specific agent ID to clear memories for.
+            user_id (Optional[str]): Specific user ID to clear memories for.
+        """
         try:
-            filters = self._prepare_filters(
-                agent_id=self.agent_id,
-                user_id=self.user_id,
-            )
-            self.client.delete_users(**filters)
+            # Use provided IDs or fall back to instance defaults
+            target_user_id = user_id or self.user_id
+            target_agent_id = agent_id or self.agent_id
+
+            # Build kwargs for delete_users method
+            kwargs = {}
+            if target_user_id:
+                kwargs['user_id'] = target_user_id
+            if target_agent_id:
+                kwargs['agent_id'] = target_agent_id
+
+            if kwargs:
+                # Use delete_users (plural) - this is the correct method name
+                self.client.delete_users(**kwargs)
+                logger.info(
+                    f"Successfully cleared memories with filters: {kwargs}"
+                )
+            else:
+                logger.warning(
+                    "No user_id or agent_id available for clearing memories"
+                )
+
         except Exception as e:
             logger.error(f"Error deleting memories: {e}")
-            logger.error(f"Error: {e}")

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,20 +111,21 @@ 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,
             )
 
-            self._client.create_vidx_with_vec_index_param(
-                table_name=self.table_name, vidx_param=index_params.params[0]
-            )
+            # Get the first index parameter
+            first_index_param = next(iter(index_params), None)
+            if first_index_param is not None:
+                self._client.create_vidx_with_vec_index_param(
+                    table_name=self.table_name, vidx_param=first_index_param
+                )
 
             logger.info(f"Created table {self.table_name} with vector index")
         else:

camel/storages/vectordb_storages/qdrant.py

@@ -14,6 +14,7 @@
 import logging
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
+from uuid import UUID
 
 if TYPE_CHECKING:
     from qdrant_client import QdrantClient
@@ -251,7 +252,6 @@ class QdrantStorage(BaseVectorStorage):
             else None,
             "vector_count": collection_info.points_count,
             "status": collection_info.status,
-            "vectors_count": collection_info.vectors_count,
             "config": collection_info.config,
         }
 
@@ -304,7 +304,7 @@ class QdrantStorage(BaseVectorStorage):
         """
         from qdrant_client.http.models import PointIdsList, UpdateStatus
 
-        points = cast(List[Union[str, int]], ids)
+        points = cast(List[Union[int, str, UUID]], ids)
 
         op_info = self._client.set_payload(
             collection_name=self.collection_name,
@@ -376,7 +376,7 @@ class QdrantStorage(BaseVectorStorage):
             op_info = self._client.delete(
                 collection_name=self.collection_name,
                 points_selector=PointIdsList(
-                    points=cast(List[Union[int, str]], ids)
+                    points=cast(List[Union[int, str, UUID]], ids)
                 ),
                 **kwargs,
             )

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
@@ -37,9 +37,12 @@ from .code_execution import CodeExecutionToolkit
 from .github_toolkit import GithubToolkit
 from .google_scholar_toolkit import GoogleScholarToolkit
 from .google_calendar_toolkit import GoogleCalendarToolkit
+from .gmail_toolkit import GmailToolkit
 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,14 +64,13 @@ 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
 from .data_commons_toolkit import DataCommonsToolkit
 from .thinking_toolkit import ThinkingToolkit
 from .pyautogui_toolkit import PyAutoGUIToolkit
-from .openai_agent_toolkit import OpenAIAgentToolkit
 from .searxng_toolkit import SearxNGToolkit
 from .jina_reranker_toolkit import JinaRerankerToolkit
 from .pulse_mcp_search_toolkit import PulseMCPSearchToolkit
@@ -76,6 +78,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
@@ -88,7 +91,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',
@@ -103,7 +109,9 @@ __all__ = [
     'SearchToolkit',
     'SlackToolkit',
     'WhatsAppToolkit',
-    'OpenAIImageToolkit',
+    'WeChatOfficialToolkit',
+    'DingtalkToolkit',
+    'ImageGenToolkit',
     'TwitterToolkit',
     'WeatherToolkit',
     'RetrievalToolkit',
@@ -115,6 +123,7 @@ __all__ = [
     'AsyncAskNewsToolkit',
     'GoogleScholarToolkit',
     'GoogleCalendarToolkit',
+    'GmailToolkit',
     'NotionToolkit',
     'ArxivToolkit',
     'HumanToolkit',
@@ -136,14 +145,14 @@ __all__ = [
     'ImageAnalysisToolkit',
     'BrowserToolkit',
     'AsyncBrowserToolkit',
-    'FileWriteToolkit',
+    'FileToolkit',
+    'FileWriteToolkit',  # Deprecated, use FileToolkit instead
     'PPTXToolkit',
     'TerminalToolkit',
     'PubMedToolkit',
     'DataCommonsToolkit',
     'ThinkingToolkit',
     'PyAutoGUIToolkit',
-    'OpenAIAgentToolkit',
     'SearxNGToolkit',
     'JinaRerankerToolkit',
     'OrigeneToolkit',
@@ -151,9 +160,10 @@ __all__ = [
     'KlavisToolkit',
     'ACIToolkit',
     'PlaywrightMCPToolkit',
+    'ResendToolkit',
     'WolframAlphaToolkit',
     'BohriumToolkit',
-    'OpenAIImageToolkit',
+    'OpenAIImageToolkit',  # Backward compatibility
     'TaskPlanningToolkit',
     'HybridBrowserToolkit',
     'EdgeOnePagesMCPToolkit',
@@ -166,5 +176,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/base.py

@@ -16,7 +16,7 @@ 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
@@ -35,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.")
@@ -48,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

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