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

vibe_surf/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.36'
-__version_tuple__ = version_tuple = (0, 1, 36)
+__version__ = version = '0.1.38'
+__version_tuple__ = version_tuple = (0, 1, 38)
 
 __commit_id__ = commit_id = None

vibe_surf/agents/browser_use_agent.py

@@ -72,7 +72,7 @@ from browser_use.utils import (
     time_execution_async,
     time_execution_sync,
 )
-
+from browser_use.llm.messages import BaseMessage, ContentPartImageParam, ContentPartTextParam, UserMessage
 from browser_use.agent.service import Agent, AgentHookFunc
 from vibe_surf.tools.file_system import CustomFileSystem
 from vibe_surf.telemetry.service import ProductTelemetry
@@ -107,6 +107,7 @@ class BrowserUseAgent(Agent):
                     | None
             ) = None,
             register_external_agent_status_raise_error_callback: Callable[[], Awaitable[bool]] | None = None,
+            register_should_stop_callback: Callable[[], Awaitable[bool]] | None = None,
             # Agent settings
             output_model_schema: type[AgentStructuredOutput] | None = None,
             use_vision: bool = True,
@@ -127,7 +128,6 @@ class BrowserUseAgent(Agent):
             source: str | None = None,
             file_system_path: str | None = None,
             task_id: str | None = None,
-            cloud_sync: CloudSync | None = None,
             calculate_cost: bool = False,
             display_files_in_done_text: bool = True,
             include_tool_call_examples: bool = False,
@@ -136,7 +136,9 @@ class BrowserUseAgent(Agent):
             step_timeout: int = 120,
             directly_open_url: bool = False,
             include_recent_events: bool = False,
-            allow_parallel_action_types: list[str] = ["extract_structured_data", "extract_content_from_file"],
+            sample_images: list[ContentPartTextParam | ContentPartImageParam] | None = None,
+            final_response_after_failure: bool = True,
+            allow_parallel_action_types: list[str] = ["extract", "extract_content_from_file"],
             _url_shortening_limit: int = 25,
             token_cost_service: Optional[TokenCost] = None,
             **kwargs,
@@ -151,7 +153,7 @@ class BrowserUseAgent(Agent):
         self.session_id: str = uuid7str()
         self.allow_parallel_action_types = allow_parallel_action_types
         self._url_shortening_limit = _url_shortening_limit
-
+        self.sample_images = sample_images
         browser_profile = browser_profile or DEFAULT_BROWSER_PROFILE
 
         # Handle browser vs browser_session parameter (browser takes precedence)
@@ -206,6 +208,7 @@ class BrowserUseAgent(Agent):
             include_tool_call_examples=include_tool_call_examples,
             llm_timeout=llm_timeout,
             step_timeout=step_timeout,
+            final_response_after_failure=final_response_after_failure,
         )
 
         # Token cost service
@@ -289,7 +292,6 @@ class BrowserUseAgent(Agent):
         self._message_manager = MessageManager(
             task=task,
             system_message=SystemPrompt(
-                action_description=self.unfiltered_actions,
                 max_actions_per_step=self.settings.max_actions_per_step,
                 override_system_message=override_system_message,
                 extend_system_message=extend_system_message,
@@ -306,6 +308,7 @@ class BrowserUseAgent(Agent):
             vision_detail_level=self.settings.vision_detail_level,
             include_tool_call_examples=self.settings.include_tool_call_examples,
             include_recent_events=self.include_recent_events,
+            sample_images=self.sample_images,
         )
 
         if self.sensitive_data:
@@ -375,6 +378,7 @@ class BrowserUseAgent(Agent):
         # Callbacks
         self.register_new_step_callback = register_new_step_callback
         self.register_done_callback = register_done_callback
+        self.register_should_stop_callback = register_should_stop_callback
         self.register_external_agent_status_raise_error_callback = register_external_agent_status_raise_error_callback
 
         # Telemetry
@@ -463,7 +467,7 @@ class BrowserUseAgent(Agent):
 
             # Use _make_history_item like main branch
             await self._make_history_item(self.state.last_model_output, browser_state_summary, self.state.last_result,
-                                          metadata)
+                                          metadata, state_message=self._message_manager.last_state_message_text,)
 
         # Log step completion summary
         self._log_step_completion_summary(self.step_start_time, self.state.last_result)
@@ -490,6 +494,9 @@ class BrowserUseAgent(Agent):
         self.task = new_task
         self._message_manager.add_new_task(new_task)
 
+        # Mark as follow-up task and recreate eventbus (gets shut down after each run)
+        self.state.follow_up_task = True
+
     @observe(name='agent.run', metadata={'task': '{{task}}', 'debug': '{{debug}}'})
     @time_execution_async('--run')
     async def run(
@@ -749,273 +756,4 @@ class BrowserUseAgent(Agent):
         # Add the last group
         groups.append(current_group)
 
-        return groups
-
-    @observe_debug(ignore_input=True, ignore_output=True)
-    @time_execution_async('--multi_act')
-    async def multi_act(
-            self,
-            actions: list[ActionModel],
-            check_for_new_elements: bool = True,
-    ) -> list[ActionResult]:
-        """Execute multiple actions, with parallel execution for allowed action types"""
-        results: list[ActionResult] = []
-        time_elapsed = 0
-        total_actions = len(actions)
-
-        assert self.browser_session is not None, 'BrowserSession is not set up'
-        try:
-            if (
-                    self.browser_session._cached_browser_state_summary is not None
-                    and self.browser_session._cached_browser_state_summary.dom_state is not None
-            ):
-                cached_selector_map = dict(self.browser_session._cached_browser_state_summary.dom_state.selector_map)
-                cached_element_hashes = {e.parent_branch_hash() for e in cached_selector_map.values()}
-            else:
-                cached_selector_map = {}
-                cached_element_hashes = set()
-        except Exception as e:
-            self.logger.error(f'Error getting cached selector map: {e}')
-            cached_selector_map = {}
-            cached_element_hashes = set()
-
-        # Group actions for potential parallel execution
-        action_groups = self._group_actions_for_parallel_execution(actions)
-
-        # Track global action index for logging and DOM checks
-        global_action_index = 0
-
-        for group_index, action_group in enumerate(action_groups):
-            group_size = len(action_group)
-
-            # Check if this group can be executed in parallel
-            can_execute_in_parallel = (
-                    group_size > 1 and
-                    all(self._is_action_parallel_allowed(action) for action in action_group)
-            )
-
-            if can_execute_in_parallel:
-                self.logger.info(
-                    f'🚀 Executing {group_size} actions in parallel: group {group_index + 1}/{len(action_groups)}')
-                # Execute actions in parallel using asyncio.gather
-                parallel_results = await self._execute_actions_in_parallel(
-                    action_group, global_action_index, total_actions,
-                    cached_selector_map, cached_element_hashes, check_for_new_elements
-                )
-                results.extend(parallel_results)
-                global_action_index += group_size
-
-                # Check if any result indicates completion or error
-                if any(result.is_done or result.error for result in parallel_results):
-                    break
-            else:
-                # Execute actions sequentially
-                for local_index, action in enumerate(action_group):
-                    i = global_action_index + local_index
-
-                    # Original sequential execution logic continues here...
-                    # if i > 0:
-                    #     # ONLY ALLOW TO CALL `done` IF IT IS A SINGLE ACTION
-                    #     if action.model_dump(exclude_unset=True).get('done') is not None:
-                    #         msg = f'Done action is allowed only as a single action - stopped after action {i} / {total_actions}.'
-                    #         self.logger.debug(msg)
-                    #         break
-
-                    # DOM synchronization check - verify element indexes are still valid AFTER first action
-                    if action.get_index() is not None and i != 0:
-                        result = await self._check_dom_synchronization(
-                            action, i, total_actions, cached_selector_map, cached_element_hashes,
-                            check_for_new_elements, actions
-                        )
-                        if result:
-                            results.append(result)
-                            break
-
-                    # wait between actions (only after first action)
-                    if i > 0:
-                        await asyncio.sleep(self.browser_profile.wait_between_actions)
-
-                    # Execute single action
-                    try:
-                        action_result = await self._execute_single_action(action, i, total_actions)
-                        results.append(action_result)
-
-                        if action_result.is_done or action_result.error or i == total_actions - 1:
-                            break
-
-                    except Exception as e:
-                        self.logger.error(f'❌ Executing action {i + 1} failed: {type(e).__name__}: {e}')
-                        raise e
-
-                global_action_index += len(action_group)
-
-        return results
-
-    async def _execute_actions_in_parallel(
-            self,
-            actions: list[ActionModel],
-            start_index: int,
-            total_actions: int,
-            cached_selector_map: dict,
-            cached_element_hashes: set,
-            check_for_new_elements: bool
-    ) -> list[ActionResult]:
-        """Execute a group of actions in parallel using asyncio.gather"""
-
-        async def execute_single_parallel_action(action: ActionModel, action_index: int) -> ActionResult:
-            """Execute a single action for parallel execution"""
-            await self._raise_if_stopped_or_paused()
-
-            # Get action info for logging
-            action_data = action.model_dump(exclude_unset=True)
-            action_name = next(iter(action_data.keys())) if action_data else 'unknown'
-            action_params = getattr(action, action_name, '') or str(action.model_dump(mode='json'))[:140].replace(
-                '"', ''
-            ).replace('{', '').replace('}', '').replace("'", '').strip().strip(',')
-            action_params = str(action_params)
-            action_params = f'{action_params[:122]}...' if len(action_params) > 128 else action_params
-
-            time_start = time.time()
-            blue = '\033[34m'
-            reset = '\033[0m'
-            self.logger.info(f'  🦾 {blue}[PARALLEL ACTION {action_index + 1}/{total_actions}]{reset} {action_params}')
-
-            # Execute the action
-            result = await self.tools.act(
-                action=action,
-                browser_session=self.browser_session,
-                file_system=self.file_system,
-                page_extraction_llm=self.settings.page_extraction_llm,
-                sensitive_data=self.sensitive_data,
-                available_file_paths=self.available_file_paths,
-            )
-
-            time_end = time.time()
-            time_elapsed = time_end - time_start
-
-            green = '\033[92m'
-            self.logger.debug(
-                f'☑️ Parallel action {action_index + 1}/{total_actions}: {green}{action_params}{reset} in {time_elapsed:.2f}s'
-            )
-
-            return result
-
-        # Create tasks for parallel execution
-        tasks = [
-            execute_single_parallel_action(action, start_index + i)
-            for i, action in enumerate(actions)
-        ]
-
-        # Execute all tasks in parallel
-        parallel_results = await asyncio.gather(*tasks, return_exceptions=True)
-
-        # Process results and handle any exceptions
-        processed_results = []
-        for i, result in enumerate(parallel_results):
-            if isinstance(result, Exception):
-                action_index = start_index + i
-                self.logger.error(f'❌ Parallel action {action_index + 1} failed: {type(result).__name__}: {result}')
-                raise result
-            else:
-                processed_results.append(result)
-
-        return processed_results
-
-    async def _check_dom_synchronization(
-            self,
-            action: ActionModel,
-            action_index: int,
-            total_actions: int,
-            cached_selector_map: dict,
-            cached_element_hashes: set,
-            check_for_new_elements: bool,
-            all_actions: list[ActionModel]
-    ) -> ActionResult | None:
-        """Check DOM synchronization and return result if page changed"""
-        new_browser_state_summary = await self.browser_session.get_browser_state_summary(
-            cache_clickable_elements_hashes=False,
-            include_screenshot=False,
-        )
-        new_selector_map = new_browser_state_summary.dom_state.selector_map
-
-        # Detect index change after previous action
-        orig_target = cached_selector_map.get(action.get_index())
-        orig_target_hash = orig_target.parent_branch_hash() if orig_target else None
-
-        new_target = new_selector_map.get(action.get_index())  # type: ignore
-        new_target_hash = new_target.parent_branch_hash() if new_target else None
-
-        def get_remaining_actions_str(actions: list[ActionModel], index: int) -> str:
-            remaining_actions = []
-            for remaining_action in actions[index:]:
-                action_data = remaining_action.model_dump(exclude_unset=True)
-                action_name = next(iter(action_data.keys())) if action_data else 'unknown'
-                remaining_actions.append(action_name)
-            return ', '.join(remaining_actions)
-
-        if orig_target_hash != new_target_hash:
-            # Get names of remaining actions that won't be executed
-            remaining_actions_str = get_remaining_actions_str(all_actions, action_index)
-            msg = f'Page changed after action {action_index} / {total_actions}: actions {remaining_actions_str} were not executed'
-            self.logger.info(msg)
-            return ActionResult(
-                extracted_content=msg,
-                include_in_memory=True,
-                long_term_memory=msg,
-            )
-
-        # Check for new elements that appeared
-        new_element_hashes = {e.parent_branch_hash() for e in new_selector_map.values()}
-        if check_for_new_elements and not new_element_hashes.issubset(cached_element_hashes):
-            # next action requires index but there are new elements on the page
-            remaining_actions_str = get_remaining_actions_str(all_actions, action_index)
-            msg = f'Something new appeared after action {action_index} / {total_actions}: actions {remaining_actions_str} were not executed'
-            self.logger.info(msg)
-            return ActionResult(
-                extracted_content=msg,
-                include_in_memory=True,
-                long_term_memory=msg,
-            )
-
-        return None
-
-    async def _execute_single_action(self, action: ActionModel, action_index: int, total_actions: int) -> ActionResult:
-        """Execute a single action in sequential mode"""
-        await self._raise_if_stopped_or_paused()
-
-        # Get action name from the action model
-        action_data = action.model_dump(exclude_unset=True)
-        action_name = next(iter(action_data.keys())) if action_data else 'unknown'
-        action_params = getattr(action, action_name, '') or str(action.model_dump(mode='json'))[:140].replace(
-            '"', ''
-        ).replace('{', '').replace('}', '').replace("'", '').strip().strip(',')
-        # Ensure action_params is always a string before checking length
-        action_params = str(action_params)
-        action_params = f'{action_params[:122]}...' if len(action_params) > 128 else action_params
-
-        time_start = time.time()
-
-        red = '\033[91m'
-        green = '\033[92m'
-        blue = '\033[34m'
-        reset = '\033[0m'
-
-        self.logger.info(f'  🦾 {blue}[ACTION {action_index + 1}/{total_actions}]{reset} {action_params}')
-
-        result = await self.tools.act(
-            action=action,
-            browser_session=self.browser_session,
-            file_system=self.file_system,
-            page_extraction_llm=self.settings.page_extraction_llm,
-            sensitive_data=self.sensitive_data,
-            available_file_paths=self.available_file_paths,
-        )
-
-        time_end = time.time()
-        time_elapsed = time_end - time_start
-
-        self.logger.debug(
-            f'☑️ Executed action {action_index + 1}/{total_actions}: {green}{action_params}{reset} in {time_elapsed:.2f}s'
-        )
-
-        return result
+        return groups

vibe_surf/agents/prompts/vibe_surf_prompt.py

@@ -78,7 +78,7 @@ When using Composio tools (those with `cpo.{toolkit_name}.{tool_name}` prefix):
 - **Special Cases**: `skill_deep_research` only returns guidelines only, then follow guidelines to conduct actual research
 - **Execution Policy**: Skill actions execute only once (no need to retry if errors occur), and all results - whether successful or failed - should be presented to users in structured markdown format.
 - **Follow-up Operations**: When users input skill operations without specifying additional tasks, do not automatically perform subsequent operations. Only perform additional tool operations when users specifically request actions like saving results to files or writing reports.
-- After `/search` completion, NEVER use browser agent to deeply investigate search result (unless explicitly emphasized by the user). The user usually only need the search results. Just return the search results.
+- **Search Skill Usage**: `/search` should ONLY be used when users want to quickly obtain specific information or news. Please analyze user intent carefully - if the request contains other browser tasks or requires more complex web operations, you should generally execute browser tasks instead of using skill search.
 
 ## Language Adaptability
 

vibe_surf/agents/report_writer_agent.py

@@ -157,7 +157,27 @@ class ReportWriterAgent:
 
             # Add system message with unified prompt only if message history is empty
             if not self.message_history:
-                self.message_history.append(SystemMessage(content=REPORT_WRITER_PROMPT))
+                report_system_prompt = REPORT_WRITER_PROMPT
+                if self.use_thinking:
+                    report_system_prompt += """
+                    You must ALWAYS respond with a valid JSON in this exact format:
+                    {{
+                      "thinking": "A structured <think>-style reasoning.",
+                      "action":[{{"<action_name>": {{<action_params>}}]
+                    }}
+        
+                    Action list should NEVER be empty and Each step can only output one action. If multiple actions are output, only the first one will be executed.
+                    """
+                else:
+                    report_system_prompt += """
+                    You must ALWAYS respond with a valid JSON in this exact format:
+                    {{
+                      "action":[{{"<action_name>": {{<action_params>}}]
+                    }}
+    
+                    Action list should NEVER be empty and Each step can only output one action. If multiple actions are output, only the first one will be executed.
+                    """
+                self.message_history.append(SystemMessage(content=report_system_prompt))
 
             # Add initial user message with task details
             user_message = f"""Please generate a report within MAX {max_iterations} steps based on the following:
@@ -214,7 +234,7 @@ Please analyze the task, determine if you need to read any additional files, the
                 results = []
                 time_start = time.time()
 
-                for i, action in enumerate(actions):
+                for i, action in enumerate(actions[:1]):
                     action_data = action.model_dump(exclude_unset=True)
                     action_name = next(iter(action_data.keys())) if action_data else 'unknown'
                     logger.info(f"🛠️ Executing action {i + 1}/{len(actions)}: {action_name}")

vibe_surf/agents/vibe_surf_agent.py

@@ -41,7 +41,11 @@ from vibe_surf.tools.file_system import CustomFileSystem
 from vibe_surf.agents.views import VibeSurfAgentSettings
 
 from vibe_surf.telemetry.service import ProductTelemetry
-from vibe_surf.telemetry.views import VibeSurfAgentTelemetryEvent
+from vibe_surf.telemetry.views import (
+    VibeSurfAgentTelemetryEvent,
+    VibeSurfAgentParsedOutputEvent,
+    VibeSurfAgentExceptionEvent
+)
 
 from vibe_surf.logger import get_logger
 
@@ -400,11 +404,30 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
             AssistantMessage(content=json.dumps(response.completion.model_dump(exclude_none=True, exclude_unset=True),
                                                 ensure_ascii=False)))
 
+        # Capture telemetry for parsed output
+        import vibe_surf
+        action_types = []
+        for action in actions:
+            action_data = action.model_dump(exclude_unset=True)
+            action_name = next(iter(action_data.keys())) if action_data else 'unknown'
+            action_types.append(action_name)
+        
+        parsed_output_event = VibeSurfAgentParsedOutputEvent(
+            version=vibe_surf.__version__,
+            parsed_output=json.dumps(parsed.model_dump(exclude_none=True, exclude_unset=True), ensure_ascii=False),  # Limit size
+            action_count=len(actions),
+            action_types=action_types,
+            model=getattr(vibesurf_agent.llm, 'model_name', None),
+            session_id=state.session_id,
+        )
+        vibesurf_agent.telemetry.capture(parsed_output_event)
+        vibesurf_agent.telemetry.flush()
+
         # Log thinking if present
         if hasattr(parsed, 'thinking') and parsed.thinking:
             await log_agent_activity(state, agent_name, "thinking", parsed.thinking)
 
-        for i, action in enumerate(actions):
+        for i, action in enumerate(actions[:1]):
             action_data = action.model_dump(exclude_unset=True)
             action_name = next(iter(action_data.keys())) if action_data else 'unknown'
             logger.info(f"🛠️ Processing VibeSurf action {i + 1}/{len(actions)}: {action_name}")
@@ -505,8 +528,24 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
 
     except Exception as e:
         import traceback
+        traceback_str = traceback.format_exc()
         traceback.print_exc()
         logger.error(f"❌ VibeSurf agent failed: {e}")
+        
+        # Capture telemetry for exception
+        import vibe_surf
+        exception_event = VibeSurfAgentExceptionEvent(
+            version=vibe_surf.__version__,
+            error_message=str(e)[:500],  # Limit error message length
+            error_type=type(e).__name__,
+            traceback=traceback_str[:1000],  # Limit traceback length
+            model=getattr(vibesurf_agent.llm, 'model_name', None),
+            session_id=state.session_id,
+            function_name='_vibesurf_agent_node_impl'
+        )
+        vibesurf_agent.telemetry.capture(exception_event)
+        vibesurf_agent.telemetry.flush()
+
         state.final_response = f"Task execution failed: {str(e)}"
         state.is_complete = True
         await log_agent_activity(state, agent_name, "error", f"Agent failed: {str(e)}")
@@ -1606,7 +1645,27 @@ Please continue with your assigned work, incorporating this guidance only if it'
             upload_files = await self.process_upload_files(upload_files)
 
             if not self.message_history:
-                self.message_history.append(SystemMessage(content=VIBESURF_SYSTEM_PROMPT))
+                vibesurf_system_prompt = VIBESURF_SYSTEM_PROMPT
+                if self.settings.agent_mode == "thinking":
+                    vibesurf_system_prompt += """
+You must ALWAYS respond with a valid JSON in this exact format:
+{{
+  "thinking": "A structured <think>-style reasoning.",
+  "action":[{{"<action_name>": {{<action_params>}}]
+}}
+
+Action list should NEVER be empty and Each step can only output one action. If multiple actions are output, only the first one will be executed.
+                    """
+                else:
+                    vibesurf_system_prompt += """
+You must ALWAYS respond with a valid JSON in this exact format:
+{{
+  "action":[{{"<action_name>": {{<action_params>}}]
+}}
+
+Action list should NEVER be empty and Each step can only output one action. If multiple actions are output, only the first one will be executed.
+                    """
+                self.message_history.append(SystemMessage(content=vibesurf_system_prompt))
 
             # Format processed upload files for prompt
             user_request = f"* User's New Request:\n{task}\n"

vibe_surf/backend/llm_config.py

@@ -24,6 +24,17 @@ LLM_PROVIDERS = {
         "gemini-2.5-pro",
         "gemini-2.5-flash",
     ],
+    "kimi": [
+        "kimi-k2-0905-preview",
+        "kimi-k2-0711-preview",
+        "kimi-k2-turbo-preview"
+    ],
+    "qwen": [
+        "qwen-flash",
+        "qwen-plus",
+        "qwen3-vl-plus",
+        "qwen3-vl-flash"
+    ],
     "azure_openai": [
         "gpt-4o",
         "gpt-4o-mini",
@@ -58,6 +69,12 @@ LLM_PROVIDERS = {
     "anthropic_bedrock": [
     ],
     "openai_compatible": [
+    ],
+    "lm_studio":[
+        "qwen/qwen3-vl-8b",
+        "qwen/qwen3-vl-30b",
+        "qwen/qwen3-14b",
+        "openai/gpt-oss-20b"
     ]
 }
 
@@ -152,6 +169,30 @@ PROVIDER_METADATA = {
         "supports_tools": True,
         "supports_vision": True,
         "default_model": ""
+    },
+    "qwen": {
+        "display_name": "Qwen",
+        "requires_api_key": True,
+        "requires_base_url": False,
+        "supports_tools": True,
+        "supports_vision": False,
+        "default_model": ""
+    },
+    "kimi": {
+        "display_name": "Kimi",
+        "requires_api_key": True,
+        "requires_base_url": False,
+        "supports_tools": True,
+        "supports_vision": False,
+        "default_model": ""
+    },
+    "lm_studio": {
+        "display_name": "LM Studio",
+        "requires_api_key": False,
+        "requires_base_url": False,
+        "supports_tools": True,
+        "supports_vision": True,
+        "default_model": ""
     }
 }
 

vibe_surf/backend/shared_state.py

@@ -505,32 +505,6 @@ async def initialize_vibesurf_components():
         # Initialize LLM from default profile (if available) or fallback to environment variables
         llm = await _initialize_default_llm()
 
-        # Initialize browser manager
-        if browser_manager:
-            main_browser_session = browser_manager.main_browser_session
-        else:
-            from screeninfo import get_monitors
-            primary_monitor = get_monitors()[0]
-            _update_extension_backend_url(envs["VIBESURF_EXTENSION"], backend_url)
-            
-            browser_profile = AgentBrowserProfile(
-                executable_path=browser_execution_path,
-                user_data_dir=browser_user_data,
-                headless=False,
-                keep_alive=True,
-                auto_download_pdfs=False,
-                highlight_elements=True,
-                custom_extensions=[envs["VIBESURF_EXTENSION"]],
-                window_size={"width": primary_monitor.width, "height": primary_monitor.height}
-            )
-
-            # Initialize components
-            main_browser_session = AgentBrowserSession(browser_profile=browser_profile)
-            await main_browser_session.start()
-        browser_manager = BrowserManager(
-            main_browser_session=main_browser_session
-        )
-
         # Load active MCP servers from database
         mcp_server_config = await _load_active_mcp_servers()
 
@@ -564,6 +538,32 @@ async def initialize_vibesurf_components():
             )
             logger.info(f"✅ Registered Composio tools from {len(toolkit_tools_dict)} enabled toolkits")
 
+        # Initialize browser manager
+        if browser_manager:
+            main_browser_session = browser_manager.main_browser_session
+        else:
+            from screeninfo import get_monitors
+            primary_monitor = get_monitors()[0]
+            _update_extension_backend_url(envs["VIBESURF_EXTENSION"], backend_url)
+
+            browser_profile = AgentBrowserProfile(
+                executable_path=browser_execution_path,
+                user_data_dir=browser_user_data,
+                headless=False,
+                keep_alive=True,
+                auto_download_pdfs=False,
+                highlight_elements=True,
+                custom_extensions=[envs["VIBESURF_EXTENSION"]],
+                window_size={"width": primary_monitor.width, "height": primary_monitor.height}
+            )
+
+            # Initialize components
+            main_browser_session = AgentBrowserSession(browser_profile=browser_profile)
+            await main_browser_session.start()
+        browser_manager = BrowserManager(
+            main_browser_session=main_browser_session
+        )
+
         # Initialize VibeSurfAgent
         vibesurf_agent = VibeSurfAgent(
             llm=llm,