camel-ai 0.2.76a1__py3-none-any.whl → 0.2.76a3__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.76a1'
+__version__ = '0.2.76a3'
 
 __all__ = [
     '__version__',

camel/environments/tic_tac_toe.py

@@ -483,7 +483,7 @@ class TicTacToeEnv(MultiStepEnv):
         # Check all win combinations.
         for a, b, c in TicTacToeEnv.WIN_COMBINATIONS:
             if board[a] != " " and board[a] == board[b] == board[c]:
-                return board[a]
+                return board[a]  # type: ignore[return-value]
         # Check for draw.
         if all(cell != " " for cell in board):
             return "draw"

camel/models/base_model.py

@@ -24,6 +24,7 @@ from openai.lib.streaming.chat import (
 )
 from pydantic import BaseModel
 
+from camel.logger import get_logger as camel_get_logger
 from camel.messages import OpenAIMessage
 from camel.types import (
     ChatCompletion,
@@ -34,6 +35,21 @@ from camel.types import (
 )
 from camel.utils import BaseTokenCounter
 
+if os.environ.get("TRACEROOT_ENABLED", "False").lower() == "true":
+    try:
+        from traceroot import get_logger  # type: ignore[import]
+        from traceroot import trace as observe  # type: ignore[import]
+
+        logger = get_logger('base_model')
+    except ImportError:
+        from camel.utils import observe
+
+        logger = camel_get_logger('base_model')
+else:
+    from camel.utils import observe
+
+    logger = camel_get_logger('base_model')
+
 
 class ModelBackendMeta(abc.ABCMeta):
     r"""Metaclass that automatically preprocesses messages in run method.
@@ -364,6 +380,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         """
         pass
 
+    @observe()
     def run(
         self,
         messages: List[OpenAIMessage],
@@ -403,7 +420,13 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         elif not tools:
             tools = None
 
+        logger.info("Running model: %s", self.model_type)
+        logger.info("Messages: %s", messages)
+        logger.info("Response format: %s", response_format)
+        logger.info("Tools: %s", tools)
+
         result = self._run(messages, response_format, tools)
+        logger.info("Result: %s", result)
 
         # Log the response if logging is enabled
         if log_path:
@@ -411,6 +434,7 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
 
         return result
 
+    @observe()
     async def arun(
         self,
         messages: List[OpenAIMessage],
@@ -448,7 +472,13 @@ class BaseModelBackend(ABC, metaclass=ModelBackendMeta):
         elif not tools:
             tools = None
 
+        logger.info("Running model: %s", self.model_type)
+        logger.info("Messages: %s", messages)
+        logger.info("Response format: %s", response_format)
+        logger.info("Tools: %s", tools)
+
         result = await self._arun(messages, response_format, tools)
+        logger.info("Result: %s", result)
 
         # Log the response if logging is enabled
         if log_path:

camel/societies/workforce/workforce.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 import asyncio
 import concurrent.futures
 import json
+import os
 import time
 import uuid
 from collections import deque
@@ -79,7 +80,15 @@ from camel.utils import dependencies_required
 
 from .workforce_logger import WorkforceLogger
 
-logger = get_logger(__name__)
+if os.environ.get("TRACEROOT_ENABLED", "False").lower() == "true":
+    try:
+        import traceroot  # type: ignore[import]
+
+        logger = traceroot.get_logger('camel')
+    except ImportError:
+        logger = get_logger(__name__)
+else:
+    logger = get_logger(__name__)
 
 # Constants for configuration values
 MAX_TASK_RETRIES = 3

camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py

@@ -25,6 +25,66 @@ class HybridBrowserToolkit(BaseToolkit):
     This wrapper allows users to choose between:
     - 'typescript': WebSocket-based implementation using TypeScript/Node.js
     - 'python': Pure Python implementation using Playwright directly
+
+    Args:
+        mode (Literal["typescript", "python"]): Implementation mode. -
+            'typescript': Uses WebSocket-based TypeScript implementation -
+            'python': Uses pure Python Playwright implementation. Defaults to
+            "typescript".
+        headless (bool): Whether to run browser in headless mode.
+            Defaults to True.
+        user_data_dir (Optional[str]): Directory for user data
+            persistence. Defaults to None.
+        stealth (bool): Whether to enable stealth mode. Defaults to
+            False.
+        web_agent_model (Optional[BaseModelBackend]): Model for web
+            agent operations. Defaults to None.
+        cache_dir (str): Directory for caching. Defaults to "tmp/".
+        enabled_tools (Optional[List[str]]): List of enabled tools.
+            Defaults to None.
+        browser_log_to_file (bool): Whether to log browser actions to
+            file. Defaults to False.
+        log_dir (Optional[str]): Custom directory path for log files.
+            If None, defaults to "browser_log". Defaults to None.
+        session_id (Optional[str]): Session identifier. Defaults to None.
+        default_start_url (str): Default URL to start with. Defaults
+            to "https://google.com/".
+        default_timeout (Optional[int]): Default timeout in
+            milliseconds. Defaults to None.
+        short_timeout (Optional[int]): Short timeout in milliseconds.
+            Defaults to None.
+        navigation_timeout (Optional[int]): Navigation timeout in
+            milliseconds. Defaults to None.
+        network_idle_timeout (Optional[int]): Network idle timeout in
+            milliseconds. Defaults to None.
+        screenshot_timeout (Optional[int]): Screenshot timeout in
+            milliseconds. Defaults to None.
+        page_stability_timeout (Optional[int]): Page stability timeout
+            in milliseconds. Defaults to None.
+        dom_content_loaded_timeout (Optional[int]): DOM content loaded
+            timeout in milliseconds. Defaults to None.
+        viewport_limit (bool): Whether to filter page snapshot
+            elements to only those visible in the current viewport.
+            Defaults to False.
+        connect_over_cdp (bool): Whether to connect to an existing
+            browser via Chrome DevTools Protocol. Defaults to False.
+            (Only supported in TypeScript mode)
+        cdp_url (Optional[str]): WebSocket endpoint URL for CDP
+            connection. Required when connect_over_cdp is True.
+            Defaults to None. (Only supported in TypeScript mode)
+        cdp_keep_current_page (bool): When True and using CDP mode,
+        won't create new pages but use the existing one. Defaults to False.
+            (Only supported in TypeScript mode)
+        full_visual_mode (bool): When True, browser actions like click,
+            browser_open, visit_page, etc. will return 'full visual mode'
+            as snapshot instead of actual page content. The
+            browser_get_page_snapshot method will still return the actual
+            snapshot. Defaults to False.
+        **kwargs: Additional keyword arguments passed to the
+            implementation.
+
+    Returns:
+        HybridBrowserToolkit instance of the specified implementation.
     """
 
     def __new__(

camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py

@@ -109,6 +109,7 @@ class WebSocketBrowserWrapper:
         self._send_lock = asyncio.Lock()
         self._receive_task = None
         self._pending_responses: Dict[str, asyncio.Future[Dict[str, Any]]] = {}
+        self._browser_opened = False
         self._server_ready_future = None
 
         self.browser_log_to_file = (config or {}).get(
@@ -191,10 +192,14 @@ class WebSocketBrowserWrapper:
         """Start the WebSocket server and connect to it."""
         await self._cleanup_existing_processes()
 
+        import platform
+
+        use_shell = platform.system() == 'Windows'
         npm_check = subprocess.run(
             ['npm', '--version'],
             capture_output=True,
             text=True,
+            shell=use_shell,
         )
         if npm_check.returncode != 0:
             raise RuntimeError(
@@ -207,6 +212,7 @@ class WebSocketBrowserWrapper:
             ['node', '--version'],
             capture_output=True,
             text=True,
+            shell=use_shell,
         )
         if node_check.returncode != 0:
             raise RuntimeError(
@@ -223,6 +229,7 @@ class WebSocketBrowserWrapper:
                 cwd=self.ts_dir,
                 capture_output=True,
                 text=True,
+                shell=use_shell,
             )
             if install_result.returncode != 0:
                 logger.error(f"npm install failed: {install_result.stderr}")
@@ -237,6 +244,7 @@ class WebSocketBrowserWrapper:
             cwd=self.ts_dir,
             capture_output=True,
             text=True,
+            shell=use_shell,
         )
         if build_result.returncode != 0:
             logger.error(f"TypeScript build failed: {build_result.stderr}")
@@ -244,13 +252,16 @@ class WebSocketBrowserWrapper:
                 f"TypeScript build failed: {build_result.stderr}"
             )
 
+        # use_shell already defined above
         self.process = subprocess.Popen(
             ['node', 'websocket-server.js'],
             cwd=self.ts_dir,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
+            encoding='utf-8',
             bufsize=1,
+            shell=use_shell,
         )
 
         self._server_ready_future = asyncio.get_running_loop().create_future()
@@ -391,6 +402,9 @@ class WebSocketBrowserWrapper:
 
         await self._send_command('init', self.config)
 
+        if self.config.get('cdpUrl'):
+            self._browser_opened = True
+
     async def stop(self):
         """Stop the WebSocket connection and server."""
         if self.websocket:
@@ -400,11 +414,12 @@ class WebSocketBrowserWrapper:
                     timeout=2.0,
                 )
 
-            # Close websocket connection
             with contextlib.suppress(Exception):
                 await self.websocket.close()
             self.websocket = None
 
+        self._browser_opened = False
+
         # Gracefully stop the Node process before cancelling the log reader
         if self.process:
             try:
@@ -448,12 +463,13 @@ class WebSocketBrowserWrapper:
 
         This is useful for CDP mode where the browser should remain open.
         """
-        # Close websocket connection
         if self.websocket:
             with contextlib.suppress(Exception):
                 await self.websocket.close()
             self.websocket = None
 
+        self._browser_opened = False
+
         # Stop the Node process
         if self.process:
             try:
@@ -709,17 +725,31 @@ class WebSocketBrowserWrapper:
         response = await self._send_command(
             'open_browser', {'startUrl': start_url}
         )
+        self._browser_opened = True
         return response
 
     @action_logger
     async def close_browser(self) -> str:
         """Close browser."""
         response = await self._send_command('close_browser', {})
+        self._browser_opened = False
         return response['message']
 
     @action_logger
     async def visit_page(self, url: str) -> Dict[str, Any]:
-        """Visit a page."""
+        """Visit a page.
+
+        In non-CDP mode, automatically opens browser if not already open.
+        """
+        if not self._browser_opened:
+            is_cdp_mode = bool(self.config.get('cdpUrl'))
+
+            if not is_cdp_mode:
+                logger.info(
+                    "Browser not open, automatically opening browser..."
+                )
+                await self.open_browser()
+
         response = await self._send_command('visit_page', {'url': url})
         return response
 

camel/toolkits/mcp_toolkit.py

@@ -18,6 +18,8 @@ import warnings
 from contextlib import AsyncExitStack
 from typing import Any, Dict, List, Optional
 
+from typing_extensions import TypeGuard
+
 from camel.logger import get_logger
 from camel.toolkits import BaseToolkit, FunctionTool
 from camel.utils.commons import run_async
@@ -43,6 +45,187 @@ class MCPToolError(Exception):
     pass
 
 
+_EMPTY_SCHEMA = {
+    "additionalProperties": False,
+    "type": "object",
+    "properties": {},
+    "required": [],
+}
+
+
+def ensure_strict_json_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    r"""Mutates the given JSON schema to ensure it conforms to the
+    `strict` standard that the OpenAI API expects.
+    """
+    if schema == {}:
+        return _EMPTY_SCHEMA
+    return _ensure_strict_json_schema(schema, path=(), root=schema)
+
+
+def _ensure_strict_json_schema(
+    json_schema: object,
+    *,
+    path: tuple[str, ...],
+    root: dict[str, object],
+) -> dict[str, Any]:
+    if not is_dict(json_schema):
+        raise TypeError(
+            f"Expected {json_schema} to be a dictionary; path={path}"
+        )
+
+    defs = json_schema.get("$defs")
+    if is_dict(defs):
+        for def_name, def_schema in defs.items():
+            _ensure_strict_json_schema(
+                def_schema, path=(*path, "$defs", def_name), root=root
+            )
+
+    definitions = json_schema.get("definitions")
+    if is_dict(definitions):
+        for definition_name, definition_schema in definitions.items():
+            _ensure_strict_json_schema(
+                definition_schema,
+                path=(*path, "definitions", definition_name),
+                root=root,
+            )
+
+    typ = json_schema.get("type")
+    if typ == "object" and "additionalProperties" not in json_schema:
+        json_schema["additionalProperties"] = False
+    elif (
+        typ == "object"
+        and "additionalProperties" in json_schema
+        and json_schema["additionalProperties"]
+    ):
+        raise ValueError(
+            "additionalProperties should not be set for object types. This "
+            "could be because you're using an older version of Pydantic, or "
+            "because you configured additional properties to be allowed. If "
+            "you really need this, update the function or output tool "
+            "to not use a strict schema."
+        )
+
+    # object types
+    # { 'type': 'object', 'properties': { 'a':  {...} } }
+    properties = json_schema.get("properties")
+    if is_dict(properties):
+        json_schema["required"] = list(properties.keys())
+        json_schema["properties"] = {
+            key: _ensure_strict_json_schema(
+                prop_schema, path=(*path, "properties", key), root=root
+            )
+            for key, prop_schema in properties.items()
+        }
+
+    # arrays
+    # { 'type': 'array', 'items': {...} }
+    items = json_schema.get("items")
+    if is_dict(items):
+        json_schema["items"] = _ensure_strict_json_schema(
+            items, path=(*path, "items"), root=root
+        )
+
+    # unions
+    any_of = json_schema.get("anyOf")
+    if is_list(any_of):
+        json_schema["anyOf"] = [
+            _ensure_strict_json_schema(
+                variant, path=(*path, "anyOf", str(i)), root=root
+            )
+            for i, variant in enumerate(any_of)
+        ]
+
+    # intersections
+    all_of = json_schema.get("allOf")
+    if is_list(all_of):
+        if len(all_of) == 1:
+            json_schema.update(
+                _ensure_strict_json_schema(
+                    all_of[0], path=(*path, "allOf", "0"), root=root
+                )
+            )
+            json_schema.pop("allOf")
+        else:
+            json_schema["allOf"] = [
+                _ensure_strict_json_schema(
+                    entry, path=(*path, "allOf", str(i)), root=root
+                )
+                for i, entry in enumerate(all_of)
+            ]
+
+    # strip `None` defaults as there's no meaningful distinction here
+    # the schema will still be `nullable` and the model will default
+    # to using `None` anyway
+    if json_schema.get("default", None) is None:
+        json_schema.pop("default", None)
+
+    # we can't use `$ref`s if there are also other properties defined, e.g.
+    # `{"$ref": "...", "description": "my description"}`
+    #
+    # so we unravel the ref
+    # `{"type": "string", "description": "my description"}`
+    ref = json_schema.get("$ref")
+    if ref and has_more_than_n_keys(json_schema, 1):
+        assert isinstance(ref, str), f"Received non-string $ref - {ref}"
+
+        resolved = resolve_ref(root=root, ref=ref)
+        if not is_dict(resolved):
+            raise ValueError(
+                f"Expected `$ref: {ref}` to resolved to a dictionary but got "
+                f"{resolved}"
+            )
+
+        # properties from the json schema take priority
+        # over the ones on the `$ref`
+        json_schema.update({**resolved, **json_schema})
+        json_schema.pop("$ref")
+        # Since the schema expanded from `$ref` might not
+        # have `additionalProperties: false` applied
+        # we call `_ensure_strict_json_schema` again to fix the inlined
+        # schema and ensure it's valid
+        return _ensure_strict_json_schema(json_schema, path=path, root=root)
+
+    return json_schema
+
+
+def resolve_ref(*, root: dict[str, object], ref: str) -> object:
+    if not ref.startswith("#/"):
+        raise ValueError(
+            f"Unexpected $ref format {ref!r}; Does not start with #/"
+        )
+
+    path = ref[2:].split("/")
+    resolved = root
+    for key in path:
+        value = resolved[key]
+        assert is_dict(value), (
+            f"encountered non-dictionary entry while resolving {ref} - "
+            f"{resolved}"
+        )
+        resolved = value
+
+    return resolved
+
+
+def is_dict(obj: object) -> TypeGuard[dict[str, object]]:
+    # just pretend that we know there are only `str` keys
+    # as that check is not worth the performance cost
+    return isinstance(obj, dict)
+
+
+def is_list(obj: object) -> TypeGuard[list[object]]:
+    return isinstance(obj, list)
+
+
+def has_more_than_n_keys(obj: dict[str, object], n: int) -> bool:
+    i = 0
+    for _ in obj.keys():
+        i += 1
+        if i > n:
+            return True
+    return False
+
+
 class MCPToolkit(BaseToolkit):
     r"""MCPToolkit provides a unified interface for managing multiple
     MCP server connections and their tools.
@@ -476,367 +659,149 @@ class MCPToolkit(BaseToolkit):
             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 according to the structured outputs specification.
-
-        Args:
-            tool (FunctionTool): The tool to check and update if necessary.
-
-        Returns:
-            FunctionTool: The tool with a strict schema.
+        r"""Ensure a tool has a strict schema compatible with
+        OpenAI's requirements.
+
+        Strategy:
+        - Ensure parameters exist with at least an empty properties object
+            (OpenAI requirement).
+        - Try converting parameters to strict using ensure_strict_json_schema.
+        - If conversion fails, mark function.strict = False and
+            keep best-effort parameters.
         """
         try:
             schema = tool.get_openai_tool_schema()
 
-            # 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):
-                    # 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
-                            )
+            def _has_strict_mode_incompatible_features(json_schema):
+                r"""Check if schema has features incompatible
+                with OpenAI strict mode."""
 
-                    # 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 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 _check_incompatible(obj, path=""):
+                    if not isinstance(obj, dict):
+                        return False
 
-                def _count_properties(o, depth=0):
-                    if isinstance(o, dict):
-                        if depth > 5:
-                            raise ValueError(
-                                "Schema exceeds maximum nesting depth of 5"
+                    # Check for allOf in array items (known to cause issues)
+                    if "items" in obj and isinstance(obj["items"], dict):
+                        items_schema = obj["items"]
+                        if "allOf" in items_schema:
+                            logger.debug(
+                                f"Found allOf in array items at {path}"
                             )
+                            return True
+                        # Recursively check items schema
+                        if _check_incompatible(items_schema, f"{path}.items"):
+                            return True
+
+                    # Check for other potentially problematic patterns
+                    # anyOf/oneOf in certain contexts can also cause issues
+                    if (
+                        "anyOf" in obj and len(obj["anyOf"]) > 10
+                    ):  # Large unions can be problematic
+                        return True
+
+                    # Recursively check nested objects
+                    for key in [
+                        "properties",
+                        "additionalProperties",
+                        "patternProperties",
+                    ]:
+                        if key in obj and isinstance(obj[key], dict):
+                            if key == "properties":
+                                for prop_name, prop_schema in obj[key].items():
+                                    if isinstance(
+                                        prop_schema, dict
+                                    ) and _check_incompatible(
+                                        prop_schema,
+                                        f"{path}.{key}.{prop_name}",
+                                    ):
+                                        return True
+                            elif _check_incompatible(
+                                obj[key], f"{path}.{key}"
+                            ):
+                                return True
 
-                        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"
-                    )
-
-                return True
+                    # Check arrays and unions
+                    for key in ["allOf", "anyOf", "oneOf"]:
+                        if key in obj and isinstance(obj[key], list):
+                            for i, item in enumerate(obj[key]):
+                                if isinstance(
+                                    item, dict
+                                ) and _check_incompatible(
+                                    item, f"{path}.{key}[{i}]"
+                                ):
+                                    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 = []
+                    return False
 
-                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}"
-                            )
+                return _check_incompatible(json_schema)
 
-                        # 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:
-                # 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
+            # Apply sanitization if available
             if "function" in schema:
-                # Apply the sanitization function first
-                from camel.toolkits.function_tool import (
-                    sanitize_and_enforce_required,
-                )
+                try:
+                    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
+                    schema = sanitize_and_enforce_required(schema)
+                except ImportError:
+                    logger.debug("sanitize_and_enforce_required not available")
 
-                        # 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
+                parameters = schema["function"].get("parameters", {})
+                if not parameters:
+                    # Empty parameters - use minimal valid schema
+                    parameters = {
+                        "type": "object",
+                        "properties": {},
+                        "additionalProperties": False,
+                    }
+                    schema["function"]["parameters"] = parameters
 
-                # 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
+                # MCP spec doesn't require 'properties', but OpenAI spec does
+                if (
+                    parameters.get("type") == "object"
+                    and "properties" not in parameters
+                ):
+                    parameters["properties"] = {}
 
-                # Now check for blocking issues after sanitization
-                issues = _has_strict_mode_issues(schema)
-                if issues:
-                    # Can't use strict mode
+                try:
+                    # _check_schema_limits(parameters)
+
+                    # Check for OpenAI strict mode incompatible features
+                    if _has_strict_mode_incompatible_features(parameters):
+                        raise ValueError(
+                            "Schema contains features "
+                            "incompatible with strict mode"
+                        )
+
+                    strict_params = ensure_strict_json_schema(parameters)
+                    schema["function"]["parameters"] = strict_params
+                    schema["function"]["strict"] = True
+                except Exception as e:
+                    # Fallback to non-strict mode on any failure
                     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
+                        f"Tool '{tool.get_function_name()}' "
+                        f"cannot use strict mode: {e}"
                     )
-                    return tool
-
-                # Enable strict mode
-                schema["function"]["strict"] = True
-
-                parameters = schema["function"].get("parameters", {})
-                if parameters:
-                    # Validate and fix the parameters schema
-                    _validate_and_fix_schema(parameters)
-
-                    # Check schema limits
-                    _check_schema_limits(parameters)
 
             tool.set_openai_tool_schema(schema)
-            logger.debug(
-                f"Updated tool '{tool.get_function_name()}' to strict mode"
-            )
 
         except Exception as e:
-            # If we can't make it strict, disable strict mode
+            # Final fallback - ensure tool still works
             try:
-                if "function" in schema:
-                    schema["function"]["strict"] = False
-                tool.set_openai_tool_schema(schema)
+                current_schema = tool.get_openai_tool_schema()
+                if "function" in current_schema:
+                    current_schema["function"]["strict"] = False
+                tool.set_openai_tool_schema(current_schema)
                 logger.warning(
-                    f"Failed to ensure strict schema for "
-                    f"tool '{tool.get_function_name()}': {str(e)[:100]}. "
-                    f"Setting strict=False."
+                    f"Error processing schema for tool "
+                    f"'{tool.get_function_name()}': {str(e)[:100]}. "
+                    f"Using non-strict mode."
                 )
             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"Critical error processing tool "
+                    f"'{tool.get_function_name()}': {inner_e}. "
                     f"Tool may not function correctly."
                 )
 
@@ -879,6 +844,7 @@ class MCPToolkit(BaseToolkit):
             )
 
         all_tools = []
+        seen_names: set[str] = set()
         for i, client in enumerate(self.clients):
             try:
                 client_tools = client.get_tools()
@@ -887,6 +853,14 @@ class MCPToolkit(BaseToolkit):
                 strict_tools = []
                 for tool in client_tools:
                     strict_tool = self._ensure_strict_tool_schema(tool)
+                    name = strict_tool.get_function_name()
+                    if name in seen_names:
+                        logger.warning(
+                            f"Duplicate tool name detected and "
+                            f"skipped: '{name}' from client {i+1}"
+                        )
+                        continue
+                    seen_names.add(name)
                     strict_tools.append(strict_tool)
 
                 all_tools.extend(strict_tools)

camel/toolkits/slack_toolkit.py

@@ -237,7 +237,8 @@ class SlackToolkit(BaseToolkit):
     ) -> str:
         r"""Send a message to a Slack channel. When use this function you must
         call `get_slack_channel_information` function first to get the
-        `channel id`.
+        `channel id`. If use user, you must use `get_slack_user_list`
+        function first to get the user id.
 
         Args:
             message (str): The message to send.
@@ -306,6 +307,52 @@ class SlackToolkit(BaseToolkit):
         except SlackApiError as e:
             return f"Error deleting message: {e.response['error']}"
 
+    def get_slack_user_list(self) -> str:
+        r"""Retrieve a list of all users in the Slack workspace.
+
+        Returns:
+            str: A JSON string representing a list of users. Each user
+                object contains 'id', 'name'.
+        """
+        from slack_sdk.errors import SlackApiError
+
+        try:
+            slack_client = self._login_slack()
+            response = slack_client.users_list()
+            users = response["members"]
+            filtered_users = [
+                {
+                    "id": user["id"],
+                    "name": user["name"],
+                }
+                for user in users
+            ]
+
+            return json.dumps(filtered_users, ensure_ascii=False)
+        except SlackApiError as e:
+            return f"Error retrieving user list: {e.response['error']}"
+
+    def get_slack_user_info(self, user_id: str) -> str:
+        r"""Retrieve information about a specific user in the Slack workspace.
+        normally, you don't need to use this method, when you need to get a
+        user's detailed information, use this method. Use `get_slack_user_list`
+        function first to get the user id.
+
+        Args:
+            user_id (str): The ID of the user to retrieve information about.
+
+        Returns:
+            str: A JSON string representing the user's information.
+        """
+        from slack_sdk.errors import SlackApiError
+
+        try:
+            slack_client = self._login_slack()
+            response = slack_client.users_info(user=user_id)
+            return json.dumps(response, ensure_ascii=False)
+        except SlackApiError as e:
+            return f"Error retrieving user info: {e.response['error']}"
+
     def get_tools(self) -> List[FunctionTool]:
         r"""Returns a list of FunctionTool objects representing the
         functions in the toolkit.
@@ -322,4 +369,6 @@ class SlackToolkit(BaseToolkit):
             FunctionTool(self.get_slack_channel_message),
             FunctionTool(self.send_slack_message),
             FunctionTool(self.delete_slack_message),
+            FunctionTool(self.get_slack_user_list),
+            FunctionTool(self.get_slack_user_info),
         ]

{camel_ai-0.2.76a1.dist-info → camel_ai-0.2.76a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.76a1
+Version: 0.2.76a3
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -448,12 +448,52 @@ Join us ([*Discord*](https://discord.camel-ai.org/) or [*WeChat*](https://ghli.o
 </div>
 
 <div align="center">
-    <img src="docs/images/star.gif" alt="Star" width="186" height="60">
+    <img src="docs/images/stars.gif" alt="Star">
   </a>
 </div>
 
 <br>
 
+<details>
+<summary><kbd>Table of contents</kbd></summary>
+
+<br/>
+
+- [CAMEL Framework Design Principles](#camel-framework-design-principles)
+- [Why Use CAMEL for Your Research?](#why-use-camel-for-your-research)
+- [What Can You Build With CAMEL?](#what-can-you-build-with-camel)
+  - [Data Generation](#1-data-generation)
+  - [Task Automation](#2-task-automation)
+  - [World Simulation](#3-world-simulation)
+- [Quick Start](#quick-start)
+  - [Starting with ChatAgent](#starting-with-chatagent)
+  - [Seeking Help](#seeking-help)
+- [Tech Stack](#tech-stack)
+- [Research](#research)
+- [Synthetic Datasets](#synthetic-datasets)
+- [Cookbooks (Usecases)](#cookbooks-usecases)
+  - [Basic Concepts](#1-basic-concepts)
+  - [Advanced Features](#2-advanced-features)
+  - [Model Training & Data Generation](#3-model-training--data-generation)
+  - [Multi-Agent Systems & Applications](#4-multi-agent-systems--applications)
+  - [Data Processing](#5-data-processing)
+- [Real-World Usecases](#real-world-usecases)
+- [🧱 Built with CAMEL (Real-world Producs & Research)](#-built-with-camel-real-world-producs--research)
+  - [Research Projects](#research-projects)
+  - [Product Projects](#product-projects)
+- [🗓️ Events](#️-events)
+- [Contributing to CAMEL](#contributing-to-camel)
+- [Community & Contact](#community--contact)
+- [Citation](#citation)
+- [Acknowledgment](#acknowledgment)
+- [License](#license)
+
+####
+
+<br/>
+
+</details>
+
 
 ## CAMEL Framework Design Principles
 
@@ -687,6 +727,18 @@ We believe that studying these agents on a large scale offers valuable insights
 
 **Explore our research projects:**
 
+<div align="center">
+  <a href="https://github.com/camel-ai/owl">
+    <img src="docs/images/owl.png" alt="OWL">
+  </a>
+</div>
+
+<div align="center">
+  <a href="https://oasis.camel-ai.org/">
+    <img src="docs/images/oasis.png" alt="OASIS">
+  </a>
+</div>
+
 <div align="center">
   <a href="https://crab.camel-ai.org/">
     <img src="docs/images/crab.png" alt="CRAB">
@@ -694,14 +746,14 @@ We believe that studying these agents on a large scale offers valuable insights
 </div>
 
 <div align="center">
-  <a href="https://agent-trust.camel-ai.org/">
-    <img src="docs/images/agent_trust.png" alt="Agent Trust">
+  <a href="https://github.com/camel-ai/loong">
+    <img src="docs/images/loong.png" alt="Loong">
   </a>
 </div>
 
 <div align="center">
-  <a href="https://oasis.camel-ai.org/">
-    <img src="docs/images/oasis.png" alt="OASIS">
+  <a href="https://agent-trust.camel-ai.org/">
+    <img src="docs/images/agent_trust.png" alt="Agent Trust">
   </a>
 </div>
 
@@ -835,6 +887,31 @@ Real-world usecases demonstrating how CAMEL’s multi-agent framework enables re
 
 <br>
 
+## 🧱 Built with CAMEL (Real-world Producs & Research)
+<div align="left">
+  <a href="https://www.camel-ai.org/">
+    <img src="docs/images/built_with_CAMEL.png" alt="Built with CAMEL" height="40px">
+  </a>
+</div>
+
+### Research Projects
+
+| Name | Description |
+|:---|:---|
+| **[ChatDev](https://github.com/OpenBMB/ChatDev/tree/main/camel)** | Communicative Agents for software Development |
+| **[Paper2Poster](https://github.com/Paper2Poster/Paper2Poster)** | Multimodal poster automation from scientific papers |
+
+### Product Projects
+
+| Name | Description |
+|:---|:---|
+| **[Eigent](https://www.eigent.ai/)** | The World First Multi-agent Workforce |
+| **[EigentBot](https://bot.eigent.ai/)** | One EigentBot,
+Every Code Answer |
+| **[Matrix](https://matrix.eigent.ai/)** | Social Media Simulation |
+| **[AI Geometric](https://www.linkedin.com/posts/aigeometric_ai-interviewpreparation-careerdevelopment-activity-7261428422516555776-MtaK/?utm_source=share&utm_medium=member_desktop&rcm=ACoAAChHluEB9xRwkjiJ6VSAzqM2Y-U4NI2sKGY)** | AI-powered interview copilot |
+| **[Log10](https://github.com/log10-io/log10/blob/main/src/log10/agents/camel.py)** | AI accuracy, delivered |
+
 
 ## 🗓️ Events
 

{camel_ai-0.2.76a1.dist-info → camel_ai-0.2.76a3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=6I-bm5fZpPWlOpBZ5pxXypAQXhzfcXQx0Ah3FJJSZVk,901
+camel/__init__.py,sha256=9DLMrXKU5X35VRsz3WSLMoC2MnzWuYKWD0SHeoLtyIc,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
@@ -128,7 +128,7 @@ camel/environments/models.py,sha256=jVcCyU7xObKoWPnkshmPqyyKi3AOiMVVtUZA-tWEYUU,
 camel/environments/multi_step.py,sha256=HPIH2W-iWsmtDLeN1gjxo7LoAnMQQZzdmfjhmRoBAxg,8534
 camel/environments/rlcards_env.py,sha256=OclnrJf7HgjuGUgYP6lISBmzTyG_gThHgPKwTUrG9y8,29861
 camel/environments/single_step.py,sha256=zrAXLOBGGKQFnGENasUnmFO_T-rjppGPK2CRBLGu7aQ,23019
-camel/environments/tic_tac_toe.py,sha256=axRDN9yUVH8PzACkD6zenWiQKFDaupGsQ7NmSvbJCIc,19080
+camel/environments/tic_tac_toe.py,sha256=grw4z4GJBVS--IvMHUCy2IJy40z4fz6cG2HC0UmEktw,19110
 camel/extractors/__init__.py,sha256=lgtDl8zWvN826fJVKqRv05w556YZ-EdrHwdzKphywgA,1097
 camel/extractors/base.py,sha256=3jvuZpq27nlADDCX3GfubOpeb_zt-E9rzxF3x4lYm8s,10404
 camel/extractors/python_strategies.py,sha256=zHAkshnO9o-uvLtCuVOCKoA2PzetBTnkNx1Qy_3j_pE,8113
@@ -183,7 +183,7 @@ camel/models/anthropic_model.py,sha256=GlerIhIc7uGhzIsQoZw-_8CGOdcZT8DC_95V3hx3q
 camel/models/aws_bedrock_model.py,sha256=0JdsLxfi-coI8LtSPNewsaeR43CwC0qG2Gm_iY-ZCdo,4073
 camel/models/azure_openai_model.py,sha256=MSjb5E3b6BHQg896P-Mj00Q0xPq0ibi0tO2T87Fj25s,17802
 camel/models/base_audio_model.py,sha256=_VUWh1L3rh8mldNvM5R6jBOKtvmTeBKJyRxAdPJmPlY,3324
-camel/models/base_model.py,sha256=82MVxlWQXEN_gmVTgbAr0vP02opn0bn8pDK6K-3OtQE,19128
+camel/models/base_model.py,sha256=aty9oIZowjt5Mxi0aB7ifHUmQO-78UMfUFLPNm10lGg,20164
 camel/models/cohere_model.py,sha256=9H2F8bjwxPgwSwgPPRoOy090dQKBboQxnlk-94FoDIk,16719
 camel/models/crynux_model.py,sha256=rslcj7FbbeKZzYS2n23fEe5Ua77FY1gXmUAy6TBY2Yw,3545
 camel/models/deepseek_model.py,sha256=qk5RrzYddKn3usddsB9NsRG5UfNR-dh2Ymwqw-NsYNs,10432
@@ -285,7 +285,7 @@ camel/societies/workforce/structured_output_handler.py,sha256=xr8szFN86hg3jQ825a
 camel/societies/workforce/task_channel.py,sha256=TXRwiqtmRPdelEmFCVN3jhd5XpgaSLwy9uHPtGecujA,11418
 camel/societies/workforce/utils.py,sha256=THgNHSeZsNVnjTzQTur3qCJhi72MrDS8X2gPET174cI,8434
 camel/societies/workforce/worker.py,sha256=MtUqYkTC9V-PIIRwSkKiB9w_YSu92iOpoha2rktEiQ0,6248
-camel/societies/workforce/workforce.py,sha256=UsU46YWWFnJV_YbYQwwv6COZ3iPJnLY3XetDhdI9w_o,142328
+camel/societies/workforce/workforce.py,sha256=h7Df4zoo5UuB-GpYTHotdcIwFDS6ESANLQLWzo56urE,142583
 camel/societies/workforce/workforce_logger.py,sha256=0YT__ys48Bgn0IICKIZBmSWhON-eA1KShebjCdn5ppE,24525
 camel/storages/__init__.py,sha256=RwpEyvxpMbJzVDZJJygeBg4AzyYMkTjjkfB53hTuqGo,2141
 camel/storages/graph_storages/__init__.py,sha256=G29BNn651C0WTOpjCl4QnVM-4B9tcNh8DdmsCiONH8Y,948
@@ -354,7 +354,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=lwN6qQY8TLZkNWOqzeKZG3Fku-HMpGFrdRwhtPaJSlw,3844
 camel/toolkits/math_toolkit.py,sha256=SJbzT6akHRlmqo1QwCj1f7-6pEv0sNKJbcYvYAylHQw,5439
-camel/toolkits/mcp_toolkit.py,sha256=FbBKyz7f6y2hA-lBVsh3K-_gyz2rVDwe3uvaK8OsuRc,41442
+camel/toolkits/mcp_toolkit.py,sha256=Y6bwq_Wy1FeBi7uVjiR6SrN1GQeJJDqgDt6Hcl26gOw,37530
 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
@@ -380,7 +380,7 @@ camel/toolkits/screenshot_toolkit.py,sha256=IwfvfLSfqrEywvPlDbtYJe1qcbrO5uC3Mxxv
 camel/toolkits/search_toolkit.py,sha256=0SA2FLefCFmW5B4zMpllr4V-kJT2l9_KhwFuVRH2Co0,56052
 camel/toolkits/searxng_toolkit.py,sha256=a2GtE4FGSrmaIVvX6Yide-abBYD1wsHqitnDlx9fdVg,7664
 camel/toolkits/semantic_scholar_toolkit.py,sha256=Rh7eA_YPxV5pvPIzhjjvpr3vtlaCniJicrqzkPWW9_I,11634
-camel/toolkits/slack_toolkit.py,sha256=iBVkDIpfsR5QwaNCqA4O4UkCwpdLhJjYCA8Gka7U9e8,12050
+camel/toolkits/slack_toolkit.py,sha256=hlU7EmXTIrtvG5Mr35jfbQBCJW_eyOSS1FSncXYfj9U,13935
 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
@@ -398,9 +398,9 @@ camel/toolkits/wolfram_alpha_toolkit.py,sha256=qeIM8ySn5ilcExBWtx-hDOc35bNcebLVn
 camel/toolkits/zapier_toolkit.py,sha256=A83y1UcfuopH7Fx82pORzypl1StbhBjB2HhyOqYa300,7124
 camel/toolkits/hybrid_browser_toolkit/__init__.py,sha256=vxjWhq7GjUKE5I9RGQU_GoikZJ-AVK4ertdvEqp9pd0,802
 camel/toolkits/hybrid_browser_toolkit/config_loader.py,sha256=1FVZzDucDsC9IB6EcfP9TMgD3Z60vOniY4dk5TB1dsg,7595
-camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py,sha256=lKZqDiRPVi07flrACCjFtANDsp-n6kstE1iF7OOhDa4,8930
+camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py,sha256=56o6ht3SwvkUbULFfDOQMx3eE-WVp8L81zZ_hp4tjfM,12195
 camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit_ts.py,sha256=KGvtdJdUJ86VacPmL4BYd0EZjscH6Z2wXtraXAQud1Y,56214
-camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py,sha256=Ts30Ue9MEcwJU4C0KSYANvEw_YZmjeGe3quzZJ8O5Ek,37160
+camel/toolkits/hybrid_browser_toolkit/ws_wrapper.py,sha256=Z0LGrghQ9iLXJ2DKspj2_U9Qr8359lk73YH40qjkX0o,38019
 camel/toolkits/hybrid_browser_toolkit/ts/package-lock.json,sha256=_-YE9S_C1XT59A6upQp9lLuZcC67cV9QlbwAsEKkfyw,156337
 camel/toolkits/hybrid_browser_toolkit/ts/package.json,sha256=pUQm0xwXR7ZyWNv6O2QtHW00agnfAoX9F_XGXZlAxl4,745
 camel/toolkits/hybrid_browser_toolkit/ts/tsconfig.json,sha256=SwpQnq4Q-rwRobF2iWrP96mgmgwaVPZEv-nii5QIYEU,523
@@ -479,7 +479,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.76a1.dist-info/METADATA,sha256=_UR_r1rpykgqO_LbYlG7VBIkWS_uGEJqqRJYUQ0e5T4,52058
-camel_ai-0.2.76a1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.76a1.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.76a1.dist-info/RECORD,,
+camel_ai-0.2.76a3.dist-info/METADATA,sha256=rib4FdlfEFWDE_QAGVNdTIJg4SxJH03pxIhP0GqgNvU,54897
+camel_ai-0.2.76a3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.76a3.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.76a3.dist-info/RECORD,,