vibesurf 0.1.36__py3-none-any.whl → 0.1.37__py3-none-any.whl

vibe_surf/backend/utils/llm_factory.py

@@ -177,6 +177,22 @@ def create_llm_from_profile(llm_profile) -> BaseChatModel:
                 params["region_name"] = provider_config["region_name"]
             return ChatAnthropicBedrock(**params)
 
+        elif provider == "qwen":
+            return ChatOpenAICompatible(
+                model=model,
+                base_url="https://dashscope.aliyuncs.com/compatible-mode/v1" or base_url,
+                api_key=api_key,
+                **common_params
+            )
+
+        elif provider == "kimi":
+            return ChatOpenAICompatible(
+                model=model,
+                base_url="https://api.moonshot.cn/v1" or base_url,
+                api_key=api_key,
+                **common_params
+            )
+
         elif provider == "openai_compatible":
             if not base_url:
                 raise ValueError("OpenAI Compatible provider requires base_url")

vibe_surf/browser/agen_browser_profile.py

@@ -45,6 +45,11 @@ class AgentBrowserProfile(BrowserProfile):
                 'id': 'edibdbjcniadpccecjdfdjjppcpchdlm',
                 'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130&acceptformat=crx3&x=id%3Dedibdbjcniadpccecjdfdjjppcpchdlm%26uc',
             },
+            {
+                'name': 'Force Background Tab',
+                'id': 'gidlfommnbibbmegmgajdbikelkdcmcl',
+                'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=133&acceptformat=crx3&x=id%3Dgidlfommnbibbmegmgajdbikelkdcmcl%26uc',
+            },
             # {
             #     'name': 'ClearURLs',
             #     'id': 'lckanjgmijmafbedllaakclkaicjfmnk',

vibe_surf/browser/agent_browser_session.py

@@ -4,7 +4,7 @@ import asyncio
 import os
 import pdb
 from pathlib import Path
-from typing import Any, List, Optional
+from typing import TYPE_CHECKING, Any, Literal, Self, Union, cast, Optional
 
 from browser_use.browser.session import BrowserSession, CDPSession
 from pydantic import Field
@@ -68,7 +68,7 @@ class AgentBrowserSession(BrowserSession):
             executable_path: str | Path | None = None,
             headless: bool | None = None,
             args: list[str] | None = None,
-            ignore_default_args: list[str] | list[bool] | None = None,
+            ignore_default_args: list[str] | Literal[True] | None = None,
             channel: str | None = None,
             chromium_sandbox: bool | None = None,
             devtools: bool | None = None,
@@ -86,11 +86,15 @@ class AgentBrowserSession(BrowserSession):
             record_har_mode: str | None = None,
             record_har_path: str | Path | None = None,
             record_video_dir: str | Path | None = None,
+            record_video_framerate: int | None = None,
+            record_video_size: dict | None = None,
             # From BrowserLaunchPersistentContextArgs
             user_data_dir: str | Path | None = None,
             # From BrowserNewContextArgs
             storage_state: str | Path | dict[str, Any] | None = None,
             # BrowserProfile specific fields
+            use_cloud: bool | None = None,
+            cloud_browser: bool | None = None,  # Backward compatibility alias
             disable_security: bool | None = None,
             deterministic_rendering: bool | None = None,
             allowed_domains: list[str] | None = None,
@@ -99,15 +103,21 @@ class AgentBrowserSession(BrowserSession):
             enable_default_extensions: bool | None = None,
             window_size: dict | None = None,
             window_position: dict | None = None,
-            cross_origin_iframes: bool | None = None,
             minimum_wait_page_load_time: float | None = None,
             wait_for_network_idle_page_load_time: float | None = None,
             wait_between_actions: float | None = None,
-            highlight_elements: bool | None = None,
             filter_highlight_ids: bool | None = None,
             auto_download_pdfs: bool | None = None,
             profile_directory: str | None = None,
             cookie_whitelist_domains: list[str] | None = None,
+            # DOM extraction layer configuration
+            cross_origin_iframes: bool | None = None,
+            highlight_elements: bool | None = None,
+            dom_highlight_elements: bool | None = None,
+            paint_order_filtering: bool | None = None,
+            # Iframe processing limits
+            max_iframes: int | None = None,
+            max_iframe_depth: int | None = None,
             # AgentBrowserProfile specific fields
             custom_extensions: list[str] | None = None,
     ):
@@ -585,17 +595,19 @@ class AgentBrowserSession(BrowserSession):
                     f'🔍 DOMWatchdog.on_BrowserStateRequestEvent: Network waiting failed: {e}, continuing anyway...'
                 )
 
-    async def take_screenshot(self, target_id: Optional[str] = None, format: str = 'png') -> str:
+    async def take_screenshot(self, target_id: Optional[str] = None,
+                              path: str | None = None,
+                              full_page: bool = False,
+                              format: str = 'png',
+                              quality: int | None = None,
+                              clip: dict | None = None,
+                              ) -> bytes:
         """
         Concurrent screenshot method that bypasses serial bottlenecks in ScreenshotWatchdog.
         
         This method performs direct CDP calls for maximum concurrency.
         """
-        if target_id is None:
-            if not self.agent_focus:
-                self.logger.warning('No page focus to get html, please specify a target id.')
-                return ''
-            target_id = self.agent_focus.target_id
+
         cdp_session = await self.get_or_create_cdp_session(target_id, focus=False)
         await self._wait_for_stable_network()
 
@@ -607,13 +619,98 @@ class AgentBrowserSession(BrowserSession):
             pass
 
         try:
+            import base64
             from cdp_use.cdp.page import CaptureScreenshotParameters
-            # Direct CDP screenshot - bypasses all event system overhead
-            params = CaptureScreenshotParameters(format=format, captureBeyondViewport=False, quality=90)
-            result = await cdp_session.cdp_client.send.Page.captureScreenshot(
-                params=params,
-                session_id=cdp_session.session_id,
+
+            # Build parameters dict explicitly to satisfy TypedDict expectations
+            params: CaptureScreenshotParameters = {
+                'format': format,
+                'captureBeyondViewport': full_page,
+            }
+
+            if quality is not None and format == 'jpeg':
+                params['quality'] = quality
+
+            if clip:
+                params['clip'] = {
+                    'x': clip['x'],
+                    'y': clip['y'],
+                    'width': clip['width'],
+                    'height': clip['height'],
+                    'scale': 1,
+                }
+
+            params = CaptureScreenshotParameters(**params)
+
+            result = await cdp_session.cdp_client.send.Page.captureScreenshot(params=params,
+                                                                              session_id=cdp_session.session_id)
+
+            if not result or 'data' not in result:
+                raise Exception('Screenshot failed - no data returned')
+
+            screenshot_data = base64.b64decode(result['data'])
+
+            if path:
+                Path(path).write_bytes(screenshot_data)
+
+            return screenshot_data
+
+        except Exception as e:
+            self.logger.error(f'Concurrent screenshot failed: {type(e).__name__}: {e}')
+            raise
+
+    async def take_screenshot_base64(self, target_id: Optional[str] = None,
+                                     full_page: bool = False,
+                                     format: str = 'png',
+                                     quality: int | None = None,
+                                     clip: dict | None = None,
+                                     ) -> str:
+        """
+        Concurrent screenshot method that bypasses serial bottlenecks in ScreenshotWatchdog.
+
+        This method performs direct CDP calls for maximum concurrency.
+        """
+
+        cdp_session = await self.get_or_create_cdp_session(target_id, focus=False)
+        await self._wait_for_stable_network()
+
+        try:
+            ready_state = await cdp_session.cdp_client.send.Runtime.evaluate(
+                params={'expression': 'document.readyState'}, session_id=cdp_session.session_id
             )
+        except Exception:
+            pass
+
+        try:
+            import base64
+            from cdp_use.cdp.page import CaptureScreenshotParameters
+
+            # Build parameters dict explicitly to satisfy TypedDict expectations
+            params: CaptureScreenshotParameters = {
+                'format': format,
+                'captureBeyondViewport': full_page,
+            }
+
+            if quality is not None and format == 'jpeg':
+                params['quality'] = quality
+
+            if clip:
+                params['clip'] = {
+                    'x': clip['x'],
+                    'y': clip['y'],
+                    'width': clip['width'],
+                    'height': clip['height'],
+                    'scale': 1,
+                }
+
+            params = CaptureScreenshotParameters(**params)
+
+            result = await cdp_session.cdp_client.send.Page.captureScreenshot(params=params,
+                                                                              session_id=cdp_session.session_id)
+
+            if not result or 'data' not in result:
+                raise Exception('Screenshot failed - no data returned')
+
             return result['data']
 
         except Exception as e:
@@ -625,12 +722,8 @@ class AgentBrowserSession(BrowserSession):
         Get html content of current page
         :return:
         """
-        if target_id is None:
-            if not self.agent_focus:
-                self.logger.warning('No page focus to get html, please specify a target id.')
-                return ''
-            target_id = self.agent_focus.target_id
-        cdp_session = await self.get_or_create_cdp_session(target_id, focus=True)
+
+        cdp_session = await self.get_or_create_cdp_session(target_id, focus=False)
         await self._wait_for_stable_network()
 
         try:
@@ -654,7 +747,6 @@ class AgentBrowserSession(BrowserSession):
 
     async def get_browser_state_summary(
             self,
-            cache_clickable_elements_hashes: bool = True,
             include_screenshot: bool = True,
             cached: bool = False,
             include_recent_events: bool = False,
@@ -677,7 +769,6 @@ class AgentBrowserSession(BrowserSession):
         browser_state = await self._dom_watchdog.get_browser_state_no_event_bus(
             include_dom=True,
             include_screenshot=include_screenshot,
-            cache_clickable_elements_hashes=cache_clickable_elements_hashes,
             include_recent_events=include_recent_events
         )
         return browser_state
@@ -738,9 +829,9 @@ class AgentBrowserSession(BrowserSession):
 
         return tabs
 
-    async def refresh_page(self):
-        cdp_session = await self.browser_session.get_or_create_cdp_session()
+    async def refresh_page(self, target_id: Optional[str] = None, ):
         try:
+            cdp_session = await self.browser_session.get_or_create_cdp_session(target_id)
             # Reload the target
             await cdp_session.cdp_client.send.Page.reload(session_id=cdp_session.session_id)
 

vibe_surf/browser/watchdogs/action_watchdog.py

@@ -20,86 +20,4 @@ from browser_use.browser.watchdog_base import BaseWatchdog
 from browser_use.dom.service import EnhancedDOMTreeNode
 
 class CustomActionWatchdog(DefaultActionWatchdog):
-    async def on_ClickElementEvent(self, event: ClickElementEvent) -> None:
-        """Handle click request with CDP."""
-        try:
-            # Check if session is alive before attempting any operations
-            if not self.browser_session.agent_focus or not self.browser_session.agent_focus.target_id:
-                error_msg = 'Cannot execute click: browser session is corrupted (target_id=None). Session may have crashed.'
-                self.logger.error(f'⚠️ {error_msg}')
-                raise BrowserError(error_msg)
-
-            # Use the provided node
-            element_node = event.node
-            index_for_logging = element_node.element_index or 'unknown'
-            starting_target_id = self.browser_session.agent_focus.target_id
-
-            # Track initial number of tabs to detect new tab opening
-            if hasattr(self.browser_session, "main_browser_session") and self.browser_session.main_browser_session:
-                initial_target_ids = await self.browser_session.main_browser_session._cdp_get_all_pages()
-            else:
-                initial_target_ids = await self.browser_session._cdp_get_all_pages()
-
-            # Check if element is a file input (should not be clicked)
-            if self.browser_session.is_file_input(element_node):
-                msg = f'Index {index_for_logging} - has an element which opens file upload dialog. To upload files please use a specific function to upload files'
-                self.logger.info(msg)
-                raise BrowserError(
-                    message=msg,
-                    long_term_memory=msg,
-                )
-
-            # Perform the actual click using internal implementation
-            click_metadata = None
-            click_metadata = await self._click_element_node_impl(element_node,
-                                                                 while_holding_ctrl=event.while_holding_ctrl)
-            download_path = None  # moved to downloads_watchdog.py
-
-            # Build success message
-            if download_path:
-                msg = f'Downloaded file to {download_path}'
-                self.logger.info(f'💾 {msg}')
-            else:
-                msg = f'Clicked button with index {index_for_logging}: {element_node.get_all_children_text(max_depth=2)}'
-                self.logger.debug(f'🖱️ {msg}')
-            self.logger.debug(f'Element xpath: {element_node.xpath}')
-
-            # Wait a bit for potential new tab to be created
-            # This is necessary because tab creation is async and might not be immediate
-            await asyncio.sleep(0.5)
-
-            # Clear cached state after click action since DOM might have changed
-            self.browser_session.agent_focus = await self.browser_session.get_or_create_cdp_session(
-                target_id=starting_target_id, focus=True
-            )
-
-            # Check if a new tab was opened
-            if hasattr(self.browser_session, "main_browser_session") and self.browser_session.main_browser_session:
-                after_target_ids = await self.browser_session.main_browser_session._cdp_get_all_pages()
-            else:
-                after_target_ids = await self.browser_session._cdp_get_all_pages()
-            new_target_ids = {t['targetId'] for t in after_target_ids} - {t['targetId'] for t in initial_target_ids}
-            if new_target_ids:
-                new_tab_msg = 'New tab opened - switching to it'
-                msg += f' - {new_tab_msg}'
-                self.logger.info(f'🔗 {new_tab_msg}')
-                new_target_id = new_target_ids.pop()
-                if not event.while_holding_ctrl:
-                    # if while_holding_ctrl=False it means agent was not expecting a new tab to be opened
-                    # so we need to switch to the new tab to make the agent aware of the surprise new tab that was opened.
-                    # when while_holding_ctrl=True we dont actually want to switch to it,
-                    # we should match human expectations of ctrl+click which opens in the background,
-                    # so in multi_act it usually already sends [click_element_by_index(123, while_holding_ctrl=True), switch_tab(tab_id=None)] anyway
-                    from browser_use.browser.events import SwitchTabEvent
-
-                    await self.browser_session.get_or_create_cdp_session(
-                        target_id=new_target_id, focus=True
-                    )
-                else:
-                    await self.browser_session.get_or_create_cdp_session(
-                        target_id=new_target_id, focus=False
-                    )
-
-            return None
-        except Exception as e:
-            raise
+    pass

vibe_surf/browser/watchdogs/dom_watchdog.py

@@ -27,7 +27,6 @@ class CustomDOMWatchdog(DOMWatchdog):
 
     async def get_browser_state_no_event_bus(self, include_dom: bool = True,
                                              include_screenshot: bool = True,
-                                             cache_clickable_elements_hashes: bool = True,
                                              include_recent_events: bool = False) -> 'BrowserStateSummary':
         """Handle browser state request by coordinating DOM building and screenshot capture.
 
@@ -91,7 +90,7 @@ class CustomDOMWatchdog(DOMWatchdog):
             # Start clean screenshot task if requested (without JS highlights)
             if include_screenshot:
                 self.logger.debug('🔍 DOMWatchdog.on_BrowserStateRequestEvent: 📸 Starting clean screenshot task...')
-                screenshot_task = asyncio.create_task(self.browser_session.take_screenshot())
+                screenshot_task = asyncio.create_task(self.browser_session.take_screenshot_base64())
 
             # Wait for both tasks to complete
             content = None
@@ -121,13 +120,18 @@ class CustomDOMWatchdog(DOMWatchdog):
                 try:
                     self.logger.debug(
                         '🔍 DOMWatchdog.on_BrowserStateRequestEvent: 🎨 Applying Python-based highlighting...')
-                    from vibe_surf.browser.utils import create_highlighted_screenshot_async
+                    from browser_use.browser.python_highlights import create_highlighted_screenshot_async
 
                     # Get CDP session for viewport info
                     cdp_session = await self.browser_session.get_or_create_cdp_session()
 
-                    screenshot_b64 = await create_highlighted_screenshot_async(screenshot_b64, content.selector_map,
-                                                                               cdp_session)
+                    screenshot_b64 = await create_highlighted_screenshot_async(
+                        screenshot_b64,
+                        content.selector_map,
+                        cdp_session,
+                        self.browser_session.browser_profile.filter_highlight_ids,
+                    )
+
                     self.logger.debug(
                         f'🔍 DOMWatchdog.on_BrowserStateRequestEvent: ✅ Applied highlights to {len(content.selector_map)} elements'
                     )
@@ -234,4 +238,3 @@ class CustomDOMWatchdog(DOMWatchdog):
                 is_pdf_viewer=False,
                 recent_events=None,
             )
-

vibe_surf/cli.py

@@ -455,6 +455,8 @@ def main():
         import vibe_surf
         console.print(f"[dim]Version: {vibe_surf.__version__}[/dim]\n")
         console.print(f"[dim]Author: WarmShao and Community Contributors [/dim]\n")
+        console.print("[dim]VibeSurf collects anonymous usage data by default to improve user experience.[/dim]")
+        console.print("[dim]To opt out, set environment variable: VIBESURF_ANONYMIZED_TELEMETRY=false[/dim]\n")
         
         # Capture telemetry start event
         start_event = CLITelemetryEvent(

vibe_surf/llm/openai_compatible.py

@@ -209,14 +209,6 @@ class ChatOpenAICompatible(ChatOpenAI):
 
         return clean_schema(schema)
 
-    @overload
-    async def ainvoke(self, messages: list[BaseMessage], output_format: None = None) -> ChatInvokeCompletion[str]:
-        ...
-
-    @overload
-    async def ainvoke(self, messages: list[BaseMessage], output_format: type[T]) -> ChatInvokeCompletion[T]:
-        ...
-
     async def ainvoke(
             self, messages: list[BaseMessage], output_format: type[T] | None = None
     ) -> ChatInvokeCompletion[T] | ChatInvokeCompletion[str]:
@@ -299,7 +291,8 @@ class ChatOpenAICompatible(ChatOpenAI):
 
                 # Add JSON schema to system prompt if requested
                 if self.add_schema_to_system_prompt and openai_messages and openai_messages[0]['role'] == 'system':
-                    schema_text = f'\n<json_schema>\n{response_format}\n</json_schema>'
+                    schema_text = "Your response must return JSON with followed format:\n"
+                    schema_text += f'\n<json_schema>\n{response_format}\n</json_schema>'
                     if isinstance(openai_messages[0]['content'], str):
                         openai_messages[0]['content'] += schema_text
                     elif isinstance(openai_messages[0]['content'], Iterable):

vibe_surf/telemetry/views.py

@@ -154,3 +154,35 @@ class BackendTelemetryEvent(BaseTelemetryEvent):
 	error_message: str | None = None
 	
 	name: str = 'backend_event'
+
+
+@dataclass
+class VibeSurfAgentParsedOutputEvent(BaseTelemetryEvent):
+	"""Telemetry event for VibeSurf Agent parsed output"""
+	
+	version: str
+	parsed_output: str | None = None
+	action_count: int | None = None
+	action_types: list[str] | None = None
+	model: str | None = None
+	model_provider: str | None = None
+	session_id: str | None = None
+	thinking: str | None = None
+	
+	name: str = 'vibesurf_agent_parsed_output'
+
+
+@dataclass
+class VibeSurfAgentExceptionEvent(BaseTelemetryEvent):
+	"""Telemetry event for VibeSurf Agent exceptions"""
+	
+	version: str
+	error_message: str
+	error_type: str | None = None
+	traceback: str | None = None
+	model: str | None = None
+	model_provider: str | None = None
+	session_id: str | None = None
+	function_name: str | None = None
+	
+	name: str = 'vibesurf_agent_exception'