camel-ai 0.2.76a4__py3-none-any.whl → 0.2.76a5__py3-none-any.whl

camel/memories/records.py

@@ -15,8 +15,8 @@
 # Enables postponed evaluation of annotations (for string-based type hints)
 from __future__ import annotations
 
+import inspect
 import time
-from dataclasses import asdict
 from typing import Any, ClassVar, Dict
 from uuid import UUID, uuid4
 
@@ -63,6 +63,20 @@ class MemoryRecord(BaseModel):
         "FunctionCallingMessage": FunctionCallingMessage,
     }
 
+    # Cache for constructor parameters (performance optimization)
+    _constructor_params_cache: ClassVar[Dict[str, set]] = {}
+
+    @classmethod
+    def _get_constructor_params(cls, message_cls) -> set:
+        """Get constructor parameters for a message class with caching."""
+        cls_name = message_cls.__name__
+        if cls_name not in cls._constructor_params_cache:
+            sig = inspect.signature(message_cls.__init__)
+            cls._constructor_params_cache[cls_name] = set(
+                sig.parameters.keys()
+            ) - {'self'}
+        return cls._constructor_params_cache[cls_name]
+
     @classmethod
     def from_dict(cls, record_dict: Dict[str, Any]) -> "MemoryRecord":
         r"""Reconstruct a :obj:`MemoryRecord` from the input dict.
@@ -70,14 +84,42 @@ class MemoryRecord(BaseModel):
         Args:
             record_dict(Dict[str, Any]): A dict generated by :meth:`to_dict`.
         """
+        from camel.types import OpenAIBackendRole, RoleType
+
         message_cls = cls._MESSAGE_TYPES[record_dict["message"]["__class__"]]
-        kwargs: Dict = record_dict["message"].copy()
-        kwargs.pop("__class__")
-        reconstructed_message = message_cls(**kwargs)
+        data = record_dict["message"].copy()
+        data.pop("__class__")
+
+        # Convert role_type string to enum
+        if "role_type" in data and isinstance(data["role_type"], str):
+            data["role_type"] = RoleType(data["role_type"])
+
+        # Get valid constructor parameters (cached)
+        valid_params = cls._get_constructor_params(message_cls)
+
+        # Separate constructor args from extra fields
+        kwargs = {k: v for k, v in data.items() if k in valid_params}
+        extra_fields = {k: v for k, v in data.items() if k not in valid_params}
+
+        # Handle meta_dict properly: merge existing meta_dict with extra fields
+        existing_meta = kwargs.get("meta_dict", {}) or {}
+        if extra_fields:
+            # Extra fields take precedence, but preserve existing meta_dict
+            # structure
+            merged_meta = {**existing_meta, **extra_fields}
+            kwargs["meta_dict"] = merged_meta
+        elif not existing_meta:
+            kwargs["meta_dict"] = None
+
+        # Convert role_at_backend
+        role_at_backend = record_dict["role_at_backend"]
+        if isinstance(role_at_backend, str):
+            role_at_backend = OpenAIBackendRole(role_at_backend)
+
         return cls(
             uuid=UUID(record_dict["uuid"]),
-            message=reconstructed_message,
-            role_at_backend=record_dict["role_at_backend"],
+            message=message_cls(**kwargs),
+            role_at_backend=role_at_backend,
             extra_info=record_dict["extra_info"],
             timestamp=record_dict["timestamp"],
             agent_id=record_dict["agent_id"],
@@ -91,9 +133,11 @@ class MemoryRecord(BaseModel):
             "uuid": str(self.uuid),
             "message": {
                 "__class__": self.message.__class__.__name__,
-                **asdict(self.message),
+                **self.message.to_dict(),
             },
-            "role_at_backend": self.role_at_backend,
+            "role_at_backend": self.role_at_backend.value
+            if hasattr(self.role_at_backend, "value")
+            else self.role_at_backend,
             "extra_info": self.extra_info,
             "timestamp": self.timestamp,
             "agent_id": self.agent_id,

camel/messages/base.py

@@ -554,7 +554,7 @@ class BaseMessage:
         """
         return {
             "role_name": self.role_name,
-            "role_type": self.role_type.name,
+            "role_type": self.role_type.value,
             **(self.meta_dict or {}),
             "content": self.content,
         }

camel/models/__init__.py

@@ -19,6 +19,7 @@ from .azure_openai_model import AzureOpenAIModel
 from .base_audio_model import BaseAudioModel
 from .base_model import BaseModelBackend
 from .cohere_model import CohereModel
+from .cometapi_model import CometAPIModel
 from .crynux_model import CrynuxModel
 from .deepseek_model import DeepSeekModel
 from .fish_audio_model import FishAudioModel
@@ -69,6 +70,7 @@ __all__ = [
     'StubModel',
     'ZhipuAIModel',
     'CohereModel',
+    'CometAPIModel',
     'ModelFactory',
     'ModelManager',
     'LiteLLMModel',

camel/models/cometapi_model.py

@@ -0,0 +1,83 @@
+# ========= 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. =========
+import os
+from typing import Any, Dict, Optional, Union
+
+from camel.configs import CometAPIConfig
+from camel.models.openai_compatible_model import OpenAICompatibleModel
+from camel.types import ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    api_keys_required,
+)
+
+
+class CometAPIModel(OpenAICompatibleModel):
+    r"""LLM API served by CometAPI in a unified OpenAICompatibleModel
+    interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`.
+            If:obj:`None`, :obj:`CometAPIConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating
+            with the CometAPI service. (default: :obj:`None`).
+        url (Optional[str], optional): The url to the CometAPI service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+        max_retries (int, optional): Maximum number of retries for API calls.
+            (default: :obj:`3`)
+        **kwargs (Any): Additional arguments to pass to the client
+            initialization.
+    """
+
+    @api_keys_required([("api_key", "COMETAPI_KEY")])
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
+        max_retries: int = 3,
+        **kwargs: Any,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = CometAPIConfig().as_dict()
+        api_key = api_key or os.environ.get("COMETAPI_KEY")
+        url = url or os.environ.get(
+            "COMETAPI_API_BASE_URL", "https://api.cometapi.com/v1"
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(
+            model_type=model_type,
+            model_config_dict=model_config_dict,
+            api_key=api_key,
+            url=url,
+            token_counter=token_counter,
+            timeout=timeout,
+            max_retries=max_retries,
+            **kwargs,
+        )

camel/models/model_factory.py

@@ -22,6 +22,7 @@ from camel.models.aws_bedrock_model import AWSBedrockModel
 from camel.models.azure_openai_model import AzureOpenAIModel
 from camel.models.base_model import BaseModelBackend
 from camel.models.cohere_model import CohereModel
+from camel.models.cometapi_model import CometAPIModel
 from camel.models.crynux_model import CrynuxModel
 from camel.models.deepseek_model import DeepSeekModel
 from camel.models.gemini_model import GeminiModel
@@ -86,6 +87,7 @@ class ModelFactory:
         ModelPlatformType.AZURE: AzureOpenAIModel,
         ModelPlatformType.ANTHROPIC: AnthropicModel,
         ModelPlatformType.GROQ: GroqModel,
+        ModelPlatformType.COMETAPI: CometAPIModel,
         ModelPlatformType.NEBIUS: NebiusModel,
         ModelPlatformType.LMSTUDIO: LMStudioModel,
         ModelPlatformType.OPENROUTER: OpenRouterModel,

camel/retrievers/auto_retriever.py

@@ -97,6 +97,7 @@ class AutoRetriever:
                     "URL (database url) and API key required for TiDB storage "
                     "are not provided. Format: "
                     "mysql+pymysql://<username>:<password>@<host>:4000/test"
+                    "You can get the database url from https://tidbcloud.com/console/clusters"
                 )
             return TiDBStorage(
                 vector_dim=self.embedding_model.get_output_dim(),

camel/societies/workforce/workforce.py

@@ -23,6 +23,7 @@ from collections import deque
 from enum import Enum
 from typing import (
     Any,
+    Callable,
     Coroutine,
     Deque,
     Dict,
@@ -32,6 +33,7 @@ from typing import (
     Set,
     Tuple,
     Union,
+    cast,
 )
 
 from colorama import Fore
@@ -71,6 +73,7 @@ from camel.tasks.task import (
 )
 from camel.toolkits import (
     CodeExecutionToolkit,
+    FunctionTool,
     SearchToolkit,
     TaskPlanningToolkit,
     ThinkingToolkit,
@@ -345,10 +348,7 @@ class Workforce(BaseNode):
                     None,
                 ),
                 output_language=coordinator_agent.output_language,
-                tools=[
-                    tool.func
-                    for tool in coordinator_agent._internal_tools.values()
-                ],
+                tools=list(coordinator_agent._internal_tools.values()),
                 external_tools=[
                     schema
                     for schema in coordinator_agent._external_tool_schemas.values()  # noqa: E501
@@ -398,9 +398,11 @@ class Workforce(BaseNode):
 
             # Since ChatAgent constructor uses a dictionary with
             # function names as keys, we don't need to manually deduplicate.
-            combined_tools = [
-                tool.func for tool in task_agent._internal_tools.values()
-            ] + [tool.func for tool in task_planning_tools]
+            combined_tools: List[Union[FunctionTool, Callable]] = cast(
+                List[Union[FunctionTool, Callable]],
+                list(task_agent._internal_tools.values())
+                + task_planning_tools,
+            )
 
             # Create a new agent with the provided agent's configuration
             # but with the combined system message and tools

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/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/toolkits/__init__.py

@@ -41,6 +41,7 @@ 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
@@ -76,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
@@ -107,6 +109,7 @@ __all__ = [
     'SlackToolkit',
     'WhatsAppToolkit',
     'WeChatOfficialToolkit',
+    'DingtalkToolkit',
     'ImageGenToolkit',
     'TwitterToolkit',
     'WeatherToolkit',
@@ -155,6 +158,7 @@ __all__ = [
     'KlavisToolkit',
     'ACIToolkit',
     'PlaywrightMCPToolkit',
+    'ResendToolkit',
     'WolframAlphaToolkit',
     'BohriumToolkit',
     'OpenAIImageToolkit',  # Backward compatibility