camel-ai 0.2.71a2__py3-none-any.whl → 0.2.71a4__py3-none-any.whl

camel/toolkits/{non_visual_browser_toolkit → hybrid_browser_toolkit}/snapshot.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 if TYPE_CHECKING:
     from playwright.async_api import Page
@@ -64,7 +64,17 @@ class PageSnapshot:
             )
 
             logger.debug("Capturing page snapshot …")
-            snapshot_text = await self._get_snapshot_direct()
+            snapshot_result = await self._get_snapshot_direct()
+
+            # Extract snapshot text from the unified analyzer result
+            if (
+                isinstance(snapshot_result, dict)
+                and 'snapshotText' in snapshot_result
+            ):
+                snapshot_text = snapshot_result['snapshotText']
+            else:
+                snapshot_text = snapshot_result
+
             formatted = self._format_snapshot(snapshot_text or "<empty>")
 
             output = formatted
@@ -99,7 +109,9 @@ class PageSnapshot:
     # ------------------------------------------------------------------
     _snapshot_js_cache: Optional[str] = None  # class-level cache
 
-    async def _get_snapshot_direct(self) -> Optional[str]:
+    async def _get_snapshot_direct(
+        self,
+    ) -> Optional[Union[str, Dict[str, Any]]]:
         r"""Evaluate the snapshot-extraction JS with simple retry logic.
 
         Playwright throws *Execution context was destroyed* when a new page
@@ -110,7 +122,7 @@ class PageSnapshot:
 
         # Load JS once and cache it at class level
         if PageSnapshot._snapshot_js_cache is None:
-            js_path = Path(__file__).parent / "snapshot.js"
+            js_path = Path(__file__).parent / "unified_analyzer.js"
             PageSnapshot._snapshot_js_cache = js_path.read_text(
                 encoding="utf-8"
             )

camel/toolkits/{non_visual_browser_toolkit/snapshot.js → hybrid_browser_toolkit/unified_analyzer.js}

@@ -1,20 +1,40 @@
 (() => {
-    // Playwright's snapshot logic focuses on semantics and visibility, not arbitrary limits.
-    // We will first build a semantic tree in memory, then render it.
+    // Unified analyzer that combines visual and structural analysis
+    // Preserves complete snapshot.js logic while adding visual coordinate information
+
+    let refCounter = 1;
+    function generateRef() {
+        return `e${refCounter++}`;
+    }
+
+    // === Complete snapshot.js logic preservation ===
 
     function isVisible(node) {
+        // Check if node is null or not a valid DOM node
+        if (!node || typeof node.nodeType === 'undefined') return false;
         if (node.nodeType !== Node.ELEMENT_NODE) return true;
-        const style = window.getComputedStyle(node);
-        if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0')
+
+        try {
+            const style = window.getComputedStyle(node);
+            if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0')
+                return false;
+            // An element with `display: contents` is not rendered itself, but its children are.
+            if (style.display === 'contents')
+                return true;
+            const rect = node.getBoundingClientRect();
+            return rect.width > 0 && rect.height > 0;
+        } catch (e) {
+            // If there's an error getting computed style or bounding rect, assume element is not visible
             return false;
-        // An element with `display: contents` is not rendered itself, but its children are.
-        if (style.display === 'contents')
-            return true;
-        const rect = node.getBoundingClientRect();
-        return rect.width > 0 && rect.height > 0;
+        }
     }
 
     function getRole(node) {
+        // Check if node is null or doesn't have required properties
+        if (!node || !node.tagName || !node.getAttribute) {
+            return 'generic';
+        }
+
         const role = node.getAttribute('role');
         if (role) return role;
 
@@ -32,6 +52,9 @@
     }
 
     function getAccessibleName(node) {
+        // Check if node is null or doesn't have required methods
+        if (!node || !node.hasAttribute || !node.getAttribute) return '';
+
         if (node.hasAttribute('aria-label')) return node.getAttribute('aria-label') || '';
         if (node.hasAttribute('aria-labelledby')) {
             const id = node.getAttribute('aria-labelledby');
@@ -48,6 +71,9 @@
 
     const textCache = new Map();
     function getVisibleTextContent(_node) {
+        // Check if node is null or doesn't have nodeType
+        if (!_node || typeof _node.nodeType === 'undefined') return '';
+
         if (textCache.has(_node)) return textCache.get(_node);
 
         if (_node.nodeType === Node.TEXT_NODE) {
@@ -70,18 +96,17 @@
         return result;
     }
 
-    let refCounter = 1;
-    function generateRef() {
-        return `e${refCounter++}`;
-    }
-
     /**
      * Phase 1: Build an in-memory representation of the accessibility tree.
+     * Complete preservation of snapshot.js buildAriaTree logic
      */
     function buildAriaTree(rootElement) {
         const visited = new Set();
 
         function toAriaNode(element) {
+            // Check if element is null or not a valid DOM element
+            if (!element || !element.tagName) return null;
+
             // Only consider visible elements
             if (!isVisible(element)) return null;
 
@@ -112,7 +137,8 @@
         }
 
         function traverse(element, parentNode) {
-            if (visited.has(element)) return;
+            // Check if element is null or not a valid DOM element
+            if (!element || !element.tagName || visited.has(element)) return;
             visited.add(element);
 
             // FIX: Completely skip script and style tags and their children.
@@ -153,9 +179,34 @@
                 }
             }
 
-            // FIX: If an element's name is the same as its only text child, remove the redundant child.
-            if (ariaNode && ariaNode.children.length === 1 && typeof ariaNode.children[0] === 'string' && ariaNode.name === ariaNode.children[0]) {
-                ariaNode.children = [];
+            // FIX: Remove redundant text children that match the element's name
+            if (ariaNode && ariaNode.children.length > 0) {
+                // Remove text children that are the same as the parent's name or are contained in it
+                ariaNode.children = ariaNode.children.filter(child => {
+                    if (typeof child === 'string') {
+                        const childText = child.trim();
+                        const parentName = ariaNode.name.trim();
+
+                        // Remove if text child exactly matches parent name
+                        if (childText === parentName) {
+                            return false;
+                        }
+
+                        // Also remove if the child text is completely contained in parent name
+                        // and represents a significant portion (to avoid removing important partial text)
+                        if (childText.length > 3 && parentName.includes(childText)) {
+                            return false;
+                        }
+
+                        return true;
+                    }
+                    return true;
+                });
+
+                // If after filtering, we have only one text child that equals the name, remove it
+                if (ariaNode.children.length === 1 && typeof ariaNode.children[0] === 'string' && ariaNode.name === ariaNode.children[0]) {
+                    ariaNode.children = [];
+                }
             }
         }
 
@@ -166,7 +217,7 @@
 
     /**
      * Phase 2: Normalize the tree by removing redundant generic wrappers.
-     * This is a key optimization in Playwright to simplify the structure.
+     * Complete preservation of snapshot.js normalizeTree logic
      */
     function normalizeTree(node) {
         if (typeof node === 'string') return [node];
@@ -178,6 +229,24 @@
         node.children = newChildren;
 
         // Remove child elements that have the same name as their parent
+        const filteredChildren = [];
+        for (const child of node.children) {
+            if (typeof child !== 'string' && child.name && node.name) {
+                const childName = child.name.trim();
+                const parentName = node.name.trim();
+                if (childName === parentName) {
+                    // If child has same name as parent, merge its children into parent
+                    filteredChildren.push(...(child.children || []));
+                } else {
+                    filteredChildren.push(child);
+                }
+            } else {
+                filteredChildren.push(child);
+            }
+        }
+        node.children = filteredChildren;
+
+        // Also handle the case where we have only one child with same name
         if (node.children.length === 1 && typeof node.children[0] !== 'string') {
             const child = node.children[0];
             if (child.name && node.name && child.name.trim() === node.name.trim()) {
@@ -195,9 +264,9 @@
         return [node];
     }
 
-
     /**
      * Phase 3: Render the normalized tree into the final string format.
+     * Complete preservation of snapshot.js renderTree logic
      */
     function renderTree(node, indent = '') {
         const lines = [];
@@ -263,6 +332,116 @@
         return lines;
     }
 
-    const outputLines = processDocument(document);
-    return outputLines.join('\n');
-})();
+    // === Visual analysis functions from page_script.js ===
+
+    // From page_script.js - check if element is topmost at coordinates
+    function isTopmost(element, x, y) {
+        let hit = document.elementFromPoint(x, y);
+        if (hit === null) return true;
+
+        while (hit) {
+            if (hit == element) return true;
+            hit = hit.parentNode;
+        }
+        return false;
+    }
+
+    // From page_script.js - get visual coordinates
+    function getElementCoordinates(element) {
+        let rects = element.getClientRects();
+        let scale = window.devicePixelRatio || 1;
+        let validRects = [];
+
+        for (const rect of rects) {
+            let x = rect.left + rect.width / 2;
+            let y = rect.top + rect.height / 2;
+            if (isTopmost(element, x, y)) {
+                validRects.push({
+                    x: rect.x * scale,
+                    y: rect.y * scale,
+                    width: rect.width * scale,
+                    height: rect.height * scale,
+                    top: rect.top * scale,
+                    left: rect.left * scale,
+                    right: rect.right * scale,
+                    bottom: rect.bottom * scale
+                });
+            }
+        }
+
+        return validRects;
+    }
+
+    // === Unified analysis function ===
+
+    function collectElementsFromTree(node, elementsMap) {
+        if (typeof node === 'string') return;
+
+        if (node.element && node.ref) {
+            // Get visual coordinates for this element
+            const coordinates = getElementCoordinates(node.element);
+
+            // Store comprehensive element information
+            elementsMap[node.ref] = {
+                // Structural information (preserved from snapshot.js)
+                role: node.role,
+                name: node.name,
+                tagName: node.element.tagName.toLowerCase(),
+                disabled: node.disabled,
+                checked: node.checked,
+                expanded: node.expanded,
+
+                // Visual information (from page_script.js)
+                coordinates: coordinates,
+
+                // Additional metadata
+                href: node.element.href || null,
+                value: node.element.value || null,
+                placeholder: node.element.placeholder || null,
+                scrollable: node.element.scrollHeight > node.element.clientHeight
+            };
+        }
+
+        // Recursively process children
+        if (node.children) {
+            for (const child of node.children) {
+                collectElementsFromTree(child, elementsMap);
+            }
+        }
+    }
+
+    function analyzePageElements() {
+        // Generate the complete structured snapshot using original snapshot.js logic
+        const outputLines = processDocument(document);
+        const snapshotText = outputLines.join('\n');
+
+        // Build the tree again to collect element information with visual data
+        textCache.clear();
+        refCounter = 1; // Reset counter to match snapshot generation
+        let tree = buildAriaTree(document.body);
+        [tree] = normalizeTree(tree);
+
+        const elementsMap = {};
+        collectElementsFromTree(tree, elementsMap);
+
+        const result = {
+            url: window.location.href,
+            elements: elementsMap,
+            snapshotText: snapshotText,
+            metadata: {
+                timestamp: new Date().toISOString(),
+                elementCount: Object.keys(elementsMap).length,
+                screenInfo: {
+                    width: window.innerWidth,
+                    height: window.innerHeight,
+                    devicePixelRatio: window.devicePixelRatio || 1
+                }
+            }
+        };
+
+        return result;
+    }
+
+    // Execute analysis and return result
+    return analyzePageElements();
+})();

camel/toolkits/note_taking_toolkit.py

@@ -0,0 +1,90 @@
+# ========= 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 pathlib import Path
+from typing import List, Optional
+
+from camel.toolkits.base import BaseToolkit
+from camel.toolkits.function_tool import FunctionTool
+
+
+class NoteTakingToolkit(BaseToolkit):
+    r"""A toolkit for taking notes in a Markdown file.
+
+    This toolkit allows an agent to create, append to, and update a specific
+    Markdown file for note-taking purposes.
+    """
+
+    def __init__(
+        self,
+        note_file_path: str = "notes/notes.md",
+        timeout: Optional[float] = None,
+    ) -> None:
+        r"""Initialize the NoteTakingToolkit.
+
+        Args:
+            note_file_path (str): The path to the note file.
+                (default: :obj:`notes/notes.md`)
+            timeout (Optional[float]): The timeout for the toolkit.
+        """
+        super().__init__(timeout=timeout)
+        self.note_file_path = Path(note_file_path)
+        self.note_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def take_note(self, content: str, update: bool = False) -> str:
+        r"""Takes a note and saves it to the note file.
+
+        Args:
+            content (str): The content of the note to be saved.
+            update (bool): If True, the existing note file will be
+                overwritten with the new content. If False, the new content
+                will be appended to the end of the file.
+                (default: :obj:`False`)
+
+        Returns:
+            str: A message indicating the result of the operation.
+        """
+        mode = "w" if update else "a"
+        try:
+            with self.note_file_path.open(mode, encoding="utf-8") as f:
+                f.write(content + "\n")
+            action = "updated" if update else "appended to"
+            return f"Note successfully {action} in {self.note_file_path}."
+        except Exception as e:
+            return f"Error taking note: {e}"
+
+    def read_note(self) -> str:
+        r"""Reads the content of the note file.
+
+        Returns:
+            str: The content of the note file, or an error message if the
+                 file cannot be read.
+        """
+        try:
+            if not self.note_file_path.exists():
+                return "Note file does not exist yet."
+            return self.note_file_path.read_text(encoding="utf-8")
+        except Exception as e:
+            return f"Error reading note: {e}"
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Return a list of FunctionTool objects representing the functions
+        in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects.
+        """
+        return [
+            FunctionTool(self.take_note),
+            FunctionTool(self.read_note),
+        ]