camel-ai 0.2.71a9__py3-none-any.whl → 0.2.71a11__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.71a9'
+__version__ = '0.2.71a11'
 
 __all__ = [
     '__version__',

camel/models/cohere_model.py

@@ -21,7 +21,10 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union
 from pydantic import BaseModel
 
 if TYPE_CHECKING:
-    from cohere.types import ChatMessageV2, ChatResponse
+    from cohere.types import (  # type: ignore[attr-defined]
+        ChatMessageV2,
+        ChatResponse,
+    )
 
 from camel.configs import COHERE_API_PARAMS, CohereConfig
 from camel.messages import OpenAIMessage

camel/models/moonshot_model.py

@@ -29,8 +29,23 @@ from camel.types import (
 from camel.utils import (
     BaseTokenCounter,
     api_keys_required,
+    get_current_agent_session_id,
+    update_langfuse_trace,
 )
 
+if os.environ.get("LANGFUSE_ENABLED", "False").lower() == "true":
+    try:
+        from langfuse.decorators import observe
+    except ImportError:
+        from camel.utils import observe
+elif os.environ.get("TRACEROOT_ENABLED", "False").lower() == "true":
+    try:
+        from traceroot import trace as observe  # type: ignore[import]
+    except ImportError:
+        from camel.utils import observe
+else:
+    from camel.utils import observe
+
 
 class MoonshotModel(OpenAICompatibleModel):
     r"""Moonshot API in a unified OpenAICompatibleModel interface.
@@ -91,13 +106,51 @@ class MoonshotModel(OpenAICompatibleModel):
             **kwargs,
         )
 
+    @observe()
     async def _arun(
         self,
         messages: List[OpenAIMessage],
         response_format: Optional[Type[BaseModel]] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
     ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
-        raise NotImplementedError("Moonshot does not support async inference.")
+        r"""Runs inference of Moonshot chat completion asynchronously.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+
+        # Update Langfuse trace with current agent session and metadata
+        agent_session_id = get_current_agent_session_id()
+        if agent_session_id:
+            update_langfuse_trace(
+                session_id=agent_session_id,
+                metadata={
+                    "agent_id": agent_session_id,
+                    "model_type": str(self.model_type),
+                },
+                tags=["CAMEL-AI", str(self.model_type)],
+            )
+
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

camel/societies/workforce/prompts.py

@@ -196,7 +196,11 @@ Now you should summarize the scenario and return the result of the task.
 """
 )
 
-WF_TASK_DECOMPOSE_PROMPT = r"""You need to decompose the given task into subtasks according to the workers available in the group, following these important principles to maximize efficiency and parallelism:
+TASK_DECOMPOSE_PROMPT = r"""You need to decompose the given task into subtasks according to the workers available in the group, following these important principles to maximize efficiency, parallelism, and clarity for the executing agents:
+
+1.  **Self-Contained Subtasks**: This is critical principle. Each subtask's description **must be fully self-sufficient and independently understandable**. The agent executing the subtask has **no knowledge** of the parent task, other subtasks, or the overall workflow.
+    *   **DO NOT** use relative references like "the first task," "the paper mentioned above," or "the result from the previous step."
+    *   **DO** write explicit instructions. For example, instead of "Analyze the document," write "Analyze the document titled 'The Future of AI'." The system will automatically provide the necessary inputs (like the document itself) from previous steps.
 
 1.  **Strategic Grouping for Sequential Work**:
     *   If a series of steps must be done in order *and* can be handled by the same worker type, group them into a single subtask to maintain flow and minimize handoffs.
@@ -216,23 +220,42 @@ These principles aim to reduce overall completion time by maximizing concurrent
 
 **EXAMPLE FORMAT ONLY** (DO NOT use this example content for actual task decomposition):
 
-If given a hypothetical task requiring research, analysis, and reporting with multiple items to process, you should decompose it to maximize parallelism:
-
-*   Poor decomposition (monolithic):
-    `<tasks><task>Do all research, analysis, and write final report.</task></tasks>`
+***
+**Example 1: Sequential Task for a Single Worker**
 
-*   Better decomposition (parallel structure):
+*   **Overall Task**: "Create a short blog post about the benefits of Python. First, research the key benefits. Then, write a 300-word article. Finally, find a suitable image to go with it."
+*   **Available Workers**:
+    *   `Document Agent`: A worker that can research topics, write articles, and find images.
+*   **Correct Decomposition**:
+    ```xml
+    <tasks>
+    <task>Create a short blog post about the benefits of Python by researching key benefits, writing a 300-word article, and finding a suitable image.</task>
+    </tasks>
     ```
+*   **Reasoning**: All steps are sequential and can be handled by the same worker type (`Document Agent`). Grouping them into one subtask is efficient and maintains the workflow, following the "Strategic Grouping" principle.
+
+***
+**Example 2: Parallel Task Across Different Workers**
+
+*   **Overall Task**: "Write a report on the Q2 performance of Apple (AAPL) and Google (GOOGL). The report needs a financial summary and a market sentiment analysis for each company."
+*   **Available Workers**:
+    *   `financial_analyst_1`: A worker that can analyze financial data and create summaries.
+    *   `market_researcher_1`: A worker that can perform market sentiment analysis.
+    *   `report_writer_1`: A worker that compiles information into a final report.
+*   **Correct Decomposition**:
+    ```xml
     <tasks>
-    <task>Subtask 1 (ResearchAgent): Gather initial data and resources.</task>
-    <task>Subtask 2.1 (AnalysisAgent): Analyze Item A from Subtask 1 results.</task>
-    <task>Subtask 2.2 (AnalysisAgent): Analyze Item B from Subtask 1 results.</task>
-    <task>Subtask 2.N (AnalysisAgent): Analyze Item N from Subtask 1 results.</task>
-    <task>Subtask 3 (ReportAgent): Compile all analyses into final report.</task>
+    <task>Create a financial summary for Apple (AAPL) for Q2.</task>
+    <task>Create a financial summary for Google (GOOGL) for Q2.</task>
+    <task>Perform market sentiment analysis for Apple (AAPL) for Q2.</task>
+    <task>Perform market sentiment analysis for Google (GOOGL) for Q2.</task>
+    <task>Compile the provided financial summaries and market sentiment analyses for Apple (AAPL) and Google (GOOGL) into a single Q2 performance report.</task>
     </tasks>
     ```
+*   **Reasoning**: The financial analysis and market research can be done in parallel for both companies. The final report depends on all previous steps. This decomposition leverages worker specialization and parallelism, following the "Aggressive Parallelization" principle.
+***
 
-**END OF FORMAT EXAMPLE** - Now apply this structure to your actual task below.
+**END OF EXAMPLES** - Now, apply these principles and examples to decompose the following task.
 
 The content of the task is:
 
@@ -261,10 +284,11 @@ You must return the subtasks as a list of individual subtasks within <tasks> tag
 </tasks>
 
 Each subtask should be:
-- Clear and concise
-- Achievable by a single worker
-- Contain all sequential steps that should be performed by the same worker type
-- Only separated from other subtasks when parallel execution by different worker types is beneficial
+- **Self-contained and independently understandable.**
+- Clear and concise.
+- Achievable by a single worker.
+- Containing all sequential steps that should be performed by the same worker type.
+- Written without any relative references (e.g., "the previous task").
 """
 
 FAILURE_ANALYSIS_PROMPT = TextPrompt(

camel/societies/workforce/worker.py

@@ -87,15 +87,9 @@ class Worker(BaseNode, ABC):
                 f"{Fore.YELLOW}{self} get task {task.id}: {task.content}"
                 f"{Fore.RESET}"
             )
-            # Get the Task instance of dependencies
-            dependency_ids = await self._channel.get_dependency_ids()
-            task_dependencies = [
-                await self._channel.get_task_by_id(dep_id)
-                for dep_id in dependency_ids
-            ]
 
             # Process the task
-            task_state = await self._process_task(task, task_dependencies)
+            task_state = await self._process_task(task, [])
 
             # Update the result and status of the task
             task.set_state(task_state)

camel/societies/workforce/workforce.py

@@ -44,7 +44,7 @@ from camel.societies.workforce.prompts import (
     ASSIGN_TASK_PROMPT,
     CREATE_NODE_PROMPT,
     FAILURE_ANALYSIS_PROMPT,
-    WF_TASK_DECOMPOSE_PROMPT,
+    TASK_DECOMPOSE_PROMPT,
 )
 from camel.societies.workforce.role_playing_worker import RolePlayingWorker
 from camel.societies.workforce.single_agent_worker import SingleAgentWorker
@@ -730,7 +730,7 @@ class Workforce(BaseNode):
             Union[List[Task], Generator[List[Task], None, None]]:
             The subtasks or generator of subtasks.
         """
-        decompose_prompt = WF_TASK_DECOMPOSE_PROMPT.format(
+        decompose_prompt = TASK_DECOMPOSE_PROMPT.format(
             content=task.content,
             child_nodes_info=self._get_child_nodes_info(),
             additional_info=task.additional_info,

camel/toolkits/function_tool.py

@@ -256,11 +256,24 @@ def sanitize_and_enforce_required(parameters_dict):
                 # This field is optional - add null to its type
                 current_type = field_schema.get('type')
                 has_ref = '$ref' in field_schema
+                has_any_of = 'anyOf' in field_schema
 
                 if has_ref:
                     # Fields with $ref shouldn't have additional type field
                     # The $ref itself defines the type structure
                     pass
+                elif has_any_of:
+                    # Field already has anyOf
+                    any_of_types = field_schema['anyOf']
+                    has_null_type = any(
+                        item.get('type') == 'null' for item in any_of_types
+                    )
+                    if not has_null_type:
+                        # Add null type to anyOf
+                        field_schema['anyOf'].append({'type': 'null'})
+                    # Remove conflicting type field if it exists
+                    if 'type' in field_schema:
+                        del field_schema['type']
                 elif current_type:
                     if isinstance(current_type, str):
                         # Single type - convert to array with null

camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py

@@ -1094,25 +1094,19 @@ class HybridBrowserToolkit(BaseToolkit):
     # Public API Methods
 
     async def open_browser(self) -> Dict[str, Any]:
-        r"""Launches a new browser session and navigates to the configured
-        default page.
+        r"""Starts a new browser session. This must be the first browser
+        action.
 
-        This method initializes the underlying browser instance and
-        automatically navigates to the default start URL that was configured
-        during toolkit initialization in the first tab. Agents cannot specify
-        a custom URL - they must use the visit_page tool to open new tabs
-        with other URLs.
+        This method initializes the browser and navigates to a default start
+        page. To visit a specific URL, use `visit_page` after this.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A string confirming that the browser session has
-                  started and the default page has been loaded.
-                - "snapshot": A textual representation of the current page's
-                  interactive elements. This snapshot is crucial for
-                  identifying elements for subsequent actions.
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A textual snapshot of interactive elements.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         # Add logging if enabled
         action_start = time.time()
@@ -1163,14 +1157,12 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def close_browser(self) -> str:
-        r"""Closes the current browser session and releases all associated
-        resources.
+        r"""Closes the browser session, releasing all resources.
 
-        This should be called at the end of a web automation task to ensure a
-        clean shutdown of the browser instance.
+        This should be called at the end of a task for cleanup.
 
         Returns:
-            str: A confirmation message indicating the session is closed.
+            str: A confirmation message.
         """
         if self._agent is not None:
             try:
@@ -1184,17 +1176,19 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def visit_page(self, url: str) -> Dict[str, Any]:
-        r"""Navigates to a URL.
-
-        This method creates a new tab for the URL instead of navigating
-        in the current tab, allowing better multi-tab management.
+        r"""Opens a URL in a new browser tab and switches to it.
 
         Args:
-            url (str): The web address to load in the browser.
+            url (str): The web address to load. This should be a valid and
+                existing URL.
 
         Returns:
-            Dict[str, Any]: A dictionary containing the result, snapshot, and
-                tab information.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A textual snapshot of the new page.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the new active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         if not url or not isinstance(url, str):
             return {
@@ -1260,23 +1254,18 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def back(self) -> Dict[str, Any]:
-        r"""Navigates the browser back to the previous page in history.
+        r"""Goes back to the previous page in the browser history.
 
-        This function simulates clicking the browser's back button, taking
-        you to the previously visited page if one exists in the browser
-        history.
+        This action simulates using the browser's "back" button in the
+        currently active tab.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message indicating the outcome of the back
-                  navigation, e.g., "Back navigation successful." or an error
-                  message if no previous page exists.
-                - "snapshot": A new textual snapshot of the page after
-                  navigation. If the snapshot is unchanged, it will be the
-                  string "snapshot not changed".
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A textual snapshot of the previous page.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         page = await self._require_page()
 
@@ -1329,23 +1318,18 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def forward(self) -> Dict[str, Any]:
-        r"""Navigates the browser forward to the next page in history.
+        r"""Goes forward to the next page in the browser history.
 
-        This function simulates clicking the browser's forward button, taking
-        you to the next page in the browser history if one exists (i.e.,
-        if you have previously navigated back).
+        This action simulates using the browser's "forward" button in the
+        currently active tab.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message indicating the outcome of the forward
-                  navigation, e.g., "Forward navigation successful." or an
-                  error message if no next page exists.
-                - "snapshot": A new textual snapshot of the page after
-                  navigation. If the snapshot is unchanged, it will be the
-                  string "snapshot not changed".
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A textual snapshot of the next page.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         page = await self._require_page()
 
@@ -1399,20 +1383,16 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def get_page_snapshot(self) -> str:
-        r"""Captures a textual representation of the current page's content.
+        r"""Gets a textual snapshot of the page's interactive elements.
 
-        This "snapshot" provides a simplified view of the DOM, focusing on
-        interactive elements like links, buttons, and input fields. Each
-        element is assigned a unique reference ID (`ref`) that can be used in
-        other actions like `click` or `type`.
-
-        The snapshot is useful for understanding the page structure and
-        identifying elements to interact with without needing to parse raw
-        HTML. A new snapshot is generated on each call.
+        The snapshot lists elements like buttons, links, and inputs, each with
+        a unique `ref` ID. This ID is used by other tools (e.g., `click`,
+        `type`) to interact with a specific element. This tool provides no
+        visual information.
 
         Returns:
-            str: A formatted string representing the interactive elements on
-                the page. For example:
+            str: A formatted string representing the interactive elements and
+                their `ref` IDs. For example:
                 '- link "Sign In" [ref=1]'
                 '- textbox "Username" [ref=2]'
         """
@@ -1435,32 +1415,25 @@ class HybridBrowserToolkit(BaseToolkit):
     @dependencies_required('PIL')
     @action_logger
     async def get_som_screenshot(self):
-        r"""Captures a screenshot of the current webpage and visually marks all
-        interactive elements. "SoM" stands for "Set of Marks".
-
-        This method is essential for tasks requiring visual understanding of
-        the page layout. It works by:
-        1. Taking a full-page screenshot.
-        2. Identifying all interactive elements (buttons, links, inputs, etc.).
-        3. Drawing colored boxes and reference IDs (`ref`) over these elements
-           on the screenshot.
-        4. Saving the annotated image to a cache directory.
-        5. Returning the image as a base64-encoded string along with a summary.
+        r"""Captures a screenshot with interactive elements highlighted.
 
-        Use this when the textual snapshot from `get_page_snapshot` is
-        insufficient and visual context is needed to decide the next action.
+        "SoM" stands for "Set of Marks". This tool takes a screenshot and draws
+        boxes around clickable elements, overlaying a `ref` ID on each. Use
+        this for a visual understanding of the page, especially when the
+        textual snapshot is not enough.
 
         Returns:
             ToolResult: An object containing:
-                - `text`: A summary string, e.g., "Visual webpage screenshot
+                - `text` (str): A summary, e.g., "Visual webpage screenshot
                   captured with 42 interactive elements".
-                - `images`: A list containing a single base64-encoded PNG image
-                  as a data URL.
+                - `images` (List[str]): A list containing one base64-encoded
+                  PNG image data URL.
         """
         from PIL import Image
 
         from camel.utils.tool_result import ToolResult
 
+        os.makedirs(self._cache_dir, exist_ok=True)
         # Get screenshot and analysis
         page = await self._require_page()
 
@@ -1516,37 +1489,33 @@ class HybridBrowserToolkit(BaseToolkit):
         return ToolResult(text=text_result, images=[img_data_url])
 
     async def click(self, *, ref: str) -> Dict[str, Any]:
-        r"""Clicks on an interactive element on the page.
+        r"""Performs a click on an element on the page.
 
         Args:
-            ref (str): The reference ID of the element to click. This ID is
-                obtained from the page snapshot (see `get_page_snapshot` or
+            ref (str): The `ref` ID of the element to click. This ID is
+                obtained from a page snapshot (`get_page_snapshot` or
                 `get_som_screenshot`).
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message confirming the click action.
-                - "snapshot": A new textual snapshot of the page after the
-                  click, which may have changed as a result of the action. If
-                  the snapshot is unchanged, it will be the string "snapshot
-                  not changed".
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A textual snapshot of the page after the
+                  click.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         self._validate_ref(ref, "click")
 
         analysis = await self._get_unified_analysis()
         elements = analysis.get("elements", {})
         if ref not in elements:
-            available_refs = list(elements.keys())
             logger.error(f"Error: Element reference '{ref}' not found. ")
             # Added snapshot to give more context on failure
             snapshot = self._format_snapshot_from_analysis(analysis)
             tab_info = await self._get_tab_info_for_output()
             return {
-                "result": f"Error: Element reference '{ref}' not found. "
-                f"Available refs: {available_refs}",
+                "result": f"Error: Element reference '{ref}' not found. ",
                 "snapshot": snapshot,
                 **tab_info,
             }
@@ -1564,20 +1533,20 @@ class HybridBrowserToolkit(BaseToolkit):
         return result
 
     async def type(self, *, ref: str, text: str) -> Dict[str, Any]:
-        r"""Types text into an input field, such as a textbox or search bar.
+        r"""Types text into an input element on the page.
 
         Args:
-            ref (str): The reference ID of the input element.
-            text (str): The text to be typed into the element.
+            ref (str): The `ref` ID of the input element, from a snapshot.
+            text (str): The text to type into the element.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message confirming the type action.
-                - "snapshot": A new textual snapshot of the page after the
-                  text has been entered.
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A textual snapshot of the page after
+                  typing.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         self._validate_ref(ref, "type")
         await self._get_unified_analysis()  # Ensure aria-ref attributes
@@ -1592,21 +1561,21 @@ class HybridBrowserToolkit(BaseToolkit):
         return result
 
     async def select(self, *, ref: str, value: str) -> Dict[str, Any]:
-        r"""Selects an option from a dropdown (`<select>`) element.
+        r"""Selects an option in a dropdown (`<select>`) element.
 
         Args:
-            ref (str): The reference ID of the `<select>` element.
-            value (str): The value of the `<option>` to be selected. This
-                should match the `value` attribute of the option, not the
-                visible text.
+            ref (str): The `ref` ID of the `<select>` element.
+            value (str): The `value` attribute of the `<option>` to select,
+                not its visible text.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message confirming the select action.
-                - "snapshot": A new snapshot of the page after the selection.
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A snapshot of the page after the
+                  selection.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         self._validate_ref(ref, "select")
         await self._get_unified_analysis()
@@ -1621,20 +1590,19 @@ class HybridBrowserToolkit(BaseToolkit):
         return result
 
     async def scroll(self, *, direction: str, amount: int) -> Dict[str, Any]:
-        r"""Scrolls the page window up or down by a specified amount.
+        r"""Scrolls the current page window.
 
         Args:
-            direction (str): The direction to scroll. Must be either 'up' or
-                'down'.
+            direction (str): The direction to scroll: 'up' or 'down'.
             amount (int): The number of pixels to scroll.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A confirmation of the scroll action.
-                - "snapshot": A new snapshot of the page after scrolling.
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A snapshot of the page after scrolling.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         if direction not in ("up", "down"):
             tab_info = await self._get_tab_info_for_output()
@@ -1656,25 +1624,17 @@ class HybridBrowserToolkit(BaseToolkit):
     async def enter(self) -> Dict[str, Any]:
         r"""Simulates pressing the Enter key on the currently focused element.
 
-        This tool is used to execute or confirm an action after interacting
-        with
-        an element, such as:
-        - Submitting a search query after typing in a search box.
-        - Confirming a form submission.
-        - Executing a command in a text input field.
-
-        The common usage pattern is to first use the 'type' tool to input
-        text, which sets the focus, and then call 'enter' without any
-        parameters to trigger the action.
+        This is useful for submitting forms or search queries after using the
+        `type` tool.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A confirmation of the Enter key action.
-                - "snapshot": A new page snapshot, as this action often
-                  triggers navigation or page updates.
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A new page snapshot, as this action often
+                  triggers navigation.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         # Always press Enter on the currently focused element
         action = {"type": "enter"}
@@ -1691,25 +1651,22 @@ class HybridBrowserToolkit(BaseToolkit):
     async def wait_user(
         self, timeout_sec: Optional[float] = None
     ) -> Dict[str, Any]:
-        r"""Pauses the agent's execution and waits for human intervention.
+        r"""Pauses execution and waits for human input from the console.
 
-        This is useful for tasks that require manual steps, like solving a
-        CAPTCHA. The agent will print a message to the console and wait
-        until the user presses the Enter key.
+        Use this for tasks requiring manual steps, like solving a CAPTCHA. The
+        agent will resume after the user presses Enter in the console.
 
         Args:
-            timeout_sec (Optional[float]): The maximum time to wait in
-                seconds. If the timeout is reached, the agent will resume
-                automatically. If `None`, it will wait indefinitely.
+            timeout_sec (Optional[float]): Max time to wait in seconds. If
+                `None`, it will wait indefinitely.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message indicating how the wait ended (e.g.,
-                  "User resumed." or "Timeout... reached, auto-resumed.").
-                - "snapshot": The current page snapshot after the wait.
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): A message indicating how the wait ended.
+                - "snapshot" (str): The page snapshot after the wait.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         import asyncio
 
@@ -1756,20 +1713,18 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def get_page_links(self, *, ref: List[str]) -> Dict[str, Any]:
-        r"""Retrieves the full URLs for a given list of link reference IDs.
+        r"""Gets the destination URLs for a list of link elements.
 
-        This is useful when you need to know the destination of a link before
-        clicking it.
+        This is useful to know where a link goes before clicking it.
 
         Args:
-            ref (List[str]): A list of reference IDs for link elements,
-                obtained from a page snapshot.
+            ref (List[str]): A list of `ref` IDs for link elements, obtained
+                from a page snapshot.
 
         Returns:
             Dict[str, Any]: A dictionary containing:
-                - "links": A list of dictionaries, where each dictionary
-                  represents a found link and has "text", "ref", and "url"
-                  keys.
+                - "links" (List[Dict]): A list of found links, where each
+                  link has "text", "ref", and "url" keys.
         """
         if not ref or not isinstance(ref, list):
             return {"links": []}
@@ -1790,26 +1745,25 @@ class HybridBrowserToolkit(BaseToolkit):
     async def solve_task(
         self, task_prompt: str, start_url: str, max_steps: int = 15
     ) -> str:
-        r"""Uses a high-level LLM agent to autonomously complete a task.
+        r"""Delegates a complex, high-level task to a specialized web agent.
 
-        This function delegates control to another agent that can reason about
-        a task, break it down into steps, and execute browser actions to
-        achieve the goal. It is suitable for complex, multi-step tasks.
+        Use this for multi-step tasks that can be described in a single prompt
+        (e.g., "log into my account and check for new messages"). The agent
+        will autonomously perform the necessary browser actions.
 
-        Note: `web_agent_model` must be provided during the toolkit's
-        initialization to use this function.
+        NOTE: This is a high-level action; for simple interactions, use tools
+        like `click` and `type`. `web_agent_model` must be provided during
+        toolkit initialization.
 
         Args:
-            task_prompt (str): A natural language description of the task to
-                be completed (e.g., "log into my account on example.com").
-            start_url (str): The URL to start the task from.
-            max_steps (int): The maximum number of steps the agent is allowed
-                to take before stopping.
+            task_prompt (str): A natural language description of the task.
+            start_url (str): The URL to start the task from. This should be a
+                valid and existing URL, as agents may generate non-existent
+                ones.
+            max_steps (int): The maximum number of steps the agent can take.
 
         Returns:
-            str: A summary message indicating that the task processing has
-                finished. The detailed trace of the agent's actions will be
-                printed to the standard output.
+            str: A summary message indicating the task has finished.
         """
         agent = self._ensure_agent()
         await agent.navigate(start_url)
@@ -1944,25 +1898,21 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def switch_tab(self, *, tab_index: int) -> Dict[str, Any]:
-        r"""Switches to a specific browser tab by its index.
+        r"""Switches to a different browser tab using its index.
 
-        This allows you to control which tab is currently active. After
-        switching, all subsequent browser actions will operate on the newly
-        selected tab.
+        After switching, all actions will apply to the new tab. Use
+        `get_tab_info` to find the index of the tab you want to switch to.
 
         Args:
-            tab_index (int): The zero-based index of the tab to switch to.
-                Use `get_tab_info` to see available tabs and their indices.
+            tab_index (int): The zero-based index of the tab to activate.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message indicating success or failure of the
-                  tab switch.
-                - "snapshot": A textual snapshot of the newly active tab's
-                  content.
-                - "tabs": List of all open tabs with their information.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A snapshot of the newly active tab.
+                - "tabs" (List[Dict]): Information about all open tabs.
+                - "current_tab" (int): Index of the new active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         await self._ensure_browser()
         session = await self._get_session()
@@ -1993,24 +1943,21 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def close_tab(self, *, tab_index: int) -> Dict[str, Any]:
-        r"""Closes a specific browser tab by its index.
+        r"""Closes a browser tab using its index.
 
-        After closing a tab, the browser will automatically switch to another
-        available tab. If the closed tab was the only one open, the browser
-        session will remain active but without any pages.
+        Use `get_tab_info` to find the index of the tab to close. After
+        closing, the browser will switch to another tab if available.
 
         Args:
             tab_index (int): The zero-based index of the tab to close.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "result": A message indicating success or failure of the
-                  tab closure.
-                - "snapshot": A textual snapshot of the currently active tab
-                  after the closure (empty if no tabs remain).
-                - "tabs": List of remaining open tabs.
-                - "current_tab": Index of the currently active tab.
-                - "total_tabs": Total number of remaining open tabs.
+            Dict[str, Any]: A dictionary with the result of the action:
+                - "result" (str): Confirmation of the action.
+                - "snapshot" (str): A snapshot of the active tab after closure.
+                - "tabs" (List[Dict]): Information about remaining tabs.
+                - "current_tab" (int): Index of the new active tab.
+                - "total_tabs" (int): Total number of remaining tabs.
         """
         await self._ensure_browser()
         session = await self._get_session()
@@ -2046,20 +1993,20 @@ class HybridBrowserToolkit(BaseToolkit):
 
     @action_logger
     async def get_tab_info(self) -> Dict[str, Any]:
-        r"""Retrieves information about all currently open browser tabs.
+        r"""Gets a list of all open browser tabs and their information.
 
-        This provides a comprehensive overview of the browser state, including
-        all open tabs, their titles, URLs, and which one is currently active.
+        This includes each tab's index, title, and URL, and indicates which
+        tab is currently active. Use this to manage multiple tabs.
 
         Returns:
-            Dict[str, Any]: A dictionary containing:
-                - "tabs": A list of dictionaries, each representing a tab with:
-                  - "index": The zero-based index of the tab
-                  - "title": The page title
-                  - "url": The current URL
-                  - "is_current": Whether this is the currently active tab
-                - "current_tab": Index of the currently active tab
-                - "total_tabs": Total number of open tabs
+            Dict[str, Any]: A dictionary with tab information:
+                - "tabs" (List[Dict]): A list of open tabs, each with:
+                  - "index" (int): The tab's zero-based index.
+                  - "title" (str): The page title.
+                  - "url" (str): The current URL.
+                  - "is_current" (bool): True if the tab is active.
+                - "current_tab" (int): Index of the active tab.
+                - "total_tabs" (int): Total number of open tabs.
         """
         await self._ensure_browser()
         return await self._get_tab_info_for_output()

camel/toolkits/hybrid_browser_toolkit/unified_analyzer.js

@@ -735,11 +735,11 @@
     function renderTree(node, indent = '') {
         const lines = [];
         let meaningfulProps = '';
-        if (node.disabled) meaningfulProps += ' disabled';
-        if (node.occluded) meaningfulProps += ' occluded';
+        if (node.disabled) meaningfulProps += ' [disabled]';
+        if (node.occluded) meaningfulProps += ' [occluded]';
         if (node.checked !== undefined) meaningfulProps += ` checked=${node.checked}`;
         if (node.expanded !== undefined) meaningfulProps += ` expanded=${node.expanded}`;
-        if (node.selected) meaningfulProps += ' selected';
+        if (node.selected) meaningfulProps += ' [selected]';
 
         // Add level attribute following Playwright's format
         if (node.level !== undefined) meaningfulProps += ` [level=${node.level}]`;

camel/toolkits/search_toolkit.py

@@ -89,8 +89,8 @@ class SearchToolkit(BaseToolkit):
             depth (Literal["standard", "deep"]): The depth of the search.
                 "standard" for a straightforward search, "deep" for a more
                 comprehensive search.
-            output_type (Literal["searchResults", "sourcedAnswer",
-                "structured"]): The type of output:
+            output_type (Literal["searchResults", "sourcedAnswer", "structured"]):
+                The type of output:
                 - "searchResults" for raw search results,
                 - "sourcedAnswer" for an answer with supporting sources,
                 - "structured" for output based on a provided schema.
@@ -265,13 +265,18 @@ class SearchToolkit(BaseToolkit):
                 The country string is limited to 2 character country codes of
                 supported countries. For a list of supported values, see
                 Country Codes. (default: :obj:`US `)
-            search_lang (str): The search language preference. The 2 or more
-                character language code for which search results are provided.
-                For a list of possible values, see Language Codes.
+            search_lang (str): The search language preference.
+                Use ONLY these exact values, NOT standard ISO codes:
+                'ar', 'eu', 'bn', 'bg', 'ca', 'zh-hans', 'zh-hant', 'hr',
+                'cs', 'da', 'nl', 'en', 'en-gb', 'et', 'fi', 'fr', 'gl', 'de',
+                'gu', 'he', 'hi', 'hu', 'is', 'it', 'jp', 'kn', 'ko', 'lv',
+                'lt', 'ms', 'ml', 'mr', 'nb', 'pl', 'pt-br', 'pt-pt', 'pa',
+                'ro', 'ru', 'sr', 'sk', 'sl', 'es', 'sv', 'ta', 'te', 'th',
+                'tr', 'uk', 'vi'.
             ui_lang (str): User interface language preferred in response.
-                Usually of the format '<language_code>-<country_code>'. For
-                more, see RFC 9110. For a list of supported values, see UI
-                Language Codes.
+                Format: '<language_code>-<country_code>'. Common examples:
+                'en-US', 'en-GB', 'jp-JP', 'zh-hans-CN', 'zh-hant-TW',
+                'de-DE', 'fr-FR', 'es-ES', 'pt-BR', 'ru-RU', 'ko-KR'.
             count (int): The number of search results returned in response.
                 The maximum is 20. The actual number delivered may be less than
                 requested. Combine this parameter with offset to paginate
@@ -375,10 +380,36 @@ class SearchToolkit(BaseToolkit):
             "extra_snippets": extra_snippets,
             "summary": summary,
         }
+        params = {k: v for k, v in params.items() if v is not None}
 
         response = requests.get(url, headers=headers, params=params)
-        data = response.json()["web"]
-        return data
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as e:
+            raise RuntimeError(
+                f"Brave API HTTP error: {e}, body={response.text!r}"
+            )
+
+        json_data = response.json()
+        # Check if response has search results
+        content_keys = [
+            'web',
+            'news',
+            'videos',
+            'images',
+            'locations',
+            'discussions',
+            'faq',
+            'infobox',
+        ]
+        has_results = any(key in json_data for key in content_keys)
+
+        if not has_results:
+            # Return empty results structure if no content found
+            json_data['web'] = {'results': []}
+            json_data['message'] = 'No search results found for the query'
+
+        return json_data
 
     @api_keys_required(
         [
@@ -941,11 +972,10 @@ class SearchToolkit(BaseToolkit):
 
         Args:
             query (str): The search query string (length >= 1 and <= 100).
-            time_range (Literal["OneDay", "OneWeek", "OneMonth", "OneYear",
-                "NoLimit"]): Time frame filter for search results.
+            time_range (Literal["OneDay", "OneWeek", "OneMonth", "OneYear", "NoLimit"]):
+                Time frame filter for search results.
                 (default: :obj:`"NoLimit"`)
-            industry (Optional[Literal["finance", "law", "medical",
-                "internet", "tax", "news_province", "news_center"]]):
+            industry (Optional[Literal["finance", "law", "medical", "internet", "tax", "news_province", "news_center"]]):
                 Industry-specific search filter. When specified, only returns
                 results from sites in the specified industries. Multiple
                 industries can be comma-separated.

camel/toolkits/slack_toolkit.py

@@ -239,6 +239,7 @@ class SlackToolkit(BaseToolkit):
         self,
         message: str,
         channel_id: str,
+        file_path: Optional[str] = None,
         user: Optional[str] = None,
     ) -> str:
         r"""Send a message to a Slack channel.
@@ -246,6 +247,8 @@ class SlackToolkit(BaseToolkit):
         Args:
             message (str): The message to send.
             channel_id (str): The ID of the Slack channel to send message.
+            file_path (Optional[str]): The path of the file to send.
+                Defaults to `None`.
             user (Optional[str]): The user ID of the recipient.
                 Defaults to `None`.
 
@@ -257,6 +260,13 @@ class SlackToolkit(BaseToolkit):
 
         try:
             slack_client = self._login_slack()
+            if file_path:
+                response = slack_client.files_upload_v2(
+                    channel=channel_id,
+                    file=file_path,
+                    initial_comment=message,
+                )
+                return f"File sent successfully, got response: {response}"
             if user:
                 response = slack_client.chat_postEphemeral(
                     channel=channel_id, text=message, user=user

camel/types/enums.py

@@ -270,6 +270,7 @@ class ModelType(UnifiedModelType, Enum):
     MOONSHOT_V1_8K = "moonshot-v1-8k"
     MOONSHOT_V1_32K = "moonshot-v1-32k"
     MOONSHOT_V1_128K = "moonshot-v1-128k"
+    MOONSHOT_KIMI_K2 = "kimi-k2-0711-preview"
 
     # SiliconFlow models support tool calling
     SILICONFLOW_DEEPSEEK_V2_5 = "deepseek-ai/DeepSeek-V2.5"
@@ -833,6 +834,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MOONSHOT_V1_8K,
             ModelType.MOONSHOT_V1_32K,
             ModelType.MOONSHOT_V1_128K,
+            ModelType.MOONSHOT_KIMI_K2,
         }
 
     @property
@@ -1205,6 +1207,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.MISTRAL_MEDIUM_3,
             ModelType.ERNIE_4_5_TURBO_128K,
             ModelType.DEEPSEEK_V3,
+            ModelType.MOONSHOT_KIMI_K2,
         }:
             return 128_000
         elif self in {

{camel_ai-0.2.71a9.dist-info → camel_ai-0.2.71a11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.71a9
+Version: 0.2.71a11
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -127,7 +127,7 @@ Requires-Dist: sympy<2,>=1.13.3; extra == 'all'
 Requires-Dist: tabulate>=0.9.0; extra == 'all'
 Requires-Dist: tavily-python<0.6,>=0.5.0; extra == 'all'
 Requires-Dist: textblob<0.18,>=0.17.1; extra == 'all'
-Requires-Dist: traceroot==0.0.3a2; extra == 'all'
+Requires-Dist: traceroot==0.0.3; extra == 'all'
 Requires-Dist: transformers<5,>=4; extra == 'all'
 Requires-Dist: tree-sitter-python<0.24,>=0.23.6; extra == 'all'
 Requires-Dist: tree-sitter<0.24,>=0.23.2; extra == 'all'
@@ -191,7 +191,7 @@ Requires-Dist: ipykernel<7,>=6.0.0; extra == 'dev-tools'
 Requires-Dist: jupyter-client<9,>=8.6.2; extra == 'dev-tools'
 Requires-Dist: langfuse>=2.60.5; extra == 'dev-tools'
 Requires-Dist: mcp>=1.3.0; extra == 'dev-tools'
-Requires-Dist: traceroot==0.0.3a2; extra == 'dev-tools'
+Requires-Dist: traceroot==0.0.3; extra == 'dev-tools'
 Requires-Dist: tree-sitter-python<0.24,>=0.23.6; extra == 'dev-tools'
 Requires-Dist: tree-sitter<0.24,>=0.23.2; extra == 'dev-tools'
 Requires-Dist: typer>=0.15.2; extra == 'dev-tools'

{camel_ai-0.2.71a9.dist-info → camel_ai-0.2.71a11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-camel/__init__.py,sha256=5n7NZMAxb749oqgkyLbTX4gLlHYBd4c8HTvC0fzotXg,901
+camel/__init__.py,sha256=0_Amq6sz_Pgv__ZMtKiptsrQ5gIku0jlCc0G6Bc1qac,902
 camel/generators.py,sha256=JRqj9_m1PF4qT6UtybzTQ-KBT9MJQt18OAAYvQ_fr2o,13844
 camel/human.py,sha256=Xg8x1cS5KK4bQ1SDByiHZnzsRpvRP-KZViNvmu38xo4,5475
 camel/logger.py,sha256=WgEwael_eT6D-lVAKHpKIpwXSTjvLbny5jbV1Ab8lnA,5760
@@ -180,7 +180,7 @@ camel/models/aws_bedrock_model.py,sha256=bcQBiHVdVuJXyPEkSdymQlGx2zHIVj5d4ouFuF8
 camel/models/azure_openai_model.py,sha256=-hnzGlV8NJAzR9wVfhe-YDazbGU43ECtw6_uFICKnPU,18393
 camel/models/base_audio_model.py,sha256=_VUWh1L3rh8mldNvM5R6jBOKtvmTeBKJyRxAdPJmPlY,3324
 camel/models/base_model.py,sha256=NouoYjMPo2K6KmKCIeU7smyEFnDkqnLL71Dh9SyJoa4,19486
-camel/models/cohere_model.py,sha256=V1sL8JpaOAVYOi5hAIXWdEex0Mr36_kx4-BEACQfN5o,17237
+camel/models/cohere_model.py,sha256=6KvYnYxoBZ8kLMmRp5wcJisY65KhCTl6kiG1W3xOkJQ,17292
 camel/models/crynux_model.py,sha256=leEiFz1RcRtVJLJvYt_Ydyg5jkSk3VEJphgmHFz67bw,4118
 camel/models/deepseek_model.py,sha256=MXOdmpFQFbxpgh5DiTETzx3qDFUkKiFjnEjTMDeWk2k,11015
 camel/models/fish_audio_model.py,sha256=RCwORRIdCbjZXWWjjctpksPI2DnS0b68JjxunHBQ1xk,5981
@@ -193,7 +193,7 @@ camel/models/mistral_model.py,sha256=ipOVPk2boGqyGAypgKeQ9syaP0znKFQQSOqeVtockjk
 camel/models/model_factory.py,sha256=8b-LEXovPnpmD3GFKOdbtcgjCwpa91IPCJxikPxhdMs,12114
 camel/models/model_manager.py,sha256=ln3bCV_QWM3V5BrwKwjmxIeRN8ojIvPEBMMHun0MliU,9942
 camel/models/modelscope_model.py,sha256=meO7KCAwZtHpUVgwtuKe0j4jYh0IWsxa8e3mwyhGLvg,10804
-camel/models/moonshot_model.py,sha256=ulZYikMe65wFZ-xyo6QMmn1q4vhsodyFjMBOmZu01Xw,4622
+camel/models/moonshot_model.py,sha256=BNkKcEPMieMZwClRT4w-D4crZ5Ovs8tLdK5Kxm41hWg,6465
 camel/models/nemotron_model.py,sha256=PzRuQoAEmBRZ2wcotQ8-MRz5wYachKa_CUNenMQg-3U,3091
 camel/models/netmind_model.py,sha256=YKHfntqsKqBxfh6qryn4L7CzHOIAYtyPXwJNK6NxNi4,4276
 camel/models/novita_model.py,sha256=V-g0Wrf1Zh1il6oPKh1LVy_U0nveOwJq9YBVzGp4GOI,4238
@@ -273,14 +273,14 @@ camel/societies/babyagi_playing.py,sha256=KbTdpHfZ2V8AripVck0bNTOyF-RSaMPCRARz3D
 camel/societies/role_playing.py,sha256=0XScr3WfxX1QOC71RhBLmrcS5y2c7DMQB_mAFOHU34M,31421
 camel/societies/workforce/__init__.py,sha256=bkTI-PE-MSK9AQ2V2gR6cR2WY-R7Jqy_NmXRtAoqo8o,920
 camel/societies/workforce/base.py,sha256=z2DmbTP5LL5-aCAAqglznQqCLfPmnyM5zD3w6jjtsb8,2175
-camel/societies/workforce/prompts.py,sha256=gobVelz7rRdReogFG2QCfFy21GfhaQJyoiNnKWo4EHE,14391
+camel/societies/workforce/prompts.py,sha256=AxsznORYV6E31Hcf6CcDbuV4iuUY7EFsu9MTV42P144,16517
 camel/societies/workforce/role_playing_worker.py,sha256=z5-OcNiaNEaoC206_3HD7xeonuUkD-XTxYbD3AqoNC8,10319
 camel/societies/workforce/single_agent_worker.py,sha256=fXgAEkDMhvTd-nbwy5Gw3BOaRAiPsL8mf3AW1aaNqKU,19342
 camel/societies/workforce/structured_output_handler.py,sha256=xr8szFN86hg3jQ825aEkJTjkSFQnTlbinVg4j1vZJVI,17870
 camel/societies/workforce/task_channel.py,sha256=GWHaGQBpjTzdKbWoBYAQzzAiLKRKRXa6beqtc4cg-Is,7611
 camel/societies/workforce/utils.py,sha256=THgNHSeZsNVnjTzQTur3qCJhi72MrDS8X2gPET174cI,8434
-camel/societies/workforce/worker.py,sha256=k_AokiF-HAfq6Cd5SQYb0uaoJsA_kSwV_n5o1fxvzmo,6522
-camel/societies/workforce/workforce.py,sha256=HD9Q5U4hqtTYewNWbYxa7u6ojW6lyGX_o_K7alm4S6E,138306
+camel/societies/workforce/worker.py,sha256=wImTK95gXBfnfzEaInUKJyyRSPlHJUyV9dONjofbVu8,6233
+camel/societies/workforce/workforce.py,sha256=yiKEULgeNl5Red3LGhDZzY63tFZpcEkCKFivVKTfIKg,138300
 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
@@ -333,7 +333,7 @@ camel/toolkits/data_commons_toolkit.py,sha256=aHZUSL1ACpnYGaf1rE2csVKTmXTmN8lMGR
 camel/toolkits/edgeone_pages_mcp_toolkit.py,sha256=1TFpAGHUNLggFQeN1OEw7P5laijwnlrCkfxBtgxFuUY,2331
 camel/toolkits/excel_toolkit.py,sha256=9Uk5GLWl719c4W-NcGPJTNMtodAbEE5gUgLsFkIInbk,32564
 camel/toolkits/file_write_toolkit.py,sha256=d8N8FfmK1fS13sY58PPhJh6M0vq6yh-s1-ltCZQJObg,37044
-camel/toolkits/function_tool.py,sha256=xCDzjxTRCVj_kmbnMFBuwK-3NuzM4JNe_kv9HLtjnIA,33644
+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
 camel/toolkits/google_drive_mcp_toolkit.py,sha256=NubrRdPV8_t8bM4vP-7eKSVMuVwSEBXLfubWR_Hba7k,2583
@@ -366,10 +366,10 @@ camel/toolkits/pulse_mcp_search_toolkit.py,sha256=uLUpm19uC_4xLJow0gGVS9f-5T5EW2
 camel/toolkits/pyautogui_toolkit.py,sha256=Q810fm8cFvElRory7B74aqS2YV6BOpdRE6jkewoM8xc,16093
 camel/toolkits/reddit_toolkit.py,sha256=x0XAT1zQJVNHUr1R1HwWCgIlkamU-kPmbfb_H1WIv-w,8036
 camel/toolkits/retrieval_toolkit.py,sha256=BKjEyOqW3cGEPTS5yHPYb-Qg795iNNPIs1wjowfuq3U,3825
-camel/toolkits/search_toolkit.py,sha256=hqiqF8QJVaghQv36ra36SFzpjZkw7aJWsnMfGYaH_CQ,43996
+camel/toolkits/search_toolkit.py,sha256=qt-g6c563p2pw0I8arXY3K45nvzu8QSKOBRMghdltuI,45161
 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=4Bj8P2ardLwfiyUz3ha5QobSvziV54E9zipysCg9GuI,11208
+camel/toolkits/slack_toolkit.py,sha256=ZT6Ndlce2qjGsyZaNMfQ54nSEi7DOC9Ro7YqtK-u5O4,11651
 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
@@ -387,10 +387,10 @@ camel/toolkits/hybrid_browser_toolkit/actions.py,sha256=x6X-kEdQx3K1ID-BBwdQEciX
 camel/toolkits/hybrid_browser_toolkit/agent.py,sha256=0ifwhYUDJ5GLxfdpC5KquPaW1a0QBAutp2Y9y0YFujw,11685
 camel/toolkits/hybrid_browser_toolkit/browser_session.py,sha256=LdXjF4eBFuqoRnbPU0ErBtR5wtbcv3cv-hBXtiDkgMg,27102
 camel/toolkits/hybrid_browser_toolkit/config_loader.py,sha256=0zpDq3aFKEva2jc38kgLHnyxypIDk9SOcMjoP26tozo,15414
-camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py,sha256=Mfr0-1FFCfY9cgzQ5JHD4vimh0Nbu203nwmad3RDwiU,80391
+camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py,sha256=5rrwj7H3qKoSUaDBPozWxcGqbdCInUrhhDTPZ6O7ZBU,77550
 camel/toolkits/hybrid_browser_toolkit/snapshot.py,sha256=3vQaFK5C1P8WnkK2eDMaFOizrZf4uUAW0LxdeoF4F2w,8539
 camel/toolkits/hybrid_browser_toolkit/stealth_script.js,sha256=z4XRSVUpAS87Sj36s3bY8XXhvRcHBlgsUOyMxV2HI80,27650
-camel/toolkits/hybrid_browser_toolkit/unified_analyzer.js,sha256=wVZfG-c6NqqtZnz97yyklvQsqCEeUPLH3XnvgURhIV4,40817
+camel/toolkits/hybrid_browser_toolkit/unified_analyzer.js,sha256=VnzIn0KcEtxuncJi-OPZzdWbLSeSHCH-7sviFAGNM8g,40823
 camel/toolkits/open_api_specs/security_config.py,sha256=ZVnBa_zEifaE_ao2xsvV5majuJHpn2Tn7feMDOnj-eo,898
 camel/toolkits/open_api_specs/biztoc/__init__.py,sha256=OKCZrQCDwaWtXIN_2rA9FSqEvgpQRieRoHh7Ek6N16A,702
 camel/toolkits/open_api_specs/biztoc/ai-plugin.json,sha256=IJinQbLv5MFPGFwdN7PbOhwArFVExSEZdJspe-mOBIo,866
@@ -417,7 +417,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=tUTwrEj5-R6EEXxclxiMkrThLL4SotpYX3saXQI01vo,62822
+camel/types/enums.py,sha256=qEPE2r4Np7JgJqSsZmM0SNQ8_hy19aeCn5da3pK93so,62948
 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=ZweHiS4MQ1QbDEX3a3oUc-pvgueYP27Zt0SlAPcYg_4,5623
@@ -446,7 +446,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.71a9.dist-info/METADATA,sha256=3IG3o0Zfp79IqN8Y6I6N5jJsjw0-A9A_gqwDszF8qLw,50002
-camel_ai-0.2.71a9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-camel_ai-0.2.71a9.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
-camel_ai-0.2.71a9.dist-info/RECORD,,
+camel_ai-0.2.71a11.dist-info/METADATA,sha256=n_79KNQG4fYZKxJoJxX6E9J1CyXY3pny6PpBLnOZ9lk,49999
+camel_ai-0.2.71a11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+camel_ai-0.2.71a11.dist-info/licenses/LICENSE,sha256=id0nB2my5kG0xXeimIu5zZrbHLS6EQvxvkKkzIHaT2k,11343
+camel_ai-0.2.71a11.dist-info/RECORD,,