camel-ai 0.2.73a6__py3-none-any.whl → 0.2.73a9__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.73a6'
+__version__ = '0.2.73a9'
 
 __all__ = [
     '__version__',

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/storages/key_value_storages/mem0_cloud.py

@@ -103,34 +103,6 @@ class Mem0Storage(BaseKeyValueStorage):
         }
         return {k: v for k, v in options.items() if v is not None}
 
-    def _prepare_filters(
-        self,
-        agent_id: Optional[str] = None,
-        user_id: Optional[str] = None,
-        filters: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        r"""Helper method to prepare filters for Mem0 API calls.
-
-        Args:
-            agent_id (Optional[str], optional): Agent ID to filter by
-                (default: :obj:`None`).
-            user_id (Optional[str], optional): User ID to filter by (default:
-                :obj:`None`).
-            filters (Optional[Dict[str, Any]], optional): Additional filters
-                (default: :obj:`None`).
-
-        Returns:
-            Dict[str, Any]: Prepared filters dictionary for API calls.
-        """
-        base_filters: Dict[str, Any] = {"AND": []}
-        if filters:
-            base_filters["AND"].append(filters)
-        if agent_id or self.agent_id:
-            base_filters["AND"].append({"agent_id": agent_id or self.agent_id})
-        if user_id or self.user_id:
-            base_filters["AND"].append({"user_id": user_id or self.user_id})
-        return base_filters if base_filters["AND"] else {}
-
     def _prepare_messages(
         self,
         records: List[Dict[str, Any]],
@@ -168,7 +140,6 @@ class Mem0Storage(BaseKeyValueStorage):
             self.client.add(messages, **options)
         except Exception as e:
             logger.error(f"Error adding memory: {e}")
-            logger.error(f"Error: {e}")
 
     def load(self) -> List[Dict[str, Any]]:
         r"""Loads all stored records from the Mem0 storage system.
@@ -178,11 +149,18 @@ class Mem0Storage(BaseKeyValueStorage):
                 represents a stored record.
         """
         try:
-            filters = self._prepare_filters(
-                agent_id=self.agent_id,
-                user_id=self.user_id,
-            )
-            results = self.client.get_all(version="v2", **filters)
+            # Build kwargs for get_all
+            kwargs = {}
+            if self.agent_id:
+                kwargs['agent_id'] = self.agent_id
+            if self.user_id:
+                kwargs['user_id'] = self.user_id
+
+            # If no filters available, return empty list
+            if not kwargs:
+                return []
+
+            results = self.client.get_all(**kwargs)
 
             # Transform results into MemoryRecord objects
             transformed_results = []
@@ -190,35 +168,58 @@ class Mem0Storage(BaseKeyValueStorage):
                 memory_record = MemoryRecord(
                     uuid=UUID(result["id"]),
                     message=BaseMessage(
-                        role_name="user",
+                        role_name="memory",
                         role_type=RoleType.USER,
-                        meta_dict={},
+                        meta_dict=result.get("metadata", {}),
                         content=result["memory"],
                     ),
                     role_at_backend=OpenAIBackendRole.USER,
                     extra_info=result.get("metadata", {}),
                     timestamp=datetime.fromisoformat(
-                        result["created_at"]
+                        result["created_at"].replace('Z', '+00:00')
                     ).timestamp(),
-                    agent_id=result.get("agent_id", ""),
+                    agent_id=result.get("agent_id", self.agent_id or ""),
                 )
                 transformed_results.append(memory_record.to_dict())
 
             return transformed_results
         except Exception as e:
-            logger.error(f"Error searching memories: {e}")
+            logger.error(f"Error loading memories: {e}")
             return []
 
     def clear(
         self,
+        agent_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> None:
-        r"""Removes all records from the Mem0 storage system."""
+        r"""Removes all records from the Mem0 storage system.
+
+        Args:
+            agent_id (Optional[str]): Specific agent ID to clear memories for.
+            user_id (Optional[str]): Specific user ID to clear memories for.
+        """
         try:
-            filters = self._prepare_filters(
-                agent_id=self.agent_id,
-                user_id=self.user_id,
-            )
-            self.client.delete_users(**filters)
+            # Use provided IDs or fall back to instance defaults
+            target_user_id = user_id or self.user_id
+            target_agent_id = agent_id or self.agent_id
+
+            # Build kwargs for delete_users method
+            kwargs = {}
+            if target_user_id:
+                kwargs['user_id'] = target_user_id
+            if target_agent_id:
+                kwargs['agent_id'] = target_agent_id
+
+            if kwargs:
+                # Use delete_users (plural) - this is the correct method name
+                self.client.delete_users(**kwargs)
+                logger.info(
+                    f"Successfully cleared memories with filters: {kwargs}"
+                )
+            else:
+                logger.warning(
+                    "No user_id or agent_id available for clearing memories"
+                )
+
         except Exception as e:
             logger.error(f"Error deleting memories: {e}")
-            logger.error(f"Error: {e}")

camel/toolkits/file_write_toolkit.py

@@ -840,6 +840,69 @@ class FileWriteToolkit(BaseToolkit):
 
         return text
 
+    def _ensure_html_utf8_meta(self, content: str) -> str:
+        r"""Ensure HTML content has UTF-8 meta tag.
+
+        Args:
+            content (str): The HTML content.
+
+        Returns:
+            str: HTML content with UTF-8 meta tag.
+        """
+        # Check if content already has a charset meta tag
+        has_charset = re.search(
+            r'<meta[^>]*charset[^>]*>', content, re.IGNORECASE
+        )
+
+        # UTF-8 meta tag
+        utf8_meta = '<meta charset="utf-8">'
+
+        if has_charset:
+            # Replace existing charset with UTF-8
+            content = re.sub(
+                r'<meta[^>]*charset[^>]*>',
+                utf8_meta,
+                content,
+                flags=re.IGNORECASE,
+            )
+        else:
+            # Add UTF-8 meta tag
+            # Try to find <head> tag
+            head_match = re.search(r'<head[^>]*>', content, re.IGNORECASE)
+            if head_match:
+                # Insert after <head> tag
+                insert_pos = head_match.end()
+                content = (
+                    content[:insert_pos]
+                    + '\n    '
+                    + utf8_meta
+                    + content[insert_pos:]
+                )
+            else:
+                # No <head> tag found, check if there's <html> tag
+                html_match = re.search(r'<html[^>]*>', content, re.IGNORECASE)
+                if html_match:
+                    # Insert <head> with meta tag after <html>
+                    insert_pos = html_match.end()
+                    content = (
+                        content[:insert_pos]
+                        + '\n<head>\n    '
+                        + utf8_meta
+                        + '\n</head>'
+                        + content[insert_pos:]
+                    )
+                else:
+                    # No proper HTML structure, wrap content
+                    content = (
+                        '<!DOCTYPE html>\n<html>\n<head>\n    '
+                        + utf8_meta
+                        + '\n</head>\n<body>\n'
+                        + content
+                        + '\n</body>\n</html>'
+                    )
+
+        return content
+
     def _write_csv_file(
         self,
         file_path: Path,
@@ -901,6 +964,10 @@ class FileWriteToolkit(BaseToolkit):
             content (str): The content to write.
             encoding (str): Character encoding to use. (default: :obj:`utf-8`)
         """
+        # For HTML files, ensure UTF-8 meta tag is present
+        if file_path.suffix.lower() in ['.html', '.htm']:
+            content = self._ensure_html_utf8_meta(content)
+
         with file_path.open("w", encoding=encoding) as f:
             f.write(content)
 

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/types/enums.py

@@ -245,6 +245,7 @@ class ModelType(UnifiedModelType, Enum):
     QWEN_QWQ_32B = "qwq-32b-preview"
     QWEN_QVQ_72B = "qvq-72b-preview"
     QWEN_QWQ_PLUS = "qwq-plus"
+    QWEN_3_CODER_PLUS = "qwen3-coder-plus"
 
     # Yi models (01-ai)
     YI_LIGHTNING = "yi-lightning"
@@ -763,6 +764,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.QWEN_PLUS_2025_04_28,
             ModelType.QWEN_TURBO_LATEST,
             ModelType.QWEN_TURBO_2025_04_28,
+            ModelType.QWEN_3_CODER_PLUS,
         }
 
     @property
@@ -1306,6 +1308,10 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.NOVITA_LLAMA_4_MAVERICK_17B,
         }:
             return 1_048_576
+        elif self in {
+            ModelType.QWEN_3_CODER_PLUS,
+        }:
+            return 1_000_000
         elif self in {
             ModelType.QWEN_LONG,
             ModelType.TOGETHER_LLAMA_4_SCOUT,

{camel_ai-0.2.73a6.dist-info → camel_ai-0.2.73a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a6
+Version: 0.2.73a9
 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.73a6.dist-info → camel_ai-0.2.73a9.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=JP5f2mqGwiHtIMh6SJqVmdqUdZ1ig-Hw_q0RjVeoYbE,901
+camel/__init__.py,sha256=5x8F3f70sOTYS-YwvaLAyGdigu-jW_3Tncrt3bj-R-s,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
@@ -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
@@ -292,7 +292,7 @@ camel/storages/key_value_storages/__init__.py,sha256=qBNx5QwKGa2wydavFYpM5MLVPkq
 camel/storages/key_value_storages/base.py,sha256=FSfxeLuG7SPvn-Mg-OQxtRKPtQBnRkB7lYeDaFOefpk,2177
 camel/storages/key_value_storages/in_memory.py,sha256=k04Nx53lYxD5MoqDtBEgZrQYkAQ-zIuU6tqnoNqiHws,1949
 camel/storages/key_value_storages/json.py,sha256=Jn7-fh2MjSMaVSCCMF_Hu-mAIj6JJ86iwKaSgI-5Uf0,3483
-camel/storages/key_value_storages/mem0_cloud.py,sha256=py8-n3in65K9cFnUJTxXKhzE4J0H1BSUWFDD4DT3rPg,8254
+camel/storages/key_value_storages/mem0_cloud.py,sha256=kO6HL__8AwosPY0APv_JaiiOv1jf_Xa2VyZfDlzmOdo,8213
 camel/storages/key_value_storages/redis.py,sha256=Suo7wxxBXFc0fkJ8qSX2xQ26Ik_YhoKWfTOVQKUl5vA,5720
 camel/storages/object_storages/__init__.py,sha256=26yATVTD9yVH-p9KueD30JakstTGiDh89GcFtUNNe4U,915
 camel/storages/object_storages/amazon_s3.py,sha256=9Yvyyyb1LGHxr8REEza7oGopbVtLEfOyXWJc18ZwgqA,7418
@@ -333,7 +333,7 @@ camel/toolkits/dappier_toolkit.py,sha256=OEHOYXX_oXhgbVtWYAy13nO9uXf9i5qEXSwY4Pe
 camel/toolkits/data_commons_toolkit.py,sha256=aHZUSL1ACpnYGaf1rE2csVKTmXTmN8lMGRUBYhZ_YEk,14168
 camel/toolkits/edgeone_pages_mcp_toolkit.py,sha256=1TFpAGHUNLggFQeN1OEw7P5laijwnlrCkfxBtgxFuUY,2331
 camel/toolkits/excel_toolkit.py,sha256=tQaonygk0yDTPZHWWQKG5osTN-R_EawR0bJIKLsLg08,35768
-camel/toolkits/file_write_toolkit.py,sha256=d8N8FfmK1fS13sY58PPhJh6M0vq6yh-s1-ltCZQJObg,37044
+camel/toolkits/file_write_toolkit.py,sha256=BIN4c_Tw_24iBu7vDFxVV401UTNqKZkP5p_eOOL_Hmk,39389
 camel/toolkits/function_tool.py,sha256=3_hE-Khqf556CeebchsPpjIDCynC6vKmUJLdh1EO_js,34295
 camel/toolkits/github_toolkit.py,sha256=iUyRrjWGAW_iljZVfNyfkm1Vi55wJxK6PsDAQs9pOag,13099
 camel/toolkits/google_calendar_toolkit.py,sha256=E-sdgdbtNBs_CXbhht9t1dsVr4DsTr5NguHkx4fvSmc,15410
@@ -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
@@ -438,7 +438,7 @@ camel/toolkits/open_api_specs/web_scraper/openapi.yaml,sha256=u_WalQ01e8W1D27VnZ
 camel/toolkits/open_api_specs/web_scraper/paths/__init__.py,sha256=OKCZrQCDwaWtXIN_2rA9FSqEvgpQRieRoHh7Ek6N16A,702
 camel/toolkits/open_api_specs/web_scraper/paths/scraper.py,sha256=aWy1_ppV4NVVEZfnbN3tu9XA9yAPAC9bRStJ5JuXMRU,1117
 camel/types/__init__.py,sha256=pFTg3CWGSCfwFdoxPDTf4dKV8DdJS1x-bBPuEOmtdf0,2549
-camel/types/enums.py,sha256=Zf37-MvLlbZt6WLNRMDi5UWiVDN1Q2CeZvLPSbFcg_Q,63051
+camel/types/enums.py,sha256=JolxBxgOfAGXAD-Z6DzMLiQ51I8H-6GrAO__1dEB_MQ,63239
 camel/types/mcp_registries.py,sha256=dl4LgYtSaUhsqAKpz28k_SA9La11qxqBvDLaEuyzrFE,4971
 camel/types/openai_types.py,sha256=8ZFzLe-zGmKNPfuVZFzxlxAX98lGf18gtrPhOgMmzus,2104
 camel/types/unified_model_type.py,sha256=U3NUZux7QuMIxPW2H0qDp9BOyDJFHAx6jUmDNw5_9KM,5912
@@ -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.73a6.dist-info/METADATA,sha256=CS0ZgtTR4f4JAwpvej1pHlG7S1LqF2K8k7D42GUSito,50434
-camel_ai-0.2.73a6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.73a6.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.73a6.dist-info/RECORD,,
+camel_ai-0.2.73a9.dist-info/METADATA,sha256=DX7cvC3menqY-BKlqULVDdurx20QNDEuUDiMQtrxhM0,50434
+camel_ai-0.2.73a9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.73a9.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.73a9.dist-info/RECORD,,