camel-ai 0.2.65__py3-none-any.whl → 0.2.66__py3-none-any.whl

camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.65'
+__version__ = '0.2.66'
 
 __all__ = [
     '__version__',

camel/agents/mcp_agent.py

@@ -125,7 +125,6 @@ class MCPAgent(ChatAgent):
         local_config_path: Optional[str] = None,
         tools: Optional[List[Union[FunctionTool, Callable]]] = None,
         function_calling_available: bool = True,
-        strict: bool = False,
         **kwargs,
     ):
         if model is None:
@@ -145,7 +144,6 @@ class MCPAgent(ChatAgent):
 
         self.local_config = local_config
         self.function_calling_available = function_calling_available
-        self.strict = strict
 
         if function_calling_available:
             sys_msg_content = "You are a helpful assistant, and you prefer "
@@ -179,7 +177,7 @@ class MCPAgent(ChatAgent):
         if self.local_config:
             config_dict.update(self.local_config)
 
-        return MCPToolkit(config_dict=config_dict, strict=self.strict)
+        return MCPToolkit(config_dict=config_dict)
 
     def add_registry(self, registry_config: BaseMCPRegistryConfig) -> None:
         r"""Add a new registry configuration to the agent.
@@ -213,7 +211,6 @@ class MCPAgent(ChatAgent):
         ] = None,
         model: Optional[BaseModelBackend] = None,
         function_calling_available: bool = False,
-        strict: bool = False,
         **kwargs,
     ) -> "MCPAgent":
         r"""Create and connect an MCPAgent instance.
@@ -279,7 +276,6 @@ class MCPAgent(ChatAgent):
             registry_configs=final_registry_configs,
             model=model,
             function_calling_available=function_calling_available,
-            strict=strict,
             **kwargs,
         )
 

camel/societies/workforce/role_playing_worker.py

@@ -25,9 +25,9 @@ from camel.societies.workforce.prompts import (
     ROLEPLAY_PROCESS_TASK_PROMPT,
     ROLEPLAY_SUMMARIZE_PROMPT,
 )
-from camel.societies.workforce.utils import TaskResult, validate_task_content
+from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
-from camel.tasks.task import Task, TaskState
+from camel.tasks.task import Task, TaskState, validate_task_content
 from camel.utils import print_text_animated
 
 

camel/societies/workforce/single_agent_worker.py

@@ -21,9 +21,9 @@ from colorama import Fore
 
 from camel.agents import ChatAgent
 from camel.societies.workforce.prompts import PROCESS_TASK_PROMPT
-from camel.societies.workforce.utils import TaskResult, validate_task_content
+from camel.societies.workforce.utils import TaskResult
 from camel.societies.workforce.worker import Worker
-from camel.tasks.task import Task, TaskState
+from camel.tasks.task import Task, TaskState, validate_task_content
 from camel.utils import print_text_animated
 
 

camel/societies/workforce/utils.py

@@ -16,10 +16,6 @@ from typing import Callable
 
 from pydantic import BaseModel, Field
 
-from camel.logger import get_logger
-
-logger = get_logger(__name__)
-
 
 class WorkerConf(BaseModel):
     r"""The configuration of a worker."""
@@ -75,50 +71,3 @@ def check_if_running(running: bool) -> Callable:
         return wrapper
 
     return decorator
-
-
-def validate_task_content(
-    content: str, task_id: str = "unknown", min_length: int = 10
-) -> bool:
-    r"""Validates task result content to avoid silent failures.
-    It performs basic checks to ensure the content meets minimum
-    quality standards.
-
-    Args:
-        content (str): The task result content to validate.
-        task_id (str): Task ID for logging purposes.
-            (default: :obj:`"unknown"`)
-        min_length (int): Minimum content length after stripping whitespace.
-            (default: :obj:`10`)
-
-    Returns:
-        bool: True if content passes validation, False otherwise.
-    """
-    # 1: Content must not be None
-    if content is None:
-        logger.warning(f"Task {task_id}: None content rejected")
-        return False
-
-    # 2: Content must not be empty after stripping whitespace
-    stripped_content = content.strip()
-    if not stripped_content:
-        logger.warning(
-            f"Task {task_id}: Empty or whitespace-only content rejected."
-        )
-        return False
-
-    # 3: Content must meet minimum meaningful length
-    if len(stripped_content) < min_length:
-        logger.warning(
-            f"Task {task_id}: Content too short ({len(stripped_content)} "
-            f"chars < {min_length} minimum). Content preview: "
-            f"'{stripped_content[:50]}...'"
-        )
-        return False
-
-    # All validation checks passed
-    logger.debug(
-        f"Task {task_id}: Content validation passed "
-        f"({len(stripped_content)} chars)"
-    )
-    return True

camel/societies/workforce/workforce.py

@@ -40,7 +40,7 @@ from camel.societies.workforce.utils import (
     check_if_running,
 )
 from camel.societies.workforce.worker import Worker
-from camel.tasks.task import Task, TaskState
+from camel.tasks.task import Task, TaskState, validate_task_content
 from camel.toolkits import CodeExecutionToolkit, SearchToolkit, ThinkingToolkit
 from camel.types import ModelPlatformType, ModelType
 from camel.utils import dependencies_required
@@ -211,6 +211,15 @@ class Workforce(BaseNode):
         Returns:
             Task: The updated task.
         """
+        if not validate_task_content(task.content, task.id):
+            task.state = TaskState.FAILED
+            task.result = "Task failed: Invalid or empty content provided"
+            logger.warning(
+                f"Task {task.id} rejected: Invalid or empty content. "
+                f"Content preview: '{task.content[:50]}...'"
+            )
+            return task
+
         self.reset()
         self._task = task
         task.state = TaskState.FAILED

camel/tasks/task.py

@@ -19,15 +19,66 @@ from typing import Any, Callable, Dict, List, Literal, Optional, Union
 from pydantic import BaseModel
 
 from camel.agents import ChatAgent
+from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.prompts import TextPrompt
 
+# Note: validate_task_content moved here to avoid circular imports
 from .task_prompt import (
     TASK_COMPOSE_PROMPT,
     TASK_DECOMPOSE_PROMPT,
     TASK_EVOLVE_PROMPT,
 )
 
+logger = get_logger(__name__)
+
+
+def validate_task_content(
+    content: str, task_id: str = "unknown", min_length: int = 10
+) -> bool:
+    r"""Validates task result content to avoid silent failures.
+    It performs basic checks to ensure the content meets minimum
+    quality standards.
+
+    Args:
+        content (str): The task result content to validate.
+        task_id (str): Task ID for logging purposes.
+            (default: :obj:`"unknown"`)
+        min_length (int): Minimum content length after stripping whitespace.
+            (default: :obj:`10`)
+
+    Returns:
+        bool: True if content passes validation, False otherwise.
+    """
+    # 1: Content must not be None
+    if content is None:
+        logger.warning(f"Task {task_id}: None content rejected")
+        return False
+
+    # 2: Content must not be empty after stripping whitespace
+    stripped_content = content.strip()
+    if not stripped_content:
+        logger.warning(
+            f"Task {task_id}: Empty or whitespace-only content rejected."
+        )
+        return False
+
+    # 3: Content must meet minimum meaningful length
+    if len(stripped_content) < min_length:
+        logger.warning(
+            f"Task {task_id}: Content too short ({len(stripped_content)} "
+            f"chars < {min_length} minimum). Content preview: "
+            f"'{stripped_content[:50]}...'"
+        )
+        return False
+
+    # All validation checks passed
+    logger.debug(
+        f"Task {task_id}: Content validation passed "
+        f"({len(stripped_content)} chars)"
+    )
+    return True
+
 
 def parse_response(
     response: str, task_id: Optional[str] = None
@@ -49,7 +100,16 @@ def parse_response(
     if task_id is None:
         task_id = "0"
     for i, content in enumerate(tasks_content):
-        tasks.append(Task(content=content.strip(), id=f"{task_id}.{i}"))
+        stripped_content = content.strip()
+        # validate subtask content before creating the task
+        if validate_task_content(stripped_content, f"{task_id}.{i}"):
+            tasks.append(Task(content=stripped_content, id=f"{task_id}.{i}"))
+        else:
+            logger.warning(
+                f"Skipping invalid subtask {task_id}.{i} "
+                f"during decomposition: "
+                f"Content '{stripped_content[:50]}...' failed validation"
+            )
     return tasks
 
 

camel/toolkits/function_tool.py

@@ -190,7 +190,9 @@ def sanitize_and_enforce_required(parameters_dict):
     r"""Cleans and updates the function schema to conform with OpenAI's
     requirements:
     - Removes invalid 'default' fields from the parameters schema.
-    - Ensures all fields or function parameters are marked as required.
+    - Ensures all fields are marked as required or have null type for optional
+    fields.
+    - Recursively adds additionalProperties: false to all nested objects.
 
     Args:
         parameters_dict (dict): The dictionary representing the function
@@ -198,8 +200,38 @@ def sanitize_and_enforce_required(parameters_dict):
 
     Returns:
         dict: The updated dictionary with invalid defaults removed and all
-            fields set as required.
+            fields properly configured for strict mode.
     """
+
+    def _add_additional_properties_false(obj):
+        r"""Recursively add additionalProperties: false to all objects."""
+        if isinstance(obj, dict):
+            if (
+                obj.get("type") == "object"
+                and "additionalProperties" not in obj
+            ):
+                obj["additionalProperties"] = False
+
+            # Process nested structures
+            for key, value in obj.items():
+                if key == "properties" and isinstance(value, dict):
+                    for prop_value in value.values():
+                        _add_additional_properties_false(prop_value)
+                elif key in [
+                    "items",
+                    "allOf",
+                    "oneOf",
+                    "anyOf",
+                ] and isinstance(value, (dict, list)):
+                    if isinstance(value, dict):
+                        _add_additional_properties_false(value)
+                    elif isinstance(value, list):
+                        for item in value:
+                            _add_additional_properties_false(item)
+                elif key == "$defs" and isinstance(value, dict):
+                    for def_value in value.values():
+                        _add_additional_properties_false(def_value)
+
     # Check if 'function' and 'parameters' exist
     if (
         'function' in parameters_dict
@@ -209,12 +241,52 @@ def sanitize_and_enforce_required(parameters_dict):
         parameters = parameters_dict['function']['parameters']
         properties = parameters.get('properties', {})
 
-        # Remove 'default' key from each property
-        for field in properties.values():
-            field.pop('default', None)
+        # Track which fields should be required vs optional
+        required_fields = []
+
+        # Process each property
+        for field_name, field_schema in properties.items():
+            # Check if this field had a default value (making it optional)
+            had_default = 'default' in field_schema
+
+            # Remove 'default' key from field schema as required by OpenAI
+            field_schema.pop('default', None)
+
+            if had_default:
+                # This field is optional - add null to its type
+                current_type = field_schema.get('type')
+                has_ref = '$ref' in field_schema
+
+                if has_ref:
+                    # Fields with $ref shouldn't have additional type field
+                    # The $ref itself defines the type structure
+                    pass
+                elif current_type:
+                    if isinstance(current_type, str):
+                        # Single type - convert to array with null
+                        field_schema['type'] = [current_type, 'null']
+                    elif (
+                        isinstance(current_type, list)
+                        and 'null' not in current_type
+                    ):
+                        # Array of types - add null if not present
+                        field_schema['type'] = [*current_type, 'null']
+                else:
+                    # No type specified, add null type
+                    field_schema['type'] = ['null']
+
+                # Optional fields are still marked as required in strict mode
+                # but with null type to indicate they can be omitted
+                required_fields.append(field_name)
+            else:
+                # This field is required
+                required_fields.append(field_name)
+
+        # Set all fields as required (strict mode requirement)
+        parameters['required'] = required_fields
 
-        # Mark all keys in 'properties' as required
-        parameters['required'] = list(properties.keys())
+        # Recursively add additionalProperties: false to all objects
+        _add_additional_properties_false(parameters)
 
     return parameters_dict
 

camel/toolkits/mcp_toolkit.py

@@ -98,8 +98,6 @@ class MCPToolkit(BaseToolkit):
         timeout (Optional[float], optional): Timeout for connection attempts
             in seconds. This timeout applies to individual client connections.
             (default: :obj:`None`)
-        strict (Optional[bool], optional): Flag to indicate strict mode.
-            (default: :obj:`False`)
 
     Note:
         At least one of :obj:`clients`, :obj:`config_path`, or
@@ -148,7 +146,6 @@ class MCPToolkit(BaseToolkit):
         config_path: Optional[str] = None,
         config_dict: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        strict: Optional[bool] = False,
     ):
         # Call parent constructor first
         super().__init__(timeout=timeout)
@@ -165,7 +162,6 @@ class MCPToolkit(BaseToolkit):
             raise ValueError(error_msg)
 
         self.clients: List[MCPClient] = clients or []
-        self.strict = strict  # Store strict parameter
         self._is_connected = False
         self._exit_stack: Optional[AsyncExitStack] = None
 
@@ -313,7 +309,6 @@ class MCPToolkit(BaseToolkit):
         config_path: Optional[str] = None,
         config_dict: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        strict: Optional[bool] = False,
     ) -> "MCPToolkit":
         r"""Factory method that creates and connects to all MCP servers.
 
@@ -331,8 +326,6 @@ class MCPToolkit(BaseToolkit):
                 config file. (default: :obj:`None`)
             timeout (Optional[float], optional): Timeout for connection
                 attempts in seconds. (default: :obj:`None`)
-            strict (Optional[bool], optional): Flag to indicate strict mode.
-                (default: :obj:`False`)
 
         Returns:
             MCPToolkit: A fully initialized and connected :obj:`MCPToolkit`
@@ -361,7 +354,6 @@ class MCPToolkit(BaseToolkit):
             config_path=config_path,
             config_dict=config_dict,
             timeout=timeout,
-            strict=strict,
         )
         try:
             await toolkit.connect()
@@ -381,11 +373,10 @@ class MCPToolkit(BaseToolkit):
         config_path: Optional[str] = None,
         config_dict: Optional[Dict[str, Any]] = None,
         timeout: Optional[float] = None,
-        strict: Optional[bool] = False,
     ) -> "MCPToolkit":
         r"""Synchronously create and connect to all MCP servers."""
         return run_async(cls.create)(
-            clients, config_path, config_dict, timeout, strict
+            clients, config_path, config_dict, timeout
         )
 
     def _load_clients_from_config(self, config_path: str) -> List[MCPClient]:
@@ -442,12 +433,10 @@ class MCPToolkit(BaseToolkit):
 
         try:
             # Use the new mcp_client factory function
-            # Pass timeout and strict from toolkit if available
+            # Pass timeout from toolkit if available
             kwargs = {}
             if hasattr(self, "timeout") and self.timeout is not None:
                 kwargs["timeout"] = self.timeout
-            if hasattr(self, "strict") and self.strict is not None:
-                kwargs["strict"] = self.strict
 
             client = create_mcp_client(cfg, **kwargs)
             return client
@@ -455,17 +444,68 @@ class MCPToolkit(BaseToolkit):
             error_msg = f"Failed to create client for server '{name}': {e}"
             raise ValueError(error_msg) from e
 
+    def _ensure_strict_tool_schema(self, tool: FunctionTool) -> FunctionTool:
+        r"""Ensure a tool has a strict schema compatible with OpenAI's
+        requirements.
+
+        Args:
+            tool (FunctionTool): The tool to check and update if necessary.
+
+        Returns:
+            FunctionTool: The tool with a strict schema.
+        """
+        try:
+            schema = tool.get_openai_tool_schema()
+
+            # Check if the tool already has strict mode enabled
+            if schema.get("function", {}).get("strict") is True:
+                return tool
+
+            # Update the schema to be strict
+            if "function" in schema:
+                schema["function"]["strict"] = True
+
+                # Ensure parameters have proper strict mode configuration
+                parameters = schema["function"].get("parameters", {})
+                if parameters:
+                    # Ensure additionalProperties is false
+                    parameters["additionalProperties"] = False
+
+                    # Process properties to handle optional fields
+                    properties = parameters.get("properties", {})
+                    parameters["required"] = list(properties.keys())
+
+                    # Apply the sanitization function from function_tool
+                    from camel.toolkits.function_tool import (
+                        sanitize_and_enforce_required,
+                    )
+
+                    schema = sanitize_and_enforce_required(schema)
+
+            tool.set_openai_tool_schema(schema)
+            logger.debug(
+                f"Updated tool '{tool.get_function_name()}' to strict mode"
+            )
+
+        except Exception as e:
+            logger.warning(f"Failed to ensure strict schema for tool: {e}")
+
+        return tool
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Aggregates all tools from the managed MCP client instances.
 
         Collects and combines tools from all connected MCP clients into a
         single unified list. Each tool is converted to a CAMEL-compatible
-        :obj:`FunctionTool` that can be used with CAMEL agents.
+        :obj:`FunctionTool` that can be used with CAMEL agents. All tools
+        are ensured to have strict schemas compatible with OpenAI's
+        requirements.
 
         Returns:
             List[FunctionTool]: Combined list of all available function tools
-                from all connected MCP servers. Returns an empty list if no
-                clients are connected or if no tools are available.
+                from all connected MCP servers with strict schemas. Returns an
+                empty list if no clients are connected or if no tools are
+                available.
 
         Note:
             This method can be called even when the toolkit is not connected,
@@ -492,14 +532,25 @@ class MCPToolkit(BaseToolkit):
         for i, client in enumerate(self.clients):
             try:
                 client_tools = client.get_tools()
-                all_tools.extend(client_tools)
+
+                # Ensure all tools have strict schemas
+                strict_tools = []
+                for tool in client_tools:
+                    strict_tool = self._ensure_strict_tool_schema(tool)
+                    strict_tools.append(strict_tool)
+
+                all_tools.extend(strict_tools)
                 logger.debug(
-                    f"Client {i+1} contributed {len(client_tools)} tools"
+                    f"Client {i+1} contributed {len(strict_tools)} "
+                    f"tools (strict mode enabled)"
                 )
             except Exception as e:
                 logger.error(f"Failed to get tools from client {i+1}: {e}")
 
-        logger.info(f"Total tools available: {len(all_tools)}")
+        logger.info(
+            f"Total tools available: {len(all_tools)} (all with strict "
+            f"schemas)"
+        )
         return all_tools
 
     def get_text_tools(self) -> str:

camel/utils/mcp_client.py

@@ -173,8 +173,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 +207,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 +219,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
@@ -766,7 +748,6 @@ class MCPClient:
                 "name": mcp_tool.name,
                 "description": mcp_tool.description
                 or "No description provided.",
-                "strict": self.strict,
                 "parameters": parameters,
             },
         }
@@ -932,8 +913,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 +952,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_ai-0.2.65.dist-info → camel_ai-0.2.66.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.65
+Version: 0.2.66
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel

{camel_ai-0.2.65.dist-info → camel_ai-0.2.66.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=5D8srkjQBq137gwwiGoNbI_-hTnhdx0GQMP7AmuGfK0,899
+camel/__init__.py,sha256=ieSIdwh_pdP_S24iZL6locMLIdis19n6Xl6rhY33ZVg,899
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=rZVeOVYuQ9RYJ5Tqyv0usqy0g4zaVEq4qSfZ9nd2640,5755
@@ -12,7 +12,7 @@ camel/agents/critic_agent.py,sha256=L6cTbYjyZB0DCa51tQ6LZLA6my8kHLC4nktHySH78H4,
 camel/agents/deductive_reasoner_agent.py,sha256=6BZGaq1hR6hKJuQtOfoYQnk_AkZpw_Mr7mUy2MspQgs,13540
 camel/agents/embodied_agent.py,sha256=XBxBu5ZMmSJ4B2U3Z7SMwvLlgp6yNpaBe8HNQmY9CZA,7536
 camel/agents/knowledge_graph_agent.py,sha256=7Tchhyvm1s8tQ3at7iGKZt70xWZllRXu2vwUFR37p10,9681
-camel/agents/mcp_agent.py,sha256=0e1NbHxKGx2asXKDOOuUGGGVZ1DAPxhZMDu8pP6bm_s,16591
+camel/agents/mcp_agent.py,sha256=ZMkOBQnjx9q4smJtrpZyMz5L-rX7yZOZl0ctnu2zQbQ,16455
 camel/agents/multi_hop_generator_agent.py,sha256=aYsZNsEFHxIq8_wDN8lZRkvRbfhlOYGBKezWr87y8Bs,4325
 camel/agents/programmed_agent_instruction.py,sha256=99fLe41che3X6wPpNPJXRwl4If6EoQqQVWIoT3DKE1s,7124
 camel/agents/repo_agent.py,sha256=ZzZ9zvh0vgdJv1KNY3GEaEPDdDxxXrjUZxjjHjVEWtE,22187
@@ -269,12 +269,12 @@ camel/societies/role_playing.py,sha256=1TsQbGYmN91BeQ0DGM5PpSJ9TMbn1F3maJNuv4fQ5
 camel/societies/workforce/__init__.py,sha256=bkTI-PE-MSK9AQ2V2gR6cR2WY-R7Jqy_NmXRtAoqo8o,920
 camel/societies/workforce/base.py,sha256=z2DmbTP5LL5-aCAAqglznQqCLfPmnyM5zD3w6jjtsb8,2175
 camel/societies/workforce/prompts.py,sha256=4OGp-1-XFYIZ8ZERubSsG-hwXti8fhjtwc3n5-WEgsA,7821
-camel/societies/workforce/role_playing_worker.py,sha256=Bwzcs1qN4mEQNWHDz5KHnPkRzsnNdSFGQ7HVug6T_og,7802
-camel/societies/workforce/single_agent_worker.py,sha256=Yzcp8HRXZJSyGpUdcLJe13nE4VO310AXZ5RVFv2ALT8,4758
+camel/societies/workforce/role_playing_worker.py,sha256=-o1--PZh2tUYQN9UIJdguIJ09p72ED88G8JQYV7s-TE,7802
+camel/societies/workforce/single_agent_worker.py,sha256=X23KE7flH_xBeMQm4qguqY0iBjJd8NlYMkrdxxNVjUc,4758
 camel/societies/workforce/task_channel.py,sha256=9t5hoinfGYnbRavX4kx34Jk1FOy05SnJZYbNzb5M-CQ,7140
-camel/societies/workforce/utils.py,sha256=ZGcpwGzvUnskVu3zVm9IHBPsbLjMJElJ8WHMJ0MTnpw,3983
+camel/societies/workforce/utils.py,sha256=yPbcLx8lNZStl15C4UXRBl5qsTrGA-hiIGynnGi53WQ,2384
 camel/societies/workforce/worker.py,sha256=xdUWBW8Qifhhrh4jdK5S_q4LiSEL4NxKuDZN1fgQESA,4135
-camel/societies/workforce/workforce.py,sha256=AdtkDMV66Syaht86Z3GIZmk-vfn2f2OuJg1iDIih0z8,41139
+camel/societies/workforce/workforce.py,sha256=8hvZXYe77xzhzVDqQ5BRIu-SGoDwxpKZZKdrsDF2Q1I,41539
 camel/storages/__init__.py,sha256=bFpvvAS2QyZoIr-tnwhMWsZRL411kIRq6IMUHcI7KHs,1989
 camel/storages/graph_storages/__init__.py,sha256=G29BNn651C0WTOpjCl4QnVM-4B9tcNh8DdmsCiONH8Y,948
 camel/storages/graph_storages/base.py,sha256=uSe9jWuLudfm5jtfo6E-L_kNzITwK1_Ef-6L4HWw-JM,2852
@@ -301,7 +301,7 @@ camel/storages/vectordb_storages/qdrant.py,sha256=a_cT0buSCHQ2CPZy852-mdvMDwy5zo
 camel/storages/vectordb_storages/tidb.py,sha256=w83bxgKgso43MtHqlpf2EMSpn1_Nz6ZZtY4fPw_-vgs,11192
 camel/storages/vectordb_storages/weaviate.py,sha256=wDUE4KvfmOl3DqHFU4uF0VKbHu-q9vKhZDe8FZ6QXsk,27888
 camel/tasks/__init__.py,sha256=MuHwkw5GRQc8NOCzj8tjtBrr2Xg9KrcKp-ed_-2ZGIM,906
-camel/tasks/task.py,sha256=W0c4mnqvZLLnA3RKE4Klj0vSXJMgc2NFCrqo4nCq99s,13980
+camel/tasks/task.py,sha256=DWEXf0coDKNc3k2--svb6D3v7ExAuMml4NKRTU6icYI,16054
 camel/tasks/task_prompt.py,sha256=3KZmKYKUPcTKe8EAZOZBN3G05JHRVt7oHY9ORzLVu1g,2150
 camel/terminators/__init__.py,sha256=t8uqrkUnXEOYMXQDgaBkMFJ0EXFKI0kmx4cUimli3Ls,991
 camel/terminators/base.py,sha256=xmJzERX7GdSXcxZjAHHODa0rOxRChMSRboDCNHWSscs,1511
@@ -323,7 +323,7 @@ camel/toolkits/dappier_toolkit.py,sha256=ewhXeeUj7e4DiTzuWDA-gHGhrLdyoZ4l9pbijvF
 camel/toolkits/data_commons_toolkit.py,sha256=aHZUSL1ACpnYGaf1rE2csVKTmXTmN8lMGRUBYhZ_YEk,14168
 camel/toolkits/excel_toolkit.py,sha256=DSjBXl24_LrJubGFFmB_vqliKzzWTbT1TH309YQVUO8,6653
 camel/toolkits/file_write_toolkit.py,sha256=3JF_6fFXXQUlZv3VjkXVXDOodyGHHev0GJgSyZpkEH8,16483
-camel/toolkits/function_tool.py,sha256=aMXDnPlMPJSoItED8y2lb2g2FasOXit9mkfbLm9-hEk,30367
+camel/toolkits/function_tool.py,sha256=045I_vyqvB6PorcoVaEbxYjGe-fD-FBKtO4lfpZ2eVw,33535
 camel/toolkits/github_toolkit.py,sha256=Xq4KynmvIW_2924BJBS98I9TaF0ugmN62Y74kcNv_us,13102
 camel/toolkits/google_calendar_toolkit.py,sha256=E-sdgdbtNBs_CXbhht9t1dsVr4DsTr5NguHkx4fvSmc,15410
 camel/toolkits/google_maps_toolkit.py,sha256=WTnkURpGri9KcY5OwV7AJJHOzmpu5RNmYE1QCVqvwWM,12023
@@ -334,7 +334,7 @@ camel/toolkits/jina_reranker_toolkit.py,sha256=0OWUlSqRNYYmD5EQZW7OX87lfmzLRjjDm
 camel/toolkits/klavis_toolkit.py,sha256=ZKerhgz5e-AV-iv0ftf07HgWikknIHjB3EOQswfuR80,9864
 camel/toolkits/linkedin_toolkit.py,sha256=wn4eXwYYlVA7doTna7k7WYhUqTBF83W79S-UJs_IQr0,8065
 camel/toolkits/math_toolkit.py,sha256=KdI8AJ9Dbq5cfWboAYJUYgSkmADMCO5eZ6yqYkWuiIQ,3686
-camel/toolkits/mcp_toolkit.py,sha256=I7M25kutT-Y6pAvoSrmhLpscTrR2pZIjxT6MCqU-CEg,23733
+camel/toolkits/mcp_toolkit.py,sha256=czGYgZ-Vd9NdAcPe_hoA7ZYxSV2QKhsxuJNZNg3Rof4,25459
 camel/toolkits/memory_toolkit.py,sha256=TeKYd5UMwgjVpuS2orb-ocFL13eUNKujvrFOruDCpm8,4436
 camel/toolkits/meshy_toolkit.py,sha256=NbgdOBD3FYLtZf-AfonIv6-Q8-8DW129jsaP1PqI2rs,7126
 camel/toolkits/mineru_toolkit.py,sha256=vRX9LholLNkpbJ6axfEN4pTG85aWb0PDmlVy3rAAXhg,6868
@@ -407,7 +407,7 @@ camel/utils/deduplication.py,sha256=UHikAtOW1TTDunf2t_wa2kFbmkrXWf7HfOKwLvwCxzo,
 camel/utils/filename.py,sha256=HYNc1wbSCgNR1CN21cwHxdAhpnsf5ySJ6jUDfeqOK20,2532
 camel/utils/langfuse.py,sha256=OowR6A790XG-b0UHiTYduYvS18PvSGFdmqki2Poogo0,8578
 camel/utils/mcp.py,sha256=iuthL8VuUXIRU34Nvx8guq7frfglpZoxewUKuAg3e1s,5077
-camel/utils/mcp_client.py,sha256=JXWRKcp7bO7A_fYjEV62G-oOy1etrbiRICt2SXVYcJo,37103
+camel/utils/mcp_client.py,sha256=1581sSQKNFxZFq-MvLXRq8jU1HIo3-X3xTfz6hJkKtE,36066
 camel/utils/response_format.py,sha256=xZcx6xBxeg3A0e7R0JCMJdNm2oQ1-diqVLs0JsiCkZU,5319
 camel/utils/token_counting.py,sha256=apkERzNoVc4sgvJvWVosvepX3KH8pVypVjrL4AA7RB4,17521
 camel/utils/chunker/__init__.py,sha256=6iN6HL6sblIjDuJTILk-9qKcHBZ97t8b6tZCWPZ0OYI,899
@@ -420,7 +420,7 @@ camel/verifiers/math_verifier.py,sha256=tA1D4S0sm8nsWISevxSN0hvSVtIUpqmJhzqfbuMo
 camel/verifiers/models.py,sha256=GdxYPr7UxNrR1577yW4kyroRcLGfd-H1GXgv8potDWU,2471
 camel/verifiers/physics_verifier.py,sha256=c1grrRddcrVN7szkxhv2QirwY9viIRSITWeWFF5HmLs,30187
 camel/verifiers/python_verifier.py,sha256=ogTz77wODfEcDN4tMVtiSkRQyoiZbHPY2fKybn59lHw,20558
-camel_ai-0.2.65.dist-info/METADATA,sha256=tB8PH0WUEibP9l_oa9B9s0g09RC_YtnGaIZWVRr-qko,44783
-camel_ai-0.2.65.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.65.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.65.dist-info/RECORD,,
+camel_ai-0.2.66.dist-info/METADATA,sha256=yUOJzkC_rZSyxTCZ31wVoWTDOTZGS4S-uBBUbq8Pilg,44783
+camel_ai-0.2.66.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.66.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.66.dist-info/RECORD,,