camel-ai 0.2.69a4__py3-none-any.whl → 0.2.69a7__py3-none-any.whl

camel/toolkits/google_drive_mcp_toolkit.py

@@ -0,0 +1,73 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import List, Optional
+
+from camel.toolkits import BaseToolkit, FunctionTool
+
+from .mcp_toolkit import MCPToolkit
+
+
+class GoogleDriveMCPToolkit(BaseToolkit):
+    r"""GoogleDriveMCPToolkit provides an interface for interacting with
+    Google Drive using the Google Drive MCP server.
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+        credentials_path: Optional[str] = None,
+    ) -> None:
+        r"""Initializes the GoogleDriveMCPToolkit.
+
+        Args:
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+            credentials_path (Optional[str]): Path to the Google Drive
+                credentials file. (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
+        self._mcp_toolkit = MCPToolkit(
+            config_dict={
+                "mcpServers": {
+                    "gdrive": {
+                        "command": "npx",
+                        "args": ["-y", "@modelcontextprotocol/server-gdrive"],
+                        "env": {"GDRIVE_CREDENTIALS_PATH": credentials_path},
+                    }
+                }
+            },
+            timeout=timeout,
+        )
+
+    async def connect(self):
+        r"""Explicitly connect to the Google Drive MCP server."""
+        await self._mcp_toolkit.connect()
+
+    async def disconnect(self):
+        r"""Explicitly disconnect from the Google Drive MCP server."""
+        await self._mcp_toolkit.disconnect()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of tools provided by the GoogleDriveMCPToolkit.
+
+        Returns:
+            List[FunctionTool]: List of available tools.
+        """
+        return self._mcp_toolkit.get_tools()

camel/toolkits/markitdown_toolkit.py

@@ -0,0 +1,78 @@
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+from typing import Dict, List, Optional
+
+from camel.loaders.markitdown import MarkItDownLoader
+from camel.logger import get_logger
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+from camel.utils import MCPServer
+
+logger = get_logger(__name__)
+
+
+@MCPServer()
+class MarkItDownToolkit(BaseToolkit):
+    r"""A class representing a toolkit for MarkItDown."""
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        super().__init__(timeout=timeout)
+
+    def load_files(self, file_paths: List[str]) -> Dict[str, str]:
+        r"""Scrapes content from a list of files and converts it to Markdown.
+
+        This function takes a list of local file paths, attempts to convert
+        each file into Markdown format, and returns the converted content.
+        The conversion is performed in parallel for efficiency.
+
+        Supported file formats include:
+        - PDF (.pdf)
+        - Microsoft Office: Word (.doc, .docx), Excel (.xls, .xlsx),
+          PowerPoint (.ppt, .pptx)
+        - EPUB (.epub)
+        - HTML (.html, .htm)
+        - Images (.jpg, .jpeg, .png) for OCR
+        - Audio (.mp3, .wav) for transcription
+        - Text-based formats (.csv, .json, .xml, .txt)
+        - ZIP archives (.zip)
+
+        Args:
+            file_paths (List[str]): A list of local file paths to be
+                converted.
+
+        Returns:
+            Dict[str, str]: A dictionary where keys are the input file paths
+                and values are the corresponding content in Markdown format.
+                If conversion of a file fails, the value will contain an
+                error message.
+        """
+        return MarkItDownLoader().convert_files(
+            file_paths=file_paths, parallel=True
+        )
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects
+                representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.load_files),
+        ]

camel/toolkits/mcp_toolkit.py

@@ -457,7 +457,37 @@ class MCPToolkit(BaseToolkit):
         try:
             schema = tool.get_openai_tool_schema()
 
-            # Check if the tool already has strict mode enabled
+            # Check if any object in the schema has additionalProperties: true
+            def _has_additional_properties_true(obj):
+                r"""Recursively check if any object has additionalProperties: true"""  # noqa: E501
+                if isinstance(obj, dict):
+                    if obj.get("additionalProperties") is True:
+                        return True
+                    for value in obj.values():
+                        if _has_additional_properties_true(value):
+                            return True
+                elif isinstance(obj, list):
+                    for item in obj:
+                        if _has_additional_properties_true(item):
+                            return True
+                return False
+
+            # FIRST: Check if the schema contains additionalProperties: true
+            # This must be checked before strict mode validation
+            if _has_additional_properties_true(schema):
+                # Force strict mode to False and log warning
+                if "function" in schema:
+                    schema["function"]["strict"] = False
+                tool.set_openai_tool_schema(schema)
+                logger.warning(
+                    f"Tool '{tool.get_function_name()}' contains "
+                    f"additionalProperties: true which is incompatible with "
+                    f"OpenAI strict mode. Setting strict=False for this tool."
+                )
+                return tool
+
+            # SECOND: Check if the tool already has strict mode enabled
+            # Only do this if there are no additionalProperties conflicts
             if schema.get("function", {}).get("strict") is True:
                 return tool
 

camel/toolkits/non_visual_browser_toolkit/browser_non_visual_toolkit.py

@@ -115,16 +115,19 @@ class BrowserNonVisualToolkit(BaseToolkit):
     async def open_browser(
         self, start_url: Optional[str] = None
     ) -> Dict[str, str]:
-        r"""Launch a Playwright browser session.
+        r"""Launches a new browser session. This should be the first step.
 
         Args:
-            start_url (Optional[str]): Optional URL to navigate to immediately
-                after the browser launches. If not provided, the browser will
-                not navigate to any URL. (default: :obj:`None`)
+            start_url (Optional[str]): The URL to navigate to after the browser
+                launches. If not provided, the browser will open with a blank
+                page. (default: :obj:`None`)
 
         Returns:
-            Dict[str, str]: Keys: ``result`` for action outcome,
-                ``snapshot`` for full DOM snapshot.
+            Dict[str, str]: A dictionary containing the result of the action
+                and a snapshot of the page. The keys are "result" and
+                "snapshot". The "snapshot" is a YAML-like representation of
+                the page's DOM structure, including element references
+                (e.g., "e3") that can be used in other tool calls.
         """
         await self._session.ensure_browser()
         if start_url:
@@ -136,10 +139,12 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return {"result": "Browser session started.", "snapshot": snapshot}
 
     async def close_browser(self) -> str:
-        r"""Terminate the current browser session and free all resources.
+        r"""Closes the current browser session, freeing up all associated
+        resources. This should be called when the browsing task is complete.
 
         Returns:
-            str: Confirmation message.
+            str: A confirmation message indicating the session has been
+                closed.
         """
         # Close agent if it exists
         if self._agent is not None:
@@ -154,14 +159,17 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return "Browser session closed."
 
     async def visit_page(self, url: str) -> Dict[str, str]:
-        r"""Navigate the current page to the specified URL.
+        r"""Navigates the current browser page to a new URL.
 
         Args:
-            url (str): The destination URL.
+            url (str): The URL to navigate to. Must be a fully qualified URL
+                (e.g., "https://www.google.com").
 
         Returns:
-            Dict[str, str]: Keys: ``result`` for action outcome,
-                ``snapshot`` for full DOM snapshot.
+            Dict[str, str]: A dictionary containing the navigation result and a
+                snapshot of the new page. The keys are "result" and
+                "snapshot". The "snapshot" provides a fresh view of the
+                page's DOM structure.
         """
         if not url or not isinstance(url, str):
             raise ValueError("visit_page(): 'url' must be a non-empty string")
@@ -192,14 +200,16 @@ class BrowserNonVisualToolkit(BaseToolkit):
         )
 
     async def click(self, *, ref: str) -> Dict[str, str]:
-        r"""Click an element identified by ``ref``
+        r"""Performs a click action on a specified element on the current page.
 
         Args:
-            ref (str): Element reference ID extracted from snapshot
-                (e.g.``"e3"``).
+            ref (str): The reference ID of the element to click. This ID is
+                obtained from the page snapshot (e.g., "e12").
 
         Returns:
-            Dict[str, str]: Result message from ``ActionExecutor``.
+            Dict[str, str]: A dictionary containing the result of the action.
+                If the click causes a change in the page's structure, a
+                "snapshot" key will be included with a diff of the changes.
         """
         self._validate_ref(ref, "click")
 
@@ -207,15 +217,16 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def type(self, *, ref: str, text: str) -> Dict[str, str]:
-        r"""Type text into an input or textarea element.
+        r"""Types text into an input field or textarea on the current page.
 
         Args:
-            ref (str): Element reference ID extracted from snapshot.
-                (e.g.``"e3"``).
-            text (str): The text to enter.
+            ref (str): The reference ID of the input element. This ID is
+                obtained from the page snapshot (e.g., "e25").
+            text (str): The text to be typed into the element.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                The key is "result".
         """
         self._validate_ref(ref, "type")
 
@@ -223,14 +234,17 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def select(self, *, ref: str, value: str) -> Dict[str, str]:
-        r"""Select an option in a ``<select>`` element.
+        r"""Selects an option from a dropdown (<select>) element on the page.
 
         Args:
-            ref (str): Element reference ID.
-            value (str): The value / option to select.
+            ref (str): The reference ID of the <select> element. This ID is
+                obtained from the page snapshot.
+            value (str): The value of the option to be selected. This should
+                match the 'value' attribute of an <option> tag.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                The key is "result".
         """
         self._validate_ref(ref, "select")
 
@@ -238,15 +252,16 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def scroll(self, *, direction: str, amount: int) -> Dict[str, str]:
-        r"""Scroll the page.
+        r"""Scrolls the current page up or down by a specified amount.
 
         Args:
-            direction (str): Scroll direction, should be ``"down"`` or
-                ``"up"``.
-            amount (int): Pixel distance to scroll.
+            direction (str): The direction to scroll. Must be either "up" or
+                "down".
+            amount (int): The number of pixels to scroll.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                The key is "result".
         """
         if direction not in ("up", "down"):
             logger.error("scroll(): 'direction' must be 'up' or 'down'")
@@ -258,53 +273,72 @@ class BrowserNonVisualToolkit(BaseToolkit):
         return await self._exec_with_snapshot(action)
 
     async def enter(self, *, ref: str) -> Dict[str, str]:
-        r"""Press the Enter key.
+        r"""Simulates pressing the Enter key on a specific element.
+        This is often used to submit forms.
 
         Args:
-            ref (str): Element reference ID to focus before pressing.
+            ref (str): The reference ID of the element to focus before
+                pressing Enter. This ID is obtained from the page snapshot.
 
         Returns:
-            Dict[str, str]: Execution result message.
+            Dict[str, str]: A dictionary containing the result of the action.
+                If pressing Enter causes a page navigation or DOM change, a
+                "snapshot" key will be included with a diff of the changes.
         """
         self._validate_ref(ref, "enter")
 
         action: Dict[str, Any] = {"type": "enter", "ref": ref}
         return await self._exec_with_snapshot(action)
 
-    async def wait_user(self, *, seconds: float = 1.0) -> Dict[str, str]:
-        r"""Pause execution for a given amount of *real* time and then
-        return a *full* page snapshot.
-
-        This is a convenience wrapper around the existing wait action for
-        scenarios where you encounter a CAPTCHA or need to pause for manual
-        user input, and want to retrieve the complete DOM snapshot afterward.
+    async def wait_user(
+        self,
+        timeout_sec: Optional[float] = None,
+    ) -> Dict[str, str]:
+        r"""Pauses the agent's execution and waits for human intervention.
+        This is useful for tasks that require manual steps, like solving a
+        CAPTCHA. The agent will print a message and wait for the user to
+        press the Enter key in the console.
 
         Args:
-            seconds (float): How long to sleep, expressed in seconds. Must
-                be a positive number. (default: :obj:`1.0`)
+            timeout_sec (Optional[float]): The maximum time in seconds to wait
+                for the user. If `None`, it will wait indefinitely. Defaults
+                to `None`. (default: :obj:`None`)
 
         Returns:
-            Dict[str, str]: Keys ``result`` and ``snapshot``.
+            Dict[str, str]: A dictionary containing a result message and a
+                full snapshot of the current page after the user has acted.
+                The keys are "result" and "snapshot".
         """
-        if seconds is None or seconds <= 0:
-            logger.error("wait_time(): 'seconds' must be a positive number")
-            return {
-                "result": "wait_time(): 'seconds' must be a positive number"
-            }
 
-        # Reuse underlying ActionExecutor's ``wait`` implementation (expects
-        # ms)
-        timeout_ms = int(seconds * 1000)
-        action: Dict[str, Any] = {"type": "wait", "timeout": timeout_ms}
+        import asyncio
+
+        prompt = (
+            "🕑 Agent is waiting for human input. "
+            "Complete the required action in the browser, then press Enter "
+            "to continue..."
+        )
 
-        # Execute the sleep via ActionExecutor (no snapshot diff expected)
-        result = await self._exec(action)
+        logger.info(f"\n{prompt}\n")
+
+        async def _await_enter():
+            await asyncio.to_thread(input, ">>> Press Enter to resume <<<\n")
+
+        try:
+            if timeout_sec is not None:
+                await asyncio.wait_for(_await_enter(), timeout=timeout_sec)
+                result_msg = "User resumed."
+            else:
+                await _await_enter()
+                result_msg = "User resumed."
+        except asyncio.TimeoutError:
+            result_msg = f"Timeout {timeout_sec}s reached, auto-resumed."
 
-        # Always return a *full* snapshot after the pause
         snapshot = await self._session.get_snapshot(
-            force_refresh=True, diff_only=False
+            force_refresh=True,
+            diff_only=False,
         )
-        return {"result": result, "snapshot": snapshot}
+
+        return {"result": result_msg, "snapshot": snapshot}
 
     # Helper to run through ActionExecutor
     async def _exec(self, action: Dict[str, Any]) -> str:

camel/types/enums.py

@@ -185,8 +185,8 @@ class ModelType(UnifiedModelType, Enum):
     NVIDIA_LLAMA3_3_70B_INSTRUCT = "meta/llama-3.3-70b-instruct"
 
     # Gemini models
-    GEMINI_2_5_FLASH_PREVIEW = "gemini-2.5-flash-preview-04-17"
-    GEMINI_2_5_PRO_PREVIEW = "gemini-2.5-pro-preview-06-05"
+    GEMINI_2_5_FLASH = "gemini-2.5-flash"
+    GEMINI_2_5_PRO = "gemini-2.5-pro"
     GEMINI_2_0_FLASH = "gemini-2.0-flash"
     GEMINI_2_0_FLASH_EXP = "gemini-2.0-flash-exp"
     GEMINI_2_0_FLASH_THINKING = "gemini-2.0-flash-thinking-exp"
@@ -674,8 +674,8 @@ class ModelType(UnifiedModelType, Enum):
             bool: Whether this type of models is gemini.
         """
         return self in {
-            ModelType.GEMINI_2_5_FLASH_PREVIEW,
-            ModelType.GEMINI_2_5_PRO_PREVIEW,
+            ModelType.GEMINI_2_5_FLASH,
+            ModelType.GEMINI_2_5_PRO,
             ModelType.GEMINI_2_0_FLASH,
             ModelType.GEMINI_2_0_FLASH_EXP,
             ModelType.GEMINI_2_0_FLASH_THINKING,
@@ -1278,8 +1278,8 @@ class ModelType(UnifiedModelType, Enum):
         }:
             return 512_000
         elif self in {
-            ModelType.GEMINI_2_5_FLASH_PREVIEW,
-            ModelType.GEMINI_2_5_PRO_PREVIEW,
+            ModelType.GEMINI_2_5_FLASH,
+            ModelType.GEMINI_2_5_PRO,
             ModelType.GEMINI_2_0_FLASH,
             ModelType.GEMINI_2_0_FLASH_EXP,
             ModelType.GEMINI_2_0_FLASH_THINKING,

{camel_ai-0.2.69a4.dist-info → camel_ai-0.2.69a7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.69a4
+Version: 0.2.69a7
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -31,6 +31,7 @@ Requires-Dist: arxiv<3,>=2.1.3; extra == 'all'
 Requires-Dist: azure-storage-blob<13,>=12.21.0; extra == 'all'
 Requires-Dist: beautifulsoup4<5,>=4; extra == 'all'
 Requires-Dist: botocore<2,>=1.35.3; extra == 'all'
+Requires-Dist: chromadb<1.0.0,>=0.6.0; extra == 'all'
 Requires-Dist: chunkr-ai>=0.0.50; extra == 'all'
 Requires-Dist: cohere<6,>=5.11.0; extra == 'all'
 Requires-Dist: crawl4ai>=0.3.745; extra == 'all'
@@ -176,7 +177,7 @@ Requires-Dist: types-pyyaml<7,>=6.0.12; extra == 'dev'
 Requires-Dist: types-requests<3,>=2.31.0; extra == 'dev'
 Requires-Dist: types-setuptools<70,>=69.2.0; extra == 'dev'
 Requires-Dist: types-tqdm<5,>=4.66.0; extra == 'dev'
-Requires-Dist: uv==0.6.5; extra == 'dev'
+Requires-Dist: uv<0.8,>=0.7.0; extra == 'dev'
 Provides-Extra: dev-tools
 Requires-Dist: aci-sdk>=1.0.0b1; extra == 'dev-tools'
 Requires-Dist: agentops<0.4,>=0.3.21; extra == 'dev-tools'
@@ -288,6 +289,7 @@ Requires-Dist: wikipedia<2,>=1; extra == 'owl'
 Requires-Dist: xls2xlsx>=0.2.0; extra == 'owl'
 Requires-Dist: yt-dlp<2025,>=2024.11.4; extra == 'owl'
 Provides-Extra: rag
+Requires-Dist: chromadb<1.0.0,>=0.6.0; extra == 'rag'
 Requires-Dist: chunkr-ai>=0.0.50; extra == 'rag'
 Requires-Dist: cohere<6,>=5.11.0; extra == 'rag'
 Requires-Dist: crawl4ai>=0.3.745; extra == 'rag'
@@ -311,6 +313,7 @@ Requires-Dist: scholarly[tor]==1.7.11; extra == 'research-tools'
 Provides-Extra: storage
 Requires-Dist: azure-storage-blob<13,>=12.21.0; extra == 'storage'
 Requires-Dist: botocore<2,>=1.35.3; extra == 'storage'
+Requires-Dist: chromadb<1.0.0,>=0.6.0; extra == 'storage'
 Requires-Dist: faiss-cpu<2,>=1.7.2; extra == 'storage'
 Requires-Dist: google-cloud-storage<3,>=2.18.0; extra == 'storage'
 Requires-Dist: mem0ai>=0.1.73; extra == 'storage'
@@ -322,10 +325,6 @@ Requires-Dist: pytidb-experimental==0.0.1.dev4; extra == 'storage'
 Requires-Dist: qdrant-client<2,>=1.9.0; extra == 'storage'
 Requires-Dist: redis<6,>=5.0.6; extra == 'storage'
 Requires-Dist: weaviate-client>=4.15.0; extra == 'storage'
-Provides-Extra: test
-Requires-Dist: mock<6,>=5; extra == 'test'
-Requires-Dist: pytest-asyncio<0.24,>=0.23.0; extra == 'test'
-Requires-Dist: pytest<8,>=7; extra == 'test'
 Provides-Extra: web-tools
 Requires-Dist: apify-client<2,>=1.8.1; extra == 'web-tools'
 Requires-Dist: beautifulsoup4<5,>=4; extra == 'web-tools'