vibesurf 0.1.22__py3-none-any.whl → 0.1.23__py3-none-any.whl

vibe_surf/tools/browser_use_tools.py

@@ -462,96 +462,6 @@ class BrowserUseTools(Tools, VibeSurfTools):
                 logger.error(f'Failed to switch tab: {str(e)}')
                 return ActionResult(error=f'Failed to switch to tab {params.tab_id or params.url}: {str(e)}')
 
-        @self.registry.action(
-            """Extract structured, semantic data (e.g. product description, price, all information about XYZ) from the current webpage based on a textual query.
-        This tool takes the entire markdown of the page and extracts the query from it.
-        Set extract_links=True ONLY if your query requires extracting links/URLs from the page.
-        Only use this for specific queries for information retrieval from the page. Don't use this to get interactive elements - the tool does not see HTML elements, only the markdown.
-        Note: Extracting from the same page will yield the same results unless more content is loaded (e.g., through scrolling for dynamic content, or new page is loaded) - so one extraction per page state is sufficient. If you want to scrape a listing of many elements always first scroll a lot until the page end to load everything and then call this tool in the end.
-        If you called extract_structured_data in the last step and the result was not good (e.g. because of antispam protection), use the current browser state and scrolling to get the information, dont call extract_structured_data again.
-        """,
-            param_model=ExtractionAction
-        )
-        async def extract_structured_data(
-                params: ExtractionAction,
-                browser_session: AgentBrowserSession,
-                page_extraction_llm: BaseChatModel,
-                file_system: FileSystem,
-        ):
-            try:
-                # Use AgentBrowserSession's direct method to get HTML content
-                target_id = None
-                if params.tab_id:
-                    target_id = await browser_session.get_target_id_from_tab_id(params.tab_id)
-                page_html = await browser_session.get_html_content(target_id)
-
-                # Simple markdown conversion
-                import re
-                import markdownify
-
-                if params.extract_links:
-                    content = markdownify.markdownify(page_html, heading_style='ATX', bullets='-')
-                else:
-                    content = markdownify.markdownify(page_html, heading_style='ATX', bullets='-', strip=['a'])
-                    # Remove all markdown links and images, keep only the text
-                    content = re.sub(r'!\[.*?\]\([^)]*\)', '', content, flags=re.MULTILINE | re.DOTALL)  # Remove images
-                    content = re.sub(
-                        r'\[([^\]]*)\]\([^)]*\)', r'\1', content, flags=re.MULTILINE | re.DOTALL
-                    )  # Convert [text](url) -> text
-
-                # Remove weird positioning artifacts
-                content = re.sub(r'❓\s*\[\d+\]\s*\w+.*?Position:.*?Size:.*?\n?', '', content,
-                                 flags=re.MULTILINE | re.DOTALL)
-                content = re.sub(r'Primary: UNKNOWN\n\nNo specific evidence found', '', content,
-                                 flags=re.MULTILINE | re.DOTALL)
-                content = re.sub(r'UNKNOWN CONFIDENCE', '', content, flags=re.MULTILINE | re.DOTALL)
-                content = re.sub(r'!\[\]\(\)', '', content, flags=re.MULTILINE | re.DOTALL)
-
-                # Simple truncation to 30k characters
-                if len(content) > 30000:
-                    content = content[:30000] + '\n\n... [Content truncated at 30k characters] ...'
-
-                # Simple prompt
-                prompt = f"""Extract the requested information from this webpage content.
-                
-Query: {params.query}
-
-Webpage Content:
-{content}
-
-Provide the extracted information in a clear, structured format."""
-
-                from browser_use.llm.messages import UserMessage
-
-                response = await asyncio.wait_for(
-                    page_extraction_llm.ainvoke([UserMessage(content=prompt)]),
-                    timeout=120.0,
-                )
-
-                extracted_content = f'Query: {params.query}\nExtracted Content:\n{response.completion}'
-
-                # Simple memory handling
-                if len(extracted_content) < 1000:
-                    memory = extracted_content
-                    include_extracted_content_only_once = False
-                else:
-                    save_result = await file_system.save_extracted_content(extracted_content)
-                    current_url = await browser_session.get_current_page_url()
-                    memory = (
-                        f'Extracted content from {current_url} for query: {params.query}\nContent saved to file system: {save_result}'
-                    )
-                    include_extracted_content_only_once = True
-
-                logger.info(f'📄 {memory}')
-                return ActionResult(
-                    extracted_content=extracted_content,
-                    include_extracted_content_only_once=include_extracted_content_only_once,
-                    long_term_memory=memory,
-                )
-            except Exception as e:
-                logger.debug(f'Error extracting content: {e}')
-                raise RuntimeError(str(e))
-
         @self.registry.action(
             'Take a screenshot of the current page and save it to the file system',
             param_model=NoParamsAction

vibe_surf/tools/vibesurf_registry.py

@@ -0,0 +1,52 @@
+from browser_use.tools.registry.service import Registry, Context
+import asyncio
+import functools
+import inspect
+import logging
+import re
+from collections.abc import Callable
+from inspect import Parameter, iscoroutinefunction, signature
+from types import UnionType
+from typing import Any, Generic, Optional, TypeVar, Union, get_args, get_origin
+
+import pyotp
+from pydantic import BaseModel, Field, RootModel, create_model
+
+from browser_use.browser import BrowserSession
+from browser_use.filesystem.file_system import FileSystem
+from browser_use.llm.base import BaseChatModel
+from browser_use.observability import observe_debug
+from browser_use.telemetry.service import ProductTelemetry
+from browser_use.tools.registry.views import (
+    ActionModel,
+    ActionRegistry,
+    RegisteredAction,
+    SpecialActionParameters,
+)
+from browser_use.utils import is_new_tab_page, match_url_with_domain_pattern, time_execution_async
+
+from vibe_surf.logger import get_logger
+from vibe_surf.browser.browser_manager import BrowserManager
+
+logger = get_logger(__name__)
+
+
+class VibeSurfRegistry(Registry):
+    def _get_special_param_types(self) -> dict[str, type | UnionType | None]:
+        """Get the expected types for special parameters from SpecialActionParameters"""
+        # Manually define the expected types to avoid issues with Optional handling.
+        # we should try to reduce this list to 0 if possible, give as few standardized objects to all the actions
+        # but each driver should decide what is relevant to expose the action methods,
+        # e.g. CDP client, 2fa code getters, sensitive_data wrappers, other context, etc.
+        return {
+            'context': None,  # Context is a TypeVar, so we can't validate type
+            'browser_session': BrowserSession,
+            'page_url': str,
+            'cdp_client': None,  # CDPClient type from cdp_use, but we don't import it here
+            'page_extraction_llm': BaseChatModel,
+            'available_file_paths': list,
+            'has_sensitive_data': bool,
+            'file_system': FileSystem,
+            'llm': BaseChatModel,
+            'browser_manager': BrowserManager
+        }