camel-ai 0.2.73a5__py3-none-any.whl → 0.2.73a8__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.73a5'
+__version__ = '0.2.73a8'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -2798,12 +2798,7 @@ class ChatAgent(BaseAgent):
             )
             thread = threading.Thread(
                 target=tool_worker,
-                args=(
-                    self._internal_tools[function_name],
-                    args,
-                    result_queue,
-                    tool_call_data,
-                ),
+                args=(result_queue, tool_call_data),
             )
             thread.start()
 

camel/societies/__init__.py

@@ -13,8 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from .babyagi_playing import BabyAGI
 from .role_playing import RolePlaying
+from .workforce import Workforce
 
 __all__ = [
     'RolePlaying',
     'BabyAGI',
+    'Workforce',
 ]

camel/toolkits/mcp_toolkit.py

@@ -14,6 +14,7 @@
 
 import json
 import os
+import warnings
 from contextlib import AsyncExitStack
 from typing import Any, Dict, List, Optional
 
@@ -24,6 +25,11 @@ from camel.utils.mcp_client import MCPClient, create_mcp_client
 
 logger = get_logger(__name__)
 
+# Suppress parameter description warnings for MCP tools
+warnings.filterwarnings(
+    "ignore", message="Parameter description is missing", category=UserWarning
+)
+
 
 class MCPConnectionError(Exception):
     r"""Raised when MCP connection fails."""
@@ -446,7 +452,7 @@ class MCPToolkit(BaseToolkit):
 
     def _ensure_strict_tool_schema(self, tool: FunctionTool) -> FunctionTool:
         r"""Ensure a tool has a strict schema compatible with OpenAI's
-        requirements.
+        requirements according to the structured outputs specification.
 
         Args:
             tool (FunctionTool): The tool to check and update if necessary.
@@ -457,60 +463,333 @@ class MCPToolkit(BaseToolkit):
         try:
             schema = tool.get_openai_tool_schema()
 
-            # Check if any object in the schema has additionalProperties: true
-            def _has_additional_properties_true(obj):
-                r"""Recursively check if any object has additionalProperties: true"""  # noqa: E501
+            # Helper functions for validation and transformation
+            def _validate_and_fix_schema(obj, path="", in_root=True):
+                r"""Recursively validate and fix schema to meet strict
+                requirements.
+                """
                 if isinstance(obj, dict):
-                    if obj.get("additionalProperties") is True:
-                        return True
-                    for value in obj.values():
-                        if _has_additional_properties_true(value):
-                            return True
+                    # Check if this is the root object
+                    if in_root and path == "":
+                        # Root must be an object, not anyOf
+                        if "anyOf" in obj and "type" not in obj:
+                            raise ValueError(
+                                "Root object must not be anyOf and must "
+                                "be an object"
+                            )
+                        if obj.get("type") and obj["type"] != "object":
+                            raise ValueError(
+                                "Root object must have type 'object'"
+                            )
+
+                    # Handle object types
+                    if obj.get("type") == "object":
+                        # Ensure additionalProperties is false
+                        obj["additionalProperties"] = False
+
+                        # Process properties
+                        if "properties" in obj:
+                            props = obj["properties"]
+                            # Only set required if it doesn't exist or needs
+                            # updating
+                            if "required" not in obj:
+                                # If no required field exists, make all fields
+                                # required
+                                obj["required"] = list(props.keys())
+                            else:
+                                # Ensure required field only contains valid
+                                # property names
+                                existing_required = obj.get("required", [])
+                                valid_required = [
+                                    req
+                                    for req in existing_required
+                                    if req in props
+                                ]
+                                # Add any missing properties to required
+                                for prop_name in props:
+                                    if prop_name not in valid_required:
+                                        valid_required.append(prop_name)
+                                obj["required"] = valid_required
+
+                            # Recursively process each property
+                            for prop_name, prop_schema in props.items():
+                                _validate_and_fix_schema(
+                                    prop_schema, f"{path}.{prop_name}", False
+                                )
+
+                    # Handle arrays
+                    elif obj.get("type") == "array":
+                        if "items" in obj:
+                            _validate_and_fix_schema(
+                                obj["items"], f"{path}.items", False
+                            )
+
+                    # Handle anyOf
+                    elif "anyOf" in obj:
+                        # Validate anyOf schemas
+                        for i, schema in enumerate(obj["anyOf"]):
+                            _validate_and_fix_schema(
+                                schema, f"{path}.anyOf[{i}]", False
+                            )
+
+                    # Handle string format validation
+                    elif obj.get("type") == "string":
+                        if "format" in obj:
+                            allowed_formats = [
+                                "date-time",
+                                "time",
+                                "date",
+                                "duration",
+                                "email",
+                                "hostname",
+                                "ipv4",
+                                "ipv6",
+                                "uuid",
+                            ]
+                            if obj["format"] not in allowed_formats:
+                                del obj["format"]  # Remove unsupported format
+
+                    # Handle number/integer validation
+                    elif obj.get("type") in ["number", "integer"]:
+                        # These properties are supported
+                        supported_props = [
+                            "multipleOf",
+                            "maximum",
+                            "exclusiveMaximum",
+                            "minimum",
+                            "exclusiveMinimum",
+                        ]
+                        # Remove any unsupported properties
+                        for key in list(obj.keys()):
+                            if key not in [
+                                *supported_props,
+                                "type",
+                                "description",
+                                "default",
+                            ]:
+                                del obj[key]
+
+                    # Process nested structures
+                    for key in ["allOf", "oneOf", "$defs", "definitions"]:
+                        if key in obj:
+                            if isinstance(obj[key], list):
+                                for i, item in enumerate(obj[key]):
+                                    _validate_and_fix_schema(
+                                        item, f"{path}.{key}[{i}]", False
+                                    )
+                            elif isinstance(obj[key], dict):
+                                for def_name, def_schema in obj[key].items():
+                                    _validate_and_fix_schema(
+                                        def_schema,
+                                        f"{path}.{key}.{def_name}",
+                                        False,
+                                    )
+
                 elif isinstance(obj, list):
-                    for item in obj:
-                        if _has_additional_properties_true(item):
-                            return True
-                return False
-
-            # FIRST: Check if the schema contains additionalProperties: true
-            # This must be checked before strict mode validation
-            if _has_additional_properties_true(schema):
-                # Force strict mode to False and log warning
-                if "function" in schema:
-                    schema["function"]["strict"] = False
-                tool.set_openai_tool_schema(schema)
-                logger.warning(
-                    f"Tool '{tool.get_function_name()}' contains "
-                    f"additionalProperties: true which is incompatible with "
-                    f"OpenAI strict mode. Setting strict=False for this tool."
-                )
-                return tool
+                    for i, item in enumerate(obj):
+                        _validate_and_fix_schema(item, f"{path}[{i}]", False)
+
+            def _check_schema_limits(obj, counts=None):
+                r"""Check if schema exceeds OpenAI limits."""
+                if counts is None:
+                    counts = {
+                        "properties": 0,
+                        "depth": 0,
+                        "enums": 0,
+                        "string_length": 0,
+                    }
+
+                def _count_properties(o, depth=0):
+                    if isinstance(o, dict):
+                        if depth > 5:
+                            raise ValueError(
+                                "Schema exceeds maximum nesting depth of 5"
+                            )
+
+                        if o.get("type") == "object" and "properties" in o:
+                            counts["properties"] += len(o["properties"])
+                            for prop in o["properties"].values():
+                                _count_properties(prop, depth + 1)
+
+                        if "enum" in o:
+                            counts["enums"] += len(o["enum"])
+                            if isinstance(o["enum"], list):
+                                for val in o["enum"]:
+                                    if isinstance(val, str):
+                                        counts["string_length"] += len(val)
+
+                        # Count property names
+                        if "properties" in o:
+                            for name in o["properties"].keys():
+                                counts["string_length"] += len(name)
+
+                        # Process nested structures
+                        for key in ["items", "allOf", "oneOf", "anyOf"]:
+                            if key in o:
+                                if isinstance(o[key], dict):
+                                    _count_properties(o[key], depth)
+                                elif isinstance(o[key], list):
+                                    for item in o[key]:
+                                        _count_properties(item, depth)
+
+                _count_properties(obj)
+
+                # Check limits, reference: https://platform.openai.com/docs/guides/structured-outputs?api-mode=responses#objects-have-limitations-on-nesting-depth-and-size # noqa: E501
+                if counts["properties"] > 5000:
+                    raise ValueError(
+                        "Schema exceeds maximum of 5000 properties"
+                    )
+                if counts["enums"] > 1000:
+                    raise ValueError(
+                        "Schema exceeds maximum of 1000 enum values"
+                    )
+                if counts["string_length"] > 120000:
+                    raise ValueError(
+                        "Schema exceeds maximum total string length of 120000"
+                    )
 
-            # SECOND: Check if the tool already has strict mode enabled
-            # Only do this if there are no additionalProperties conflicts
+                return True
+
+            # Check if schema has any issues that prevent strict mode
+            def _has_strict_mode_issues(obj):
+                r"""Check for any issues that would prevent strict mode."""
+                issues = []
+
+                def _check_issues(o, path=""):
+                    if isinstance(o, dict):
+                        # Check for additionalProperties: true
+                        if o.get("additionalProperties") is True:
+                            issues.append(
+                                f"additionalProperties: true at {path}"
+                            )
+
+                        # Check for unsupported keywords
+                        unsupported = [
+                            "not",
+                            "dependentRequired",
+                            "dependentSchemas",
+                            "if",
+                            "then",
+                            "else",
+                            "patternProperties",
+                        ]
+                        for keyword in unsupported:
+                            if keyword in o:
+                                issues.append(
+                                    f"Unsupported keyword '{keyword}' "
+                                    f"at {path}"
+                                )
+
+                        # Recursively check
+                        for key, value in o.items():
+                            if isinstance(value, (dict, list)):
+                                _check_issues(value, f"{path}.{key}")
+
+                    elif isinstance(o, list):
+                        for i, item in enumerate(o):
+                            _check_issues(item, f"{path}[{i}]")
+
+                _check_issues(obj)
+                return issues
+
+            # Check if already strict and compliant
             if schema.get("function", {}).get("strict") is True:
-                return tool
-
-            # Update the schema to be strict
+                # Validate it's actually compliant
+                try:
+                    params = schema["function"].get("parameters", {})
+                    if params:
+                        _validate_and_fix_schema(params)
+                        _check_schema_limits(params)
+                    return tool
+                except Exception:
+                    # Not actually compliant, continue to fix it
+                    pass
+
+            # Apply sanitization first to handle optional fields properly
             if "function" in schema:
+                # Apply the sanitization function first
+                from camel.toolkits.function_tool import (
+                    sanitize_and_enforce_required,
+                )
+
+                schema = sanitize_and_enforce_required(schema)
+
+                # Special handling for schemas with additionalProperties that
+                # aren't false These can't use strict mode
+                def _has_open_props(obj, path=""):
+                    """Check if any object has additionalProperties that
+                    isn't false."""
+                    if isinstance(obj, dict):
+                        if (
+                            obj.get("type") == "object"
+                            and "additionalProperties" in obj
+                        ):
+                            if obj["additionalProperties"] is not False:
+                                return True
+
+                        # Recurse through the schema
+                        for key, value in obj.items():
+                            if key in [
+                                "properties",
+                                "items",
+                                "allOf",
+                                "oneOf",
+                                "anyOf",
+                            ]:
+                                if isinstance(value, dict):
+                                    if _has_open_props(value, f"{path}.{key}"):
+                                        return True
+                                elif isinstance(value, list):
+                                    for i, item in enumerate(value):
+                                        if _has_open_props(
+                                            item,
+                                            f"{path}.{key}[{i}]",
+                                        ):
+                                            return True
+                            elif isinstance(value, dict) and key not in [
+                                "description",
+                                "type",
+                                "enum",
+                            ]:
+                                if _has_open_props(value, f"{path}.{key}"):
+                                    return True
+                    return False
+
+                # Check if schema has dynamic additionalProperties
+                if _has_open_props(schema["function"].get("parameters", {})):
+                    # Can't use strict mode with dynamic additionalProperties
+                    schema["function"]["strict"] = False
+                    tool.set_openai_tool_schema(schema)
+                    logger.warning(
+                        f"Tool '{tool.get_function_name()}' has "
+                        f"dynamic additionalProperties and cannot use "
+                        f"strict mode"
+                    )
+                    return tool
+
+                # Now check for blocking issues after sanitization
+                issues = _has_strict_mode_issues(schema)
+                if issues:
+                    # Can't use strict mode
+                    schema["function"]["strict"] = False
+                    tool.set_openai_tool_schema(schema)
+                    logger.warning(
+                        f"Tool '{tool.get_function_name()}' has "
+                        f"issues preventing strict mode: "
+                        f"{'; '.join(issues[:3])}{'...' if len(issues) > 3 else ''}"  # noqa: E501
+                    )
+                    return tool
+
+                # Enable strict mode
                 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,
-                    )
+                    # Validate and fix the parameters schema
+                    _validate_and_fix_schema(parameters)
 
-                    schema = sanitize_and_enforce_required(schema)
+                    # Check schema limits
+                    _check_schema_limits(parameters)
 
             tool.set_openai_tool_schema(schema)
             logger.debug(
@@ -518,7 +797,23 @@ class MCPToolkit(BaseToolkit):
             )
 
         except Exception as e:
-            logger.warning(f"Failed to ensure strict schema for tool: {e}")
+            # If we can't make it strict, disable strict mode
+            try:
+                if "function" in schema:
+                    schema["function"]["strict"] = False
+                tool.set_openai_tool_schema(schema)
+                logger.warning(
+                    f"Failed to ensure strict schema for "
+                    f"tool '{tool.get_function_name()}': {str(e)[:100]}. "
+                    f"Setting strict=False."
+                )
+            except Exception as inner_e:
+                # If even setting strict=False fails, log the error
+                logger.error(
+                    f"Critical error processing "
+                    f"tool '{tool.get_function_name()}': {inner_e}. "
+                    f"Tool may not function correctly."
+                )
 
         return tool
 

camel/toolkits/terminal_toolkit.py

@@ -98,6 +98,7 @@ class TerminalToolkit(BaseToolkit):
         self.is_macos = platform.system() == 'Darwin'
         self.initial_env_path: Optional[str] = None
         self.initial_env_prepared = False
+        self.uv_path: Optional[str] = None
 
         atexit.register(self.__del__)
 
@@ -200,37 +201,111 @@ class TerminalToolkit(BaseToolkit):
                 f"Creating new Python environment at: {self.cloned_env_path}\n"
             )
 
-            # Create virtual environment with pip
-            venv.create(self.cloned_env_path, with_pip=True)
+            # Try to use uv if available
+            if self._ensure_uv_available():
+                # Use uv to create environment with current Python version
+                uv_command = self.uv_path if self.uv_path else "uv"
 
-            # Ensure pip is properly available by upgrading it
-            if self.os_type == 'Windows':
-                python_path = os.path.join(
-                    self.cloned_env_path, "Scripts", "python.exe"
+                # Get current Python version
+                current_version = (
+                    f"{sys.version_info.major}.{sys.version_info.minor}"
                 )
-            else:
-                python_path = os.path.join(
-                    self.cloned_env_path, "bin", "python"
+
+                subprocess.run(
+                    [
+                        uv_command,
+                        "venv",
+                        "--python",
+                        current_version,
+                        self.cloned_env_path,
+                    ],
+                    check=True,
+                    capture_output=True,
+                    cwd=self.working_dir,
+                    timeout=300,
                 )
 
-            # Verify python executable exists
-            if os.path.exists(python_path):
-                # Use python -m pip to ensure pip is available
+                # Get the python path from the new environment
+                if self.os_type == 'Windows':
+                    python_path = os.path.join(
+                        self.cloned_env_path, "Scripts", "python.exe"
+                    )
+                else:
+                    python_path = os.path.join(
+                        self.cloned_env_path, "bin", "python"
+                    )
+
+                # Install pip and setuptools using uv
                 subprocess.run(
-                    [python_path, "-m", "pip", "install", "--upgrade", "pip"],
+                    [
+                        uv_command,
+                        "pip",
+                        "install",
+                        "--python",
+                        python_path,
+                        "pip",
+                        "setuptools",
+                        "wheel",
+                    ],
                     check=True,
                     capture_output=True,
                     cwd=self.working_dir,
-                    timeout=60,
+                    timeout=300,
                 )
+
                 self._update_terminal_output(
-                    "New Python environment created successfully with pip!\n"
+                    "[UV] Cloned Python environment created successfully!\n"
                 )
+
             else:
+                # Fallback to standard venv
                 self._update_terminal_output(
-                    f"Warning: Python executable not found at {python_path}\n"
+                    "Falling back to standard venv for cloning environment\n"
                 )
 
+                # Create virtual environment with pip. On macOS, use
+                # symlinks=False to avoid dyld library loading issues
+                venv.create(
+                    self.cloned_env_path, with_pip=True, symlinks=False
+                )
+
+                # Ensure pip is properly available by upgrading it
+                if self.os_type == 'Windows':
+                    python_path = os.path.join(
+                        self.cloned_env_path, "Scripts", "python.exe"
+                    )
+                else:
+                    python_path = os.path.join(
+                        self.cloned_env_path, "bin", "python"
+                    )
+
+                # Verify python executable exists
+                if os.path.exists(python_path):
+                    # Use python -m pip to ensure pip is available
+                    subprocess.run(
+                        [
+                            python_path,
+                            "-m",
+                            "pip",
+                            "install",
+                            "--upgrade",
+                            "pip",
+                        ],
+                        check=True,
+                        capture_output=True,
+                        cwd=self.working_dir,
+                        timeout=60,
+                    )
+                    self._update_terminal_output(
+                        "New Python environment created successfully "
+                        "with pip!\n"
+                    )
+                else:
+                    self._update_terminal_output(
+                        f"Warning: Python executable not found "
+                        f"at {python_path}\n"
+                    )
+
         except subprocess.CalledProcessError as e:
             error_msg = e.stderr.decode() if e.stderr else str(e)
             self._update_terminal_output(
@@ -255,6 +330,97 @@ class TerminalToolkit(BaseToolkit):
             or shutil.which("uv") is not None
         )
 
+    def _ensure_uv_available(self) -> bool:
+        r"""Ensure uv is available, installing it if necessary.
+
+        Returns:
+            bool: True if uv is available (either already installed or
+                successfully installed), False otherwise.
+        """
+        # Check if uv is already available
+        existing_uv = shutil.which("uv")
+        if existing_uv is not None:
+            self.uv_path = existing_uv
+            self._update_terminal_output(
+                f"uv is already available at: {self.uv_path}\n"
+            )
+            return True
+
+        try:
+            self._update_terminal_output("uv not found, installing...\n")
+
+            # Install uv using the official installer script
+            if self.os_type in ['Darwin', 'Linux']:
+                # Use curl to download and execute the installer
+                install_cmd = "curl -LsSf https://astral.sh/uv/install.sh | sh"
+                result = subprocess.run(
+                    install_cmd,
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+
+                if result.returncode != 0:
+                    self._update_terminal_output(
+                        f"Failed to install uv: {result.stderr}\n"
+                    )
+                    return False
+
+                # Check if uv was installed in the expected location
+                home = os.path.expanduser("~")
+                uv_bin_path = os.path.join(home, ".cargo", "bin")
+                uv_executable = os.path.join(uv_bin_path, "uv")
+
+                if os.path.exists(uv_executable):
+                    # Store the full path to uv instead of modifying PATH
+                    self.uv_path = uv_executable
+                    self._update_terminal_output(
+                        f"uv installed successfully at: {self.uv_path}\n"
+                    )
+                    return True
+
+            elif self.os_type == 'Windows':
+                # Use PowerShell to install uv on Windows
+                install_cmd = (
+                    "powershell -ExecutionPolicy Bypass -c "
+                    "\"irm https://astral.sh/uv/install.ps1 | iex\""
+                )
+                result = subprocess.run(
+                    install_cmd,
+                    shell=True,
+                    capture_output=True,
+                    text=True,
+                    timeout=60,
+                )
+
+                if result.returncode != 0:
+                    self._update_terminal_output(
+                        f"Failed to install uv: {result.stderr}\n"
+                    )
+                    return False
+
+                # Check if uv was installed in the expected location on Windows
+                home = os.path.expanduser("~")
+                uv_bin_path = os.path.join(home, ".cargo", "bin")
+                uv_executable = os.path.join(uv_bin_path, "uv.exe")
+
+                if os.path.exists(uv_executable):
+                    # Store the full path to uv instead of modifying PATH
+                    self.uv_path = uv_executable
+                    self._update_terminal_output(
+                        f"uv installed successfully at: {self.uv_path}\n"
+                    )
+                    return True
+
+            self._update_terminal_output("Failed to verify uv installation\n")
+            return False
+
+        except Exception as e:
+            self._update_terminal_output(f"Error installing uv: {e!s}\n")
+            logger.error(f"Failed to install uv: {e}")
+            return False
+
     def _prepare_initial_environment(self):
         r"""Prepare initial environment with Python 3.10, pip, and other
         essential tools.
@@ -279,10 +445,14 @@ class TerminalToolkit(BaseToolkit):
             # Create the initial environment directory
             os.makedirs(self.initial_env_path, exist_ok=True)
 
-            # Check if we should use uv
-            if self._is_uv_environment():
+            # Try to ensure uv is available and use it preferentially
+            if self._ensure_uv_available():
                 self._setup_initial_env_with_uv()
             else:
+                # Fallback to venv if uv installation failed
+                self._update_terminal_output(
+                    "Falling back to standard venv for environment setup\n"
+                )
                 self._setup_initial_env_with_venv()
 
             self.initial_env_prepared = True
@@ -302,9 +472,18 @@ class TerminalToolkit(BaseToolkit):
             raise Exception("Initial environment path not set")
 
         try:
+            # Use the stored uv path if available, otherwise fall back to "uv"
+            uv_command = self.uv_path if self.uv_path else "uv"
+
             # Create virtual environment with Python 3.10 using uv
             subprocess.run(
-                ["uv", "venv", "--python", "3.10", self.initial_env_path],
+                [
+                    uv_command,
+                    "venv",
+                    "--python",
+                    "3.10",
+                    self.initial_env_path,
+                ],
                 check=True,
                 capture_output=True,
                 cwd=self.working_dir,
@@ -332,7 +511,7 @@ class TerminalToolkit(BaseToolkit):
             ]
             subprocess.run(
                 [
-                    "uv",
+                    uv_command,
                     "pip",
                     "install",
                     "--python",
@@ -366,10 +545,12 @@ class TerminalToolkit(BaseToolkit):
 
         try:
             # Create virtual environment with system Python
+            # On macOS, use symlinks=False to avoid dyld library loading issues
             venv.create(
                 self.initial_env_path,
                 with_pip=True,
                 system_site_packages=False,
+                symlinks=False,
             )
 
             # Get pip path

{camel_ai-0.2.73a5.dist-info → camel_ai-0.2.73a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a5
+Version: 0.2.73a8
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -82,7 +82,7 @@ Requires-Dist: networkx<4,>=3.4.2; extra == 'all'
 Requires-Dist: newspaper3k<0.3,>=0.2.8; extra == 'all'
 Requires-Dist: notion-client<3,>=2.2.1; extra == 'all'
 Requires-Dist: numpy<=2.2,>=1.2; extra == 'all'
-Requires-Dist: onnxruntime<=1.20.1; extra == 'all'
+Requires-Dist: onnxruntime<=1.19.2; extra == 'all'
 Requires-Dist: openapi-spec-validator<0.8,>=0.7.1; extra == 'all'
 Requires-Dist: openpyxl>=3.1.5; extra == 'all'
 Requires-Dist: pandas<2,>=1.5.3; extra == 'all'
@@ -213,7 +213,7 @@ Requires-Dist: docx2txt<0.9,>=0.8; extra == 'document-tools'
 Requires-Dist: docx>=0.2.4; extra == 'document-tools'
 Requires-Dist: markitdown>=0.1.1; extra == 'document-tools'
 Requires-Dist: numpy<=2.2,>=1.2; extra == 'document-tools'
-Requires-Dist: onnxruntime<=1.20.1; extra == 'document-tools'
+Requires-Dist: onnxruntime<=1.19.2; extra == 'document-tools'
 Requires-Dist: openapi-spec-validator<0.8,>=0.7.1; extra == 'document-tools'
 Requires-Dist: openpyxl>=3.1.5; extra == 'document-tools'
 Requires-Dist: pandasai<3,>=2.3.0; extra == 'document-tools'
@@ -268,7 +268,7 @@ Requires-Dist: mcp-server-fetch==2025.1.17; extra == 'owl'
 Requires-Dist: mcp-simple-arxiv==0.2.2; extra == 'owl'
 Requires-Dist: newspaper3k<0.3,>=0.2.8; extra == 'owl'
 Requires-Dist: numpy<=2.2,>=1.2; extra == 'owl'
-Requires-Dist: onnxruntime<=1.20.1; extra == 'owl'
+Requires-Dist: onnxruntime<=1.19.2; extra == 'owl'
 Requires-Dist: openapi-spec-validator<0.8,>=0.7.1; extra == 'owl'
 Requires-Dist: openpyxl>=3.1.5; extra == 'owl'
 Requires-Dist: pandas<2,>=1.5.3; extra == 'owl'

{camel_ai-0.2.73a5.dist-info → camel_ai-0.2.73a8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=aFmveVoFaOw6DGWNZdbKk_pogoM5SZU6IaKMYluT5zI,901
+camel/__init__.py,sha256=_AfDG2a7ery9GuUo4kqCeCo3IdXz3d2V-0ziFUoXkgc,901
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=WgEwael_eT6D-lVAKHpKIpwXSTjvLbny5jbV1Ab8lnA,5760
@@ -7,7 +7,7 @@ camel/agents/__init__.py,sha256=64weKqdvmpZcGWyVkO-OKASAmVUdrQjv60JApgPk_SA,1644
 camel/agents/_types.py,sha256=MeFZzay2kJA6evALQ-MbBTKW-0lu_0wBuKsxzH_4gWI,1552
 camel/agents/_utils.py,sha256=AR7Qqgbkmn4X2edYUQf1rdksGUyV5hm3iK1z-Dn0Mcg,6266
 camel/agents/base.py,sha256=c4bJYL3G3Z41SaFdMPMn8ZjLdFiFaVOFO6EQIfuCVR8,1124
-camel/agents/chat_agent.py,sha256=4Hn27mtUvUQmwMIFTDTUcTsXWIjyeISvz1FCOdm5HSM,151957
+camel/agents/chat_agent.py,sha256=fxZ8dBVhLwA-ZsBJbOvTxvQc4zHCKi4D3qwLz2URiW0,151815
 camel/agents/critic_agent.py,sha256=L6cTbYjyZB0DCa51tQ6LZLA6my8kHLC4nktHySH78H4,10433
 camel/agents/deductive_reasoner_agent.py,sha256=6BZGaq1hR6hKJuQtOfoYQnk_AkZpw_Mr7mUy2MspQgs,13540
 camel/agents/embodied_agent.py,sha256=XBxBu5ZMmSJ4B2U3Z7SMwvLlgp6yNpaBe8HNQmY9CZA,7536
@@ -268,7 +268,7 @@ camel/schemas/base.py,sha256=x0H0oIwbQR6UGdEvR5v-srI25MJ8uTrEw8nnygvLwjw,1604
 camel/schemas/openai_converter.py,sha256=SEnYsYcboZgVmjcC1YP5xke3c0MYPESPRmYQWsDGZ4Y,4362
 camel/schemas/outlines_converter.py,sha256=OYKPR1fNyrYs9eh5RiXEAccMbnRc9WTwSVJYbh9HkKE,8738
 camel/services/agent_openapi_server.py,sha256=NUCBLNZBvi4C-J1ESMyRHiRX1NDhPdPkXTMJTl0oUQo,14698
-camel/societies/__init__.py,sha256=NOHjtlsY-gV9UCF2xXgcbG-xXyuigmbwbpLpNsDgEJ4,826
+camel/societies/__init__.py,sha256=8J_PBAGkFdL0692Mxx8dvcSRm57ibouXdIU_f1n9dJE,876
 camel/societies/babyagi_playing.py,sha256=KbTdpHfZ2V8AripVck0bNTOyF-RSaMPCRARz3DvzWfQ,11855
 camel/societies/role_playing.py,sha256=0XScr3WfxX1QOC71RhBLmrcS5y2c7DMQB_mAFOHU34M,31421
 camel/societies/workforce/__init__.py,sha256=bkTI-PE-MSK9AQ2V2gR6cR2WY-R7Jqy_NmXRtAoqo8o,920
@@ -347,7 +347,7 @@ camel/toolkits/klavis_toolkit.py,sha256=ZKerhgz5e-AV-iv0ftf07HgWikknIHjB3EOQswfu
 camel/toolkits/linkedin_toolkit.py,sha256=wn4eXwYYlVA7doTna7k7WYhUqTBF83W79S-UJs_IQr0,8065
 camel/toolkits/markitdown_toolkit.py,sha256=Cwga4sOTT1HO51CjmXubD6ieRMhumtqEN6jlsgL1nq0,2867
 camel/toolkits/math_toolkit.py,sha256=KdI8AJ9Dbq5cfWboAYJUYgSkmADMCO5eZ6yqYkWuiIQ,3686
-camel/toolkits/mcp_toolkit.py,sha256=da7QLwGKIKnKvMx5mOOiC56w0hKV1bvD1Z9PgrSHOtA,26999
+camel/toolkits/mcp_toolkit.py,sha256=orWwKwCCL7jiPPkuoydGcM97iDRZG3udabY1VyoyPNo,40542
 camel/toolkits/memory_toolkit.py,sha256=TeKYd5UMwgjVpuS2orb-ocFL13eUNKujvrFOruDCpm8,4436
 camel/toolkits/meshy_toolkit.py,sha256=NbgdOBD3FYLtZf-AfonIv6-Q8-8DW129jsaP1PqI2rs,7126
 camel/toolkits/message_agent_toolkit.py,sha256=yWvAaxoxAvDEtD7NH7IkkHIyfWIYK47WZhn5E_RaxKo,22661
@@ -378,7 +378,7 @@ camel/toolkits/slack_toolkit.py,sha256=ZnK_fRdrQiaAUpjkgHSv1iXdv1HKEgXMlKevu3Qiv
 camel/toolkits/stripe_toolkit.py,sha256=07swo5znGTnorafC1uYLKB4NRcJIOPOx19J7tkpLYWk,10102
 camel/toolkits/sympy_toolkit.py,sha256=BAQnI8EFJydNUpKQWXBdleQ1Cm-srDBhFlqp9V9pbPQ,33757
 camel/toolkits/task_planning_toolkit.py,sha256=Ttw9fHae4omGC1SA-6uaeXVHJ1YkwiVloz_hO-fm1gw,4855
-camel/toolkits/terminal_toolkit.py,sha256=jRprx7Qlf-_ZgXhuFXObydwNaNLG7vqDSYNA5BTw-l4,61274
+camel/toolkits/terminal_toolkit.py,sha256=7LdcG0hqZaPiaJPagXVXi87Ncm-MJIIbFUTZRtrIXes,68194
 camel/toolkits/thinking_toolkit.py,sha256=nZYLvKWIx2BM1DYu69I9B5EISAG7aYcLYXKv9663BVk,8000
 camel/toolkits/twitter_toolkit.py,sha256=Px4N8aUxUzy01LhGSWkdrC2JgwKkrY3cvxgMeJ2XYfU,15939
 camel/toolkits/video_analysis_toolkit.py,sha256=h6D7b1MAAzaHn222n_YKtwG-EGEGgMt7mBrNNVipYZc,23361
@@ -467,7 +467,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.73a5.dist-info/METADATA,sha256=SFYBkrqd_Jay-l2fzFFboHoDY69dVk_hjxED3ODbfE8,50434
-camel_ai-0.2.73a5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.73a5.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.73a5.dist-info/RECORD,,
+camel_ai-0.2.73a8.dist-info/METADATA,sha256=JMMFteW3ZHW4JreEL0nbvm9ll-rUoSab_ILr3csAPkE,50434
+camel_ai-0.2.73a8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.73a8.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.73a8.dist-info/RECORD,,