camel-ai 0.2.65__py3-none-any.whl → 0.2.83a6__py3-none-any.whl

camel/utils/deduplication.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2026 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
 
 
 from typing import Dict, List, Literal, Optional

camel/utils/filename.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2026 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
 import platform
 import re
 import unicodedata

camel/utils/langfuse.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2026 @ 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
@@ -10,17 +10,19 @@
 # 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. =========
+# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-import threading
+from contextvars import ContextVar
 from typing import Any, Dict, List, Optional
 
 from camel.logger import get_logger
 from camel.utils import dependencies_required
 
 logger = get_logger(__name__)
-# Thread-local storage for agent session IDs
-_local = threading.local()
+
+_agent_session_id_var: ContextVar[Optional[str]] = ContextVar(
+    'agent_session_id', default=None
+)
 
 # Global flag to track if Langfuse has been configured
 _langfuse_configured = False
@@ -85,6 +87,7 @@ def configure_langfuse(
     if not enabled:
         _langfuse_configured = False
         logger.info("Langfuse tracing disabled for CAMEL models")
+        return
 
     logger.debug(
         f"Configuring Langfuse - enabled: {enabled}, "
@@ -118,23 +121,28 @@ def is_langfuse_available() -> bool:
 
 
 def set_current_agent_session_id(session_id: str) -> None:
-    r"""Set the session ID for the current agent in thread-local storage.
+    r"""Set the session ID for the current agent in context-local storage.
+
+    This is safe to use in both sync and async contexts.
+    In async contexts, each coroutine maintains its own value.
 
     Args:
         session_id(str): The session ID to set for the current agent.
     """
-
-    _local.agent_session_id = session_id
+    _agent_session_id_var.set(session_id)
 
 
 def get_current_agent_session_id() -> Optional[str]:
-    r"""Get the session ID for the current agent from thread-local storage.
+    r"""Get the session ID for the current agent from context-local storage.
+
+    This is safe to use in both sync and async contexts.
+    In async contexts, returns the value for the current coroutine.
 
     Returns:
         Optional[str]: The session ID for the current agent.
     """
     if is_langfuse_available():
-        return getattr(_local, 'agent_session_id', None)
+        return _agent_session_id_var.get()
     return None
 
 

camel/utils/mcp.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2026 @ 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
@@ -10,10 +10,124 @@
 # 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. =========
+# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
 import functools
 import inspect
-from typing import Any, Callable, Optional
+import warnings
+from typing import (
+    Any,
+    Callable,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from pydantic import create_model
+from pydantic.errors import PydanticSchemaGenerationError
+
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def _is_pydantic_serializable(type_annotation: Any) -> Tuple[bool, str]:
+    r"""Check if a type annotation is Pydantic serializable.
+
+    Args:
+        type_annotation: The type annotation to check
+
+    Returns:
+        Tuple[bool, str]: (is_serializable, error_message)
+    """
+    # Handle None type
+    if type_annotation is type(None) or type_annotation is None:
+        return True, ""
+
+    # Handle generic types (List, Dict, Optional, etc.)
+    origin = get_origin(type_annotation)
+    if origin is not None:
+        args = get_args(type_annotation)
+
+        # For Union types (including Optional), check all args
+        if origin is Union:
+            for arg in args:
+                is_serializable, error_msg = _is_pydantic_serializable(arg)
+                if not is_serializable:
+                    return False, error_msg
+            return True, ""
+
+        # For List, Set, Tuple, etc., check the contained types
+        if origin in (list, set, tuple, frozenset):
+            for arg in args:
+                is_serializable, error_msg = _is_pydantic_serializable(arg)
+                if not is_serializable:
+                    return False, error_msg
+            return True, ""
+
+        # For Dict, check both key and value types
+        if origin is dict:
+            for arg in args:
+                is_serializable, error_msg = _is_pydantic_serializable(arg)
+                if not is_serializable:
+                    return False, error_msg
+            return True, ""
+
+    # Try to create a simple pydantic model with this type
+    try:
+        create_model("TestModel", test_field=(type_annotation, ...))
+        # If model creation succeeds, the type is serializable
+        return True, ""
+    except (PydanticSchemaGenerationError, TypeError, ValueError) as e:
+        error_msg = (
+            f"Type '{type_annotation}' is not Pydantic serializable. "
+            f"Consider using a custom serializable type or converting "
+            f"to bytes/base64. Error: {e!s}"
+        )
+        return False, error_msg
+
+
+def _validate_function_types(func: Callable[..., Any]) -> List[str]:
+    r"""Validate function parameter and return types are Pydantic serializable.
+
+    Args:
+        func (Callable[..., Any]): The function to validate.
+
+    Returns:
+        List[str]: List of error messages for incompatible types.
+    """
+    errors = []
+
+    try:
+        type_hints = get_type_hints(func)
+    except (NameError, AttributeError) as e:
+        # If we can't get type hints, skip validation
+        logger.warning(f"Could not get type hints for {func.__name__}: {e}")
+        return []
+
+    # Check return type
+    return_type = type_hints.get('return', Any)
+    if return_type != Any:
+        is_serializable, error_msg = _is_pydantic_serializable(return_type)
+        if not is_serializable:
+            errors.append(f"Return type: {error_msg}")
+
+    # Check parameter types
+    sig = inspect.signature(func)
+    for param_name, _param in sig.parameters.items():
+        if param_name == 'self':
+            continue
+
+        param_type = type_hints.get(param_name, Any)
+        if param_type != Any:
+            is_serializable, error_msg = _is_pydantic_serializable(param_type)
+            if not is_serializable:
+                errors.append(f"Parameter '{param_name}': {error_msg}")
+
+    return errors
 
 
 class MCPServer:
@@ -55,7 +169,7 @@ class MCPServer:
 
     def __init__(
         self,
-        function_names: Optional[list[str]] = None,
+        function_names: Optional[List[str]] = None,
         server_name: Optional[str] = None,
     ):
         self.function_names = function_names
@@ -106,11 +220,11 @@ class MCPServer:
         """
         from mcp.server.fastmcp import FastMCP
 
-        from camel.toolkits.base import BaseToolkit
-
         original_init = cls.__init__
 
         def new_init(instance, *args, **kwargs):
+            from camel.toolkits.base import BaseToolkit
+
             original_init(instance, *args, **kwargs)
             self.server_name = self.server_name or cls.__name__
             instance.mcp = FastMCP(self.server_name)
@@ -135,6 +249,26 @@ class MCPServer:
                         f"Method {name} not found in class {cls.__name__} or "
                         "cannot be called."
                     )
+
+                # Validate function types for Pydantic compatibility
+                type_errors = _validate_function_types(func)
+                if type_errors:
+                    error_message = (
+                        f"Method '{name}' in class '{cls.__name__}' has "
+                        f"non-Pydantic-serializable types:\n"
+                        + "\n".join(f"  - {error}" for error in type_errors)
+                        + "\n\nSuggestions:"
+                        + "\n  - Use standard Python types (str, int, float, bool, bytes)"  # noqa: E501
+                        + "\n  - Convert complex objects to JSON strings or bytes"  # noqa: E501
+                        + "\n  - Create custom Pydantic models for complex data"  # noqa: E501
+                        + "\n  - Use base64 encoding for binary data like images"  # noqa: E501
+                    )
+
+                    # For now, issue a warning instead of raising an error
+                    # This allows gradual migration while alerting developers
+                    warnings.warn(error_message, UserWarning, stacklevel=3)
+                    logger.warning(error_message)
+
                 wrapper = self.make_wrapper(func)
                 instance.mcp.tool(name=name)(wrapper)
 

camel/utils/mcp_client.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2026 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
 """
 Unified MCP Client
 
@@ -113,7 +113,11 @@ class ServerConfig(BaseModel):
     # Advanced options
     sse_read_timeout: float = 300.0  # 5 minutes
     terminate_on_close: bool = True
-    # For HTTP URLs, prefer SSE over StreamableHTTP
+
+    # New transport type parameter
+    type: Optional[str] = None
+
+    # Legacy parameter for backward compatibility
     prefer_sse: bool = False
 
     @model_validator(mode='after')
@@ -128,11 +132,43 @@ class ServerConfig(BaseModel):
         if self.command and self.url:
             raise ValueError("Cannot specify both 'command' and 'url'")
 
+        # Validate type if provided
+        if self.type is not None:
+            valid_types = {"stdio", "sse", "streamable_http", "websocket"}
+            if self.type not in valid_types:
+                raise ValueError(
+                    f"Invalid type: "
+                    f"'{self.type}'. "
+                    f"Valid options: {valid_types}"
+                )
+
+        # Issue deprecation warning if prefer_sse is used
+        if self.prefer_sse and self.type is None:
+            import warnings
+
+            warnings.warn(
+                "The 'prefer_sse' parameter is deprecated. "
+                "Use 'type=\"sse\"' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
         return self
 
     @property
     def transport_type(self) -> TransportType:
         r"""Automatically detect transport type based on configuration."""
+        # Use explicit transport type if provided
+        if self.type is not None:
+            transport_map = {
+                "stdio": TransportType.STDIO,
+                "sse": TransportType.SSE,
+                "streamable_http": TransportType.STREAMABLE_HTTP,
+                "websocket": TransportType.WEBSOCKET,
+            }
+            return transport_map[self.type]
+
+        # If no type is provided, fall back to automatic detection
         if self.command:
             return TransportType.STDIO
         elif self.url:
@@ -173,8 +209,6 @@ class MCPClient:
             initialization. (default: :obj:`None`)
         timeout (Optional[float], optional): Timeout for waiting for messages
             from the server in seconds. (default: :obj:`10.0`)
-        strict (Optional[bool], optional): Strict mode for generating
-            FunctionTool objects. (default: :obj:`False`)
 
     Examples:
         STDIO server:
@@ -209,20 +243,6 @@ class MCPClient:
             async with MCPClient({"url": "ws://localhost:8080/mcp"}) as client:
                 tools = client.get_tools()
 
-        With strict mode enabled:
-
-        .. code-block:: python
-
-            async with MCPClient({
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@modelcontextprotocol/server-filesystem",
-                    "/path"
-                ]
-            }, strict=True) as client:
-                tools = client.get_tools()
-
     Attributes:
         config (ServerConfig): The server configuration object.
         client_info (Optional[types.Implementation]): Client implementation
@@ -235,14 +255,12 @@ class MCPClient:
         config: Union[ServerConfig, Dict[str, Any]],
         client_info: Optional[types.Implementation] = None,
         timeout: Optional[float] = 10.0,
-        strict: Optional[bool] = False,
     ):
         # Convert dict config to ServerConfig if needed
         if isinstance(config, dict):
             config = ServerConfig(**config)
 
         self.config = config
-        self.strict = strict
 
         # Validate transport type early (this will raise ValueError if invalid)
         _ = self.config.transport_type
@@ -335,6 +353,14 @@ class MCPClient:
                 finally:
                     self._connection_context = None
 
+            # Add a small delay to allow subprocess cleanup on Windows
+            # This prevents "Event loop is closed" errors during shutdown
+            import asyncio
+            import sys
+
+            if sys.platform == "win32":
+                await asyncio.sleep(0.01)
+
         finally:
             # Ensure state is reset
             self._tools = []
@@ -766,7 +792,6 @@ class MCPClient:
                 "name": mcp_tool.name,
                 "description": mcp_tool.description
                 or "No description provided.",
-                "strict": self.strict,
                 "parameters": parameters,
             },
         }
@@ -932,8 +957,7 @@ def create_mcp_client(
             dictionary is provided, it will be automatically converted to
             a :obj:`ServerConfig`.
         **kwargs: Additional keyword arguments passed to the :obj:`MCPClient`
-            constructor, such as :obj:`client_info`, :obj:`timeout`, and
-            :obj:`strict`.
+            constructor, such as :obj:`client_info`, :obj:`timeout`.
 
     Returns:
         MCPClient: A configured :obj:`MCPClient` instance ready for use as
@@ -972,20 +996,6 @@ def create_mcp_client(
                 "url": "ws://localhost:8080/mcp"
             }) as client:
                 tools = client.get_tools()
-
-        With strict mode enabled:
-
-        .. code-block:: python
-
-            async with create_mcp_client({
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@modelcontextprotocol/server-filesystem",
-                    "/path",
-                ],
-            }, strict=True) as client:
-                tools = client.get_tools()
     """
     return MCPClient(config, **kwargs)
 

camel/utils/message_summarizer.py

@@ -0,0 +1,148 @@
+# ========= Copyright 2023-2026 @ 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-2026 @ CAMEL-AI.org. All Rights Reserved. =========
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from camel.agents import ChatAgent
+from camel.messages import BaseMessage
+from camel.models import BaseModelBackend, ModelFactory
+from camel.types import ModelPlatformType, ModelType
+
+
+class MessageSummary(BaseModel):
+    r"""Schema for structured message summaries.
+
+    Attributes:
+        summary (str): A brief, one-sentence summary of the conversation.
+        participants (List[str]): The roles of participants involved.
+        key_topics_and_entities (List[str]): Important topics, concepts, and
+            entities discussed.
+        decisions_and_outcomes (List[str]): Key decisions, conclusions, or
+            outcomes reached.
+        action_items (List[str]): A list of specific tasks or actions to be
+            taken, with assignees if mentioned.
+        progress_on_main_task (str): A summary of progress made on the
+            primary task.
+    """
+
+    summary: str = Field(
+        description="A brief, one-sentence summary of the conversation."
+    )
+    participants: List[str] = Field(
+        description="The roles of participants involved."
+    )
+    key_topics_and_entities: List[str] = Field(
+        description="Important topics, concepts, and entities discussed."
+    )
+    decisions_and_outcomes: List[str] = Field(
+        description="Key decisions, conclusions, or outcomes reached."
+    )
+    action_items: List[str] = Field(
+        description=(
+            "A list of specific tasks or actions to be taken, with assignees "
+            "if mentioned."
+        )
+    )
+    progress_on_main_task: str = Field(
+        description="A summary of progress made on the primary task."
+    )
+
+
+class MessageSummarizer:
+    r"""Utility class for generating structured summaries of chat messages.
+
+    Args:
+        model_backend (Optional[BaseModelBackend], optional):
+            The model backend to use for summarization.
+            If not provided, a default model backend will be created.
+    """
+
+    def __init__(
+        self,
+        model_backend: Optional[BaseModelBackend] = None,
+    ):
+        if model_backend is None:
+            self.model_backend = ModelFactory.create(
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.GPT_4O_MINI,
+            )
+        else:
+            self.model_backend = model_backend
+        self.agent = ChatAgent(
+            BaseMessage.make_assistant_message(
+                role_name="Message Summarizer",
+                content=(
+                    "You are an expert conversation summarizer. Your task is "
+                    "to analyze chat messages and create a structured summary "
+                    "in JSON format. The summary should capture:\n"
+                    "- summary: A brief, one-sentence summary of the "
+                    "conversation.\n"
+                    "- participants: The roles of participants involved.\n"
+                    "- key_topics_and_entities: Important topics, concepts, "
+                    "and entities discussed.\n"
+                    "- decisions_and_outcomes: Key decisions, conclusions, or "
+                    "outcomes reached.\n"
+                    "- action_items: A list of specific tasks or actions to "
+                    "be taken, with assignees if mentioned.\n"
+                    "- progress_on_main_task: A summary of progress made on "
+                    "the primary task.\n\n"
+                    "Your response must be a JSON object that strictly "
+                    "adheres to this structure. Be concise and accurate."
+                ),
+            ),
+            model=self.model_backend,
+        )
+
+    def summarize(self, messages: List[BaseMessage]) -> MessageSummary:
+        r"""Generate a structured summary of the provided messages.
+
+        Args:
+            messages (List[BaseMessage]): List of messages to summarize.
+
+        Returns:
+            MessageSummary: Structured summary of the conversation.
+
+        Raises:
+            ValueError: If the messages list is empty or if the model's
+            response cannot be parsed as valid JSON.
+        """
+        if not messages:
+            raise ValueError("Cannot summarize an empty list of messages.")
+
+        # Construct prompt from messages
+        message_text = "\n".join(
+            f"{msg.role_name}: {msg.content}" for msg in messages
+        )
+        prompt = (
+            "Please analyze the following chat messages and generate a "
+            "structured summary.\n\n"
+            f"MESSAGES:\n\"\"\"\n{message_text}\n\"\"\"\n\n"
+            "Your response must be a JSON object that strictly adheres to the "
+            "required format."
+        )
+
+        # Get structured summary from model with forced JSON response
+        response = self.agent.step(prompt, response_format=MessageSummary)
+
+        if response.msg is None or response.msg.parsed is None:
+            raise ValueError(
+                "Failed to get a structured summary from the model."
+            )
+
+        summary = response.msg.parsed
+        if not isinstance(summary, MessageSummary):
+            raise ValueError("The parsed response is not a MessageSummary.")
+
+        return summary

camel/utils/response_format.py

@@ -1,4 +1,4 @@
-# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# ========= Copyright 2023-2026 @ 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
@@ -10,7 +10,7 @@
 # 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. =========
+# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
 
 from __future__ import annotations