camel-ai 0.2.65__tar.gz → 0.2.66__tar.gz

{camel_ai-0.2.65 → camel_ai-0.2.66}/PKG-INFO

@@ -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 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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_ai-0.2.65 → camel_ai-0.2.66}/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 → camel_ai-0.2.66}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "camel-ai"
-version = "0.2.65"
+version = "0.2.66"
 description = "Communicative Agents for AI Society Study"
 authors = [{ name = "CAMEL-AI.org" }]
 requires-python = ">=3.10,<3.13"