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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.73a0
+Version: 0.2.73a1
 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.73a1}/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.73a1'
 
 __all__ = [
     '__version__',

{camel_ai-0.2.73a0 → camel_ai-0.2.73a1}/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.73a0 → camel_ai-0.2.73a1}/camel/toolkits/hybrid_browser_toolkit/hybrid_browser_toolkit.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.73a1}/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.73a1/camel/toolkits/notion_mcp_toolkit.py

@@ -0,0 +1,234 @@
+# ========= 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, ClassVar, Dict, List, Optional, Set
+
+from camel.toolkits import BaseToolkit, FunctionTool
+
+from .mcp_toolkit import MCPToolkit
+
+
+class NotionMCPToolkit(BaseToolkit):
+    r"""NotionMCPToolkit provides an interface for interacting with Notion
+    through the Model Context Protocol (MCP).
+
+    Attributes:
+        timeout (Optional[float]): Connection timeout in seconds.
+            (default: :obj:`None`)
+
+    Note:
+        Currently only supports asynchronous operation mode.
+    """
+
+    # TODO: Create unified method to validate and fix the schema
+    SCHEMA_KEYWORDS: ClassVar[Set[str]] = {
+        "type",
+        "properties",
+        "items",
+        "required",
+        "additionalProperties",
+        "description",
+        "title",
+        "default",
+        "enum",
+        "const",
+        "examples",
+        "$ref",
+        "$defs",
+        "definitions",
+        "allOf",
+        "oneOf",
+        "anyOf",
+        "not",
+        "if",
+        "then",
+        "else",
+        "format",
+        "pattern",
+        "minimum",
+        "maximum",
+        "minLength",
+        "maxLength",
+        "minItems",
+        "maxItems",
+        "uniqueItems",
+    }
+
+    def __init__(
+        self,
+        timeout: Optional[float] = None,
+    ) -> None:
+        r"""Initializes the NotionMCPToolkit.
+
+        Args:
+            timeout (Optional[float]): Connection timeout in seconds.
+                (default: :obj:`None`)
+        """
+        super().__init__(timeout=timeout)
+
+        self._mcp_toolkit = MCPToolkit(
+            config_dict={
+                "mcpServers": {
+                    "notionMCP": {
+                        "command": "npx",
+                        "args": [
+                            "-y",
+                            "mcp-remote",
+                            "https://mcp.notion.com/mcp",
+                        ],
+                    }
+                }
+            },
+            timeout=timeout,
+        )
+
+    async def connect(self):
+        r"""Explicitly connect to the Notion MCP server."""
+        await self._mcp_toolkit.connect()
+
+    async def disconnect(self):
+        r"""Explicitly disconnect from the Notion MCP server."""
+        await self._mcp_toolkit.disconnect()
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of tools provided by the NotionMCPToolkit.
+
+        Returns:
+            List[FunctionTool]: List of available tools.
+        """
+        all_tools = []
+        for client in self._mcp_toolkit.clients:
+            try:
+                original_build_schema = client._build_tool_schema
+
+                def create_wrapper(orig_func):
+                    def wrapper(mcp_tool):
+                        return self._build_notion_tool_schema(
+                            mcp_tool, orig_func
+                        )
+
+                    return wrapper
+
+                client._build_tool_schema = create_wrapper(  # type: ignore[method-assign]
+                    original_build_schema
+                )
+
+                client_tools = client.get_tools()
+                all_tools.extend(client_tools)
+
+                client._build_tool_schema = original_build_schema  # type: ignore[method-assign]
+
+            except Exception as e:
+                from camel.logger import get_logger
+
+                logger = get_logger(__name__)
+                logger.error(f"Failed to get tools from client: {e}")
+
+        return all_tools
+
+    def _build_notion_tool_schema(self, mcp_tool, original_build_schema):
+        r"""Build tool schema with Notion-specific fixes."""
+        schema = original_build_schema(mcp_tool)
+        self._fix_notion_schema_recursively(schema)
+        return schema
+
+    def _fix_notion_schema_recursively(self, obj: Any) -> None:
+        r"""Recursively fix Notion MCP schema issues."""
+        if isinstance(obj, dict):
+            self._fix_dict_schema(obj)
+            self._process_nested_structures(obj)
+        elif isinstance(obj, list):
+            for item in obj:
+                self._fix_notion_schema_recursively(item)
+
+    def _fix_dict_schema(self, obj: Dict[str, Any]) -> None:
+        r"""Fix dictionary schema issues."""
+        if "properties" in obj and "type" not in obj:
+            self._fix_missing_type_with_properties(obj)
+        elif obj.get("type") == "object" and "properties" in obj:
+            self._fix_object_with_properties(obj)
+
+    def _fix_missing_type_with_properties(self, obj: Dict[str, Any]) -> None:
+        r"""Fix objects with properties but missing type field."""
+        properties = obj.get("properties", {})
+        if properties and isinstance(properties, dict):
+            obj["type"] = "object"
+            obj["additionalProperties"] = False
+
+            required_properties = self._get_required_properties(
+                properties, conservative=True
+            )
+            if required_properties:
+                obj["required"] = required_properties
+
+    def _fix_object_with_properties(self, obj: Dict[str, Any]) -> None:
+        r"""Fix objects with type="object" and properties."""
+        properties = obj.get("properties", {})
+        if properties and isinstance(properties, dict):
+            existing_required = obj.get("required", [])
+
+            for prop_name, prop_schema in properties.items():
+                if (
+                    prop_name not in existing_required
+                    and prop_name not in self.SCHEMA_KEYWORDS
+                    and self._is_property_required(prop_schema)
+                ):
+                    existing_required.append(prop_name)
+
+            if existing_required:
+                obj["required"] = existing_required
+
+            if "additionalProperties" not in obj:
+                obj["additionalProperties"] = False
+
+    def _get_required_properties(
+        self, properties: Dict[str, Any], conservative: bool = False
+    ) -> List[str]:
+        r"""Get list of required properties from a properties dict."""
+        required = []
+        for prop_name, prop_schema in properties.items():
+            if (
+                prop_name not in self.SCHEMA_KEYWORDS
+                and isinstance(prop_schema, dict)
+                and self._is_property_required(prop_schema)
+            ):
+                required.append(prop_name)
+        return required
+
+    def _is_property_required(self, prop_schema: Dict[str, Any]) -> bool:
+        r"""Check if a property should be marked as required."""
+        prop_type = prop_schema.get("type")
+        return (
+            prop_type is not None
+            and prop_type != "null"
+            and "default" not in prop_schema
+            and not (isinstance(prop_type, list) and "null" in prop_type)
+        )
+
+    def _process_nested_structures(self, obj: Dict[str, Any]) -> None:
+        r"""Process all nested structures in a schema object."""
+        for key, value in obj.items():
+            if key in ["anyOf", "oneOf", "allOf"] and isinstance(value, list):
+                for item in value:
+                    self._fix_notion_schema_recursively(item)
+            elif key == "items" and isinstance(value, dict):
+                self._fix_notion_schema_recursively(value)
+            elif key == "properties" and isinstance(value, dict):
+                for prop_value in value.values():
+                    self._fix_notion_schema_recursively(prop_value)
+            elif key == "$defs" and isinstance(value, dict):
+                for def_value in value.values():
+                    self._fix_notion_schema_recursively(def_value)
+            elif isinstance(value, (dict, list)):
+                self._fix_notion_schema_recursively(value)

camel_ai-0.2.73a1/hatch_build_npm.py

@@ -0,0 +1,293 @@
+# ========= 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. =========
+"""
+Hatch build hook for building TypeScript dependencies in
+hybrid_browser_toolkit.
+
+This script runs during package building to compile TypeScript code.
+It gracefully handles cases where Node.js/npm is not available.
+"""
+
+import json
+import re
+import subprocess
+from pathlib import Path
+from typing import Optional, Tuple
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+class NpmBuildHook(BuildHookInterface):
+    r"""Hatch build hook for TypeScript compilation."""
+
+    PLUGIN_NAME = "npm-build"
+
+    def initialize(self, version, build_data):
+        r"""Initialize the build hook and run npm build."""
+        self.build_npm_dependencies()
+
+    def finalize(self, version, build_data, artifact_path):
+        r"""Finalize the build - ensure TypeScript was built."""
+        base_dir = Path(self.root)
+        ts_dir = self._get_ts_directory(base_dir)
+        dist_dir = ts_dir / "dist"
+
+        if dist_dir.exists():
+            print(f"TypeScript build artifacts found at: {dist_dir}")
+        else:
+            print("Warning: TypeScript build artifacts not found")
+
+    def _get_ts_directory(self, base_dir: Path) -> Path:
+        r"""Get the TypeScript directory path."""
+        return (
+            base_dir / "camel" / "toolkits" / "hybrid_browser_toolkit" / "ts"
+        )
+
+    def _parse_version(self, version_str: str) -> Tuple[int, int, int]:
+        r"""Parse version string into major, minor, patch numbers."""
+        version_str = version_str.strip().lstrip('v')
+        match = re.match(r'(\d+)\.(\d+)\.(\d+)', version_str)
+        if match:
+            return tuple(map(int, match.groups()))
+        return (0, 0, 0)
+
+    def _check_version_requirement(self, current: str, required: str) -> bool:
+        r"""Check if current version meets requirement."""
+        if required.startswith('>='):
+            required_version = self._parse_version(required[2:])
+            current_version = self._parse_version(current)
+            return current_version >= required_version
+        elif required.startswith('^'):
+            required_version = self._parse_version(required[1:])
+            current_version = self._parse_version(current)
+            return (
+                current_version[0] == required_version[0]
+                and current_version >= required_version
+            )
+        return True
+
+    def _get_package_requirements(self, ts_dir: Path) -> Optional[dict]:
+        r"""Get Node.js/npm version requirements from package.json or
+        package-lock.json.
+        """
+        package_json = ts_dir / "package.json"
+        package_lock = ts_dir / "package-lock.json"
+
+        try:
+            if package_json.exists():
+                with open(package_json, 'r') as f:
+                    data = json.load(f)
+                    if 'engines' in data:
+                        return data['engines']
+
+            if package_lock.exists():
+                with open(package_lock, 'r') as f:
+                    data = json.load(f)
+                    for pkg_name, pkg_data in data.get('packages', {}).items():
+                        if not pkg_name and 'engines' in pkg_data:
+                            return pkg_data['engines']
+
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Warning: Could not read package requirements: {e}")
+
+        return None
+
+    def _check_node_npm_versions(
+        self, ts_dir: Path
+    ) -> Tuple[Optional[str], Optional[str], bool]:
+        r"""Check Node.js and npm versions against requirements."""
+        node_version = None
+        npm_version = None
+        versions_ok = True
+
+        try:
+            result = subprocess.run(
+                ["node", "--version"],
+                check=True,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            node_version = result.stdout.strip()
+            print(f"Found Node.js version: {node_version}")
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            print("Warning: Node.js not found in PATH")
+            return None, None, False
+
+        try:
+            result = subprocess.run(
+                ["npm", "--version"],
+                check=True,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            npm_version = result.stdout.strip()
+            print(f"Found npm version: {npm_version}")
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            print("Warning: npm not found in PATH")
+            return node_version, None, False
+
+        requirements = self._get_package_requirements(ts_dir)
+        if requirements:
+            if 'node' in requirements:
+                node_req = requirements['node']
+                if not self._check_version_requirement(node_version, node_req):
+                    print(
+                        f"Warning: Node.js version {node_version} "
+                        f"does not meet requirement {node_req}"
+                    )
+                    versions_ok = False
+                else:
+                    print(
+                        f"✓ Node.js version {node_version} meets "
+                        f"requirement {node_req}"
+                    )
+
+            if 'npm' in requirements:
+                npm_req = requirements['npm']
+                if not self._check_version_requirement(npm_version, npm_req):
+                    print(
+                        f"Warning: npm version {npm_version} does not "
+                        f"meet requirement {npm_req}"
+                    )
+                    versions_ok = False
+                else:
+                    print(
+                        f"✓ npm version {npm_version} meets "
+                        f"requirement {npm_req}"
+                    )
+
+        return node_version, npm_version, versions_ok
+
+    def _run_npm_build_process(self, ts_dir: Path, dist_dir: Path) -> bool:
+        r"""Run the npm build process."""
+        try:
+            print("Installing npm dependencies...")
+            subprocess.run(
+                ["npm", "install"],
+                cwd=ts_dir,
+                check=True,
+                text=True,
+                timeout=300,
+            )
+
+            print("Building TypeScript...")
+            subprocess.run(
+                ["npm", "run", "build"],
+                cwd=ts_dir,
+                check=True,
+                text=True,
+                timeout=300,
+            )
+
+            print("Installing Playwright browsers...")
+            try:
+                subprocess.run(
+                    ["npx", "playwright", "install"],
+                    cwd=ts_dir,
+                    check=True,
+                    text=True,
+                    timeout=600,
+                )
+                print("Playwright browsers installed successfully")
+            except subprocess.CalledProcessError as e:
+                print(f"Warning: Playwright browser installation failed: {e}")
+                print(
+                    "Users will need to run 'npx playwright install' manually"
+                )
+                print("  npx playwright install")
+
+            index_js = dist_dir / "index.js"
+            if index_js.exists():
+                print("TypeScript build completed successfully")
+                return True
+            else:
+                print(
+                    "Warning: TypeScript build may have failed (index.js "
+                    "not found)"
+                )
+                return False
+
+        except subprocess.CalledProcessError as e:
+            print(f"Warning: TypeScript build failed with error: {e}")
+            print("Installing without TypeScript support")
+            print("This may affect hybrid_browser_toolkit functionality")
+            return False
+
+        except Exception as e:
+            print(f"Warning: Unexpected error during TypeScript build: {e}")
+            print("Installing without TypeScript support")
+            return False
+
+    def _print_manual_instructions(self, ts_dir: Path):
+        r"""Print manual installation instructions."""
+        print("Installing without TypeScript support")
+        print("To use hybrid_browser_toolkit, please install Node.js and run:")
+        print(f"  cd {ts_dir}")
+        print("  npm install && npm run build")
+        print("  npx playwright install")
+
+    def build_npm_dependencies(self):
+        r"""Build TypeScript dependencies during wheel/sdist creation."""
+        base_dir = Path(self.root)
+        ts_dir = self._get_ts_directory(base_dir)
+
+        print(f"Checking TypeScript directory: {ts_dir}")
+
+        if not ts_dir.exists():
+            print("TypeScript directory not found, skipping npm build")
+            return
+
+        dist_dir = ts_dir / "dist"
+        if dist_dir.exists() and any(dist_dir.iterdir()):
+            print(
+                "TypeScript already built (dist directory exists), "
+                "skipping build"
+            )
+            return
+
+        node_version, npm_version, versions_ok = self._check_node_npm_versions(
+            ts_dir
+        )
+
+        if node_version is None or npm_version is None:
+            print("Warning: npm or node not found in PATH")
+            self._print_manual_instructions(ts_dir)
+            return
+
+        if not versions_ok:
+            print("Warning: Node.js/npm version requirements not met")
+            print("Continuing anyway, but build may fail")
+
+        self._run_npm_build_process(ts_dir, dist_dir)
+
+
+def build_npm_dependencies_standalone():
+    r"""Standalone function for testing purposes."""
+    hook = NpmBuildHook(None, None)
+    hook.root = Path(__file__).parent.absolute()
+    hook.build_npm_dependencies()
+
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("Running Hatch build hook for TypeScript dependencies")
+    print("=" * 60)
+
+    build_npm_dependencies_standalone()
+
+    print("=" * 60)
+    print("Build hook completed")
+    print("=" * 60)