camel-ai 0.2.73a0__tar.gz → 0.2.73a2__tar.gz

{camel_ai-0.2.73a0 → camel_ai-0.2.73a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a0
+Version: 0.2.73a2
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -128,7 +128,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.4a4; extra == 'all'
+Requires-Dist: traceroot==0.0.4a5; 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'
@@ -193,7 +193,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.4a4; extra == 'dev-tools'
+Requires-Dist: traceroot==0.0.4a5; 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.73a0 → camel_ai-0.2.73a2}/camel/__init__.py

@@ -14,7 +14,7 @@
 
 from camel.logger import disable_logging, enable_logging, set_log_level
 
-__version__ = '0.2.73a0'
+__version__ = '0.2.73a2'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.73a0 → camel_ai-0.2.73a2}/camel/agents/chat_agent.py

@@ -2929,7 +2929,32 @@ class ChatAgent(BaseAgent):
             if function_name in self._internal_tools:
                 tool = self._internal_tools[function_name]
                 try:
-                    result = await tool.async_call(**args)
+                    # Try different invocation paths in order of preference
+                    if hasattr(tool, 'func') and hasattr(
+                        tool.func, 'async_call'
+                    ):
+                        # Case: FunctionTool wrapping an MCP tool
+                        result = await tool.func.async_call(**args)
+
+                    elif hasattr(tool, 'async_call') and callable(
+                        tool.async_call
+                    ):
+                        # Case: tool itself has async_call
+                        result = await tool.async_call(**args)
+
+                    elif hasattr(tool, 'func') and asyncio.iscoroutinefunction(
+                        tool.func
+                    ):
+                        # Case: tool wraps a direct async function
+                        result = await tool.func(**args)
+
+                    elif asyncio.iscoroutinefunction(tool):
+                        # Case: tool is itself a coroutine function
+                        result = await tool(**args)
+
+                    else:
+                        # Fallback: synchronous call
+                        result = tool(**args)
 
                     # Only record the tool response message, not the assistant
                     # message assistant message with tool_calls was already

{camel_ai-0.2.73a0 → camel_ai-0.2.73a2}/camel/toolkits/__init__.py

@@ -88,6 +88,7 @@ from .message_agent_toolkit import AgentCommunicationToolkit
 from .web_deploy_toolkit import WebDeployToolkit
 from .screenshot_toolkit import ScreenshotToolkit
 from .message_integration import ToolkitMessageIntegration
+from .notion_mcp_toolkit import NotionMCPToolkit
 
 __all__ = [
     'BaseToolkit',
@@ -165,4 +166,5 @@ __all__ = [
     'ScreenshotToolkit',
     'RegisteredAgentToolkit',
     'ToolkitMessageIntegration',
+    'NotionMCPToolkit',
 ]

camel_ai-0.2.73a2/camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py

@@ -0,0 +1,177 @@
+# ========= 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 Any, List, Literal, Optional
+
+from camel.models import BaseModelBackend
+from camel.toolkits.base import BaseToolkit
+
+
+class HybridBrowserToolkit(BaseToolkit):
+    r"""A hybrid browser toolkit that can switch between TypeScript and Python
+    implementations.
+
+    This wrapper allows users to choose between:
+    - 'typescript': WebSocket-based implementation using TypeScript/Node.js
+    - 'python': Pure Python implementation using Playwright directly
+    """
+
+    def __new__(
+        cls,
+        *,
+        mode: Literal["typescript", "python"] = "typescript",
+        headless: bool = True,
+        user_data_dir: Optional[str] = None,
+        stealth: bool = False,
+        web_agent_model: Optional[BaseModelBackend] = None,
+        cache_dir: str = "tmp/",
+        enabled_tools: Optional[List[str]] = None,
+        browser_log_to_file: bool = False,
+        session_id: Optional[str] = None,
+        default_start_url: str = "https://google.com/",
+        default_timeout: Optional[int] = None,
+        short_timeout: Optional[int] = None,
+        navigation_timeout: Optional[int] = None,
+        network_idle_timeout: Optional[int] = None,
+        screenshot_timeout: Optional[int] = None,
+        page_stability_timeout: Optional[int] = None,
+        dom_content_loaded_timeout: Optional[int] = None,
+        viewport_limit: bool = False,
+        connect_over_cdp: bool = False,
+        cdp_url: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Any:
+        r"""Create a HybridBrowserToolkit instance with the specified mode.
+
+        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.
+            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)
+            **kwargs: Additional keyword arguments passed to the
+                implementation.
+
+        Returns:
+            HybridBrowserToolkit instance of the specified implementation.
+        """
+        if mode == "typescript":
+            from .hybrid_browser_toolkit_ts import (
+                HybridBrowserToolkit as TSToolkit,
+            )
+
+            return TSToolkit(
+                headless=headless,
+                user_data_dir=user_data_dir,
+                stealth=stealth,
+                web_agent_model=web_agent_model,
+                cache_dir=cache_dir,
+                enabled_tools=enabled_tools,
+                browser_log_to_file=browser_log_to_file,
+                session_id=session_id,
+                default_start_url=default_start_url,
+                default_timeout=default_timeout,
+                short_timeout=short_timeout,
+                navigation_timeout=navigation_timeout,
+                network_idle_timeout=network_idle_timeout,
+                screenshot_timeout=screenshot_timeout,
+                page_stability_timeout=page_stability_timeout,
+                dom_content_loaded_timeout=dom_content_loaded_timeout,
+                viewport_limit=viewport_limit,
+                connect_over_cdp=connect_over_cdp,
+                cdp_url=cdp_url,
+                **kwargs,
+            )
+        elif mode == "python":
+            from ..hybrid_browser_toolkit_py import (
+                HybridBrowserToolkit as PyToolkit,
+            )
+
+            # Note: Python implementation doesn't support CDP connection
+            if connect_over_cdp:
+                raise ValueError(
+                    "CDP connection is only supported in TypeScript mode"
+                )
+
+            # Note: Python implementation doesn't support viewport_limit
+            if viewport_limit:
+                import warnings
+
+                warnings.warn(
+                    "viewport_limit is not supported "
+                    "in Python mode and will be ignored",
+                    UserWarning,
+                )
+
+            return PyToolkit(
+                headless=headless,
+                user_data_dir=user_data_dir,
+                stealth=stealth,
+                web_agent_model=web_agent_model,
+                cache_dir=cache_dir,
+                enabled_tools=enabled_tools,
+                browser_log_to_file=browser_log_to_file,
+                session_id=session_id,
+                default_start_url=default_start_url,
+                default_timeout=default_timeout,
+                short_timeout=short_timeout,
+                navigation_timeout=navigation_timeout,
+                network_idle_timeout=network_idle_timeout,
+                screenshot_timeout=screenshot_timeout,
+                page_stability_timeout=page_stability_timeout,
+                dom_content_loaded_timeout=dom_content_loaded_timeout,
+                **kwargs,
+            )
+        else:
+            raise ValueError(
+                f"Invalid mode: {mode}. Must be 'typescript' or 'python'."
+            )

camel_ai-0.2.73a0/camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.py → camel_ai-0.2.73a2/camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit_ts.py

@@ -518,7 +518,7 @@ class HybridBrowserToolkit(BaseToolkit, RegisteredAgentToolkit):
 
         Returns:
             str: A confirmation message indicating the screenshot was
-                captured, the file path where it was saved, and optionally the 
+                captured, the file path where it was saved, and optionally the
                 agent's analysis if `read_image` is `True`.
         """
         import base64

{camel_ai-0.2.73a0 → camel_ai-0.2.73a2}/camel/toolkits/hybrid_browser_toolkit/ts/src/browser-session.ts

@@ -50,20 +50,28 @@ export class HybridBrowserSession {
       // Handle existing pages
       const pages = this.context.pages();
       if (pages.length > 0) {
-        // Map existing pages
+        // Map existing pages - for CDP, only use pages with about:blank URL
+        let availablePageFound = false;
         for (const page of pages) {
-          const tabId = this.generateTabId();
-          this.pages.set(tabId, page);
-          if (!this.currentTabId) {
-            this.currentTabId = tabId;
+          const pageUrl = page.url();
+          // In CDP mode, only consider pages with about:blank as available
+          if (pageUrl === 'about:blank') {
+            const tabId = this.generateTabId();
+            this.pages.set(tabId, page);
+            if (!this.currentTabId) {
+              this.currentTabId = tabId;
+              availablePageFound = true;
+            }
           }
         }
+        
+        // If no available blank pages found in CDP mode, we cannot create new ones
+        if (!availablePageFound) {
+          throw new Error('No available blank tabs found in CDP mode. The frontend should have pre-created blank tabs.');
+        }
       } else {
-        // Create initial page if none exist
-        const initialPage = await this.context.newPage();
-        const initialTabId = this.generateTabId();
-        this.pages.set(initialTabId, initialPage);
-        this.currentTabId = initialTabId;
+        // In CDP mode, newPage is not supported
+        throw new Error('No pages available in CDP mode and newPage() is not supported. Ensure the frontend has pre-created blank tabs.');
       }
     } else {
       // Original launch logic
@@ -626,18 +634,39 @@ export class HybridBrowserSession {
           throw new Error('Browser context not initialized');
         }
         
-        
         const navigationStart = Date.now();
         
-        // Create a new page (tab)
-        const newPage = await this.context.newPage();
+        // In CDP mode, find an available blank tab instead of creating new page
+        let newPage: Page | null = null;
+        let newTabId: string | null = null;
         
-        // Generate tab ID for the new page
-        const newTabId = this.generateTabId();
-        this.pages.set(newTabId, newPage);
+        const browserConfig = this.configLoader.getBrowserConfig();
+        if (browserConfig.connectOverCdp) {
+          // CDP mode: find an available blank tab
+          const allPages = this.context.pages();
+          for (const page of allPages) {
+            const pageUrl = page.url();
+            // Check if this page is not already tracked and is blank
+            const isTracked = Array.from(this.pages.values()).includes(page);
+            if (!isTracked && pageUrl === 'about:blank') {
+              newPage = page;
+              newTabId = this.generateTabId();
+              this.pages.set(newTabId, newPage);
+              break;
+            }
+          }
+          
+          if (!newPage || !newTabId) {
+            throw new Error('No available blank tabs in CDP mode. Frontend should create more blank tabs when half are used.');
+          }
+        } else {
+          // Non-CDP mode: create new page as usual
+          newPage = await this.context.newPage();
+          newTabId = this.generateTabId();
+          this.pages.set(newTabId, newPage);
+        }
         
         // Set up page properties
-        const browserConfig = this.configLoader.getBrowserConfig();
         newPage.setDefaultNavigationTimeout(browserConfig.navigationTimeout);
         newPage.setDefaultTimeout(browserConfig.navigationTimeout);
         

{camel_ai-0.2.73a0 → camel_ai-0.2.73a2}/camel/toolkits/hybrid_browser_toolkit/ts/websocket-server.js

@@ -78,8 +78,52 @@ class WebSocketBrowserServer {
     switch (command) {
       case 'init':
         console.log('Initializing toolkit with params:', JSON.stringify(params, null, 2));
-        this.toolkit = new HybridBrowserToolkit(params);
-        return { message: 'Toolkit initialized' };
+        
+        // Check if CDP is available first
+        let useCdp = false;
+        let cdpUrl = params.cdpUrl || 'http://localhost:9222';
+        
+        // Extract base URL and port for validation
+        const baseUrl = cdpUrl.includes('/devtools/') ? cdpUrl.split('/devtools/')[0] : cdpUrl;
+        
+        try {
+          // Test if Chrome debug port is accessible and get page URL
+          const response = await fetch(`${baseUrl}/json`);
+          if (response.ok) {
+            const pages = await response.json();
+            if (pages && pages.length > 0) {
+              // If user provided a specific page URL, use it; otherwise use first available
+              if (cdpUrl.includes('/devtools/page/') || cdpUrl.includes('/devtools/browser/')) {
+                useCdp = true;
+                console.log(`Using provided CDP URL: ${cdpUrl}`);
+              } else {
+                // Use the first available page
+                const firstPage = pages[0];
+                const pageUrl = firstPage.devtoolsFrontendUrl;
+                const pageId = pageUrl.match(/ws=localhost:\d+(.*)$/)?.[1];
+                
+                if (pageId) {
+                  useCdp = true;
+                  cdpUrl = `${baseUrl}${pageId}`;
+                  console.log(`Chrome debug port detected, using CDP connection to: ${pageId}`);
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.log('Chrome debug port not accessible, will start new browser instance');
+        }
+        
+        const config = {
+          connectOverCdp: useCdp,
+          cdpUrl: useCdp ? cdpUrl : undefined,
+          headless: false,
+          ...params
+        };
+        
+        console.log('Final config:', JSON.stringify(config, null, 2));
+        this.toolkit = new HybridBrowserToolkit(config);
+        return { message: 'Toolkit initialized with CDP connection' };
 
       case 'open_browser':
         if (!this.toolkit) throw new Error('Toolkit not initialized');

camel_ai-0.2.73a2/camel/toolkits/hybrid_browser_toolkit_py/__init__.py

@@ -0,0 +1,17 @@
+# ========= 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 .hybrid_browser_toolkit import HybridBrowserToolkit
+
+__all__ = ["HybridBrowserToolkit"]