vibesurf 0.1.7__py3-none-any.whl → 0.1.9__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.7'
-__version_tuple__ = version_tuple = (0, 1, 7)
+__version__ = version = '0.1.9'
+__version_tuple__ = version_tuple = (0, 1, 9)
 
 __commit_id__ = commit_id = None

vibe_surf/agents/browser_use_agent.py

@@ -53,12 +53,12 @@ from browser_use.agent.views import (
     StepMetadata,
 )
 from pydantic import BaseModel, ConfigDict, Field, ValidationError, create_model, model_validator
-from browser_use.browser import BrowserProfile, BrowserSession
+from browser_use import Browser, BrowserProfile, BrowserSession
 from browser_use.browser.session import DEFAULT_BROWSER_PROFILE
 from browser_use.browser.views import BrowserStateSummary
 from browser_use.config import CONFIG
-from browser_use.controller.registry.views import ActionModel
-from browser_use.controller.service import Controller
+from browser_use.tools.registry.views import ActionModel
+from browser_use.tools.service import Controller, Tools
 from browser_use.dom.views import DOMInteractedElement
 from browser_use.filesystem.file_system import FileSystem
 from browser_use.observability import observe, observe_debug
@@ -79,45 +79,6 @@ from vibe_surf.controller.file_system import CustomFileSystem
 Context = TypeVar('Context')
 
 
-def log_response(response: AgentOutput, registry=None, logger=None) -> None:
-    """Utility function to log the model's response."""
-
-    # Use module logger if no logger provided
-    if logger is None:
-        logger = logging.getLogger(__name__)
-
-    # Only log thinking if it's present
-    if response.current_state.thinking:
-        logger.info(f'💡 Thinking:\n{response.current_state.thinking}')
-
-    # Only log evaluation if it's not empty
-    eval_goal = response.current_state.evaluation_previous_goal
-    if eval_goal:
-        if 'success' in eval_goal.lower():
-            emoji = '👍'
-            # Green color for success
-            logger.info(f'  \033[32m{emoji} Eval: {eval_goal}\033[0m')
-        elif 'failure' in eval_goal.lower():
-            emoji = '⚠️'
-            # Red color for failure
-            logger.info(f'  \033[31m{emoji} Eval: {eval_goal}\033[0m')
-        else:
-            emoji = '❔'
-            # No color for unknown/neutral
-            logger.info(f'  {emoji} Eval: {eval_goal}')
-
-    # Always log memory if present
-    if response.current_state.memory:
-        logger.debug(f'🧠 Memory: {response.current_state.memory}')
-
-    # Only log next goal if it's not empty
-    next_goal = response.current_state.next_goal
-    if next_goal:
-        # Blue color for next goal
-        logger.info(f'  \033[34m🎯 Next goal: {next_goal}\033[0m')
-    else:
-        logger.info('')  # Add empty line for spacing
-
 
 class BrowserUseAgent(Agent):
     @time_execution_sync('--init')
@@ -128,7 +89,9 @@ class BrowserUseAgent(Agent):
             # Optional parameters
             browser_profile: BrowserProfile | None = None,
             browser_session: BrowserSession | None = None,
-            controller: Controller[Context] | None = None,
+            browser: Browser | None = None,  # Alias for browser_session
+            tools: Tools[Context] | None = None,
+            controller: Tools[Context] | None = None,  # Alias for tools
             # Initial agent run parameters
             sensitive_data: dict[str, str | dict[str, str]] | None = None,
             initial_actions: list[dict[str, dict[str, Any]]] | None = None,
@@ -147,14 +110,11 @@ class BrowserUseAgent(Agent):
             # Agent settings
             output_model_schema: type[AgentStructuredOutput] | None = None,
             use_vision: bool = True,
-            use_vision_for_planner: bool = False,  # Deprecated
             save_conversation_path: str | Path | None = None,
             save_conversation_path_encoding: str | None = 'utf-8',
             max_failures: int = 3,
-            retry_delay: int = 10,
             override_system_message: str | None = None,
             extend_system_message: str | None = None,
-            validate_output: bool = False,
             generate_gif: bool | str = False,
             available_file_paths: list[str] | None = None,
             include_attributes: list[str] | None = None,
@@ -163,12 +123,7 @@ class BrowserUseAgent(Agent):
             flash_mode: bool = False,
             max_history_items: int | None = None,
             page_extraction_llm: BaseChatModel | None = None,
-            planner_llm: BaseChatModel | None = None,  # Deprecated
-            planner_interval: int = 1,  # Deprecated
-            is_planner_reasoning: bool = False,  # Deprecated
-            extend_planner_system_message: str | None = None,  # Deprecated
             injected_agent_state: AgentState | None = None,
-            context: Context | None = None,
             source: str | None = None,
             file_system_path: str | None = None,
             task_id: str | None = None,
@@ -179,38 +134,11 @@ class BrowserUseAgent(Agent):
             vision_detail_level: Literal['auto', 'low', 'high'] = 'auto',
             llm_timeout: int = 90,
             step_timeout: int = 120,
-            preload: bool = True,
+            directly_open_url: bool = True,
             include_recent_events: bool = False,
             allow_parallel_action_types: list[str] = ["extract_structured_data", "extract_content_from_file"],
             **kwargs,
     ):
-        if not isinstance(llm, BaseChatModel):
-            raise ValueError('invalid llm, must be from browser_use.llm')
-        # Check for deprecated planner parameters
-        planner_params = [
-            planner_llm,
-            use_vision_for_planner,
-            is_planner_reasoning,
-            extend_planner_system_message,
-        ]
-        if any(param is not None and param is not False for param in planner_params) or planner_interval != 1:
-            self.logger.warning(
-                '⚠️ Planner functionality has been removed in browser-use v0.3.3+. '
-                'The planner_llm, use_vision_for_planner, planner_interval, is_planner_reasoning, '
-                'and extend_planner_system_message parameters are deprecated and will be ignored. '
-                'Please remove these parameters from your Agent() initialization.'
-            )
-
-        # Check for deprecated memory parameters
-        if kwargs.get('enable_memory', False) or kwargs.get('memory_config') is not None:
-            self.logger.warning(
-                'Memory support has been removed as of version 0.3.2. '
-                'The agent context for memory is significantly improved and no longer requires the old memory system. '
-                "Please remove the 'enable_memory' and 'memory_config' parameters."
-            )
-            kwargs['enable_memory'] = False
-            kwargs['memory_config'] = None
-
         if page_extraction_llm is None:
             page_extraction_llm = llm
         if available_file_paths is None:
@@ -221,39 +149,49 @@ class BrowserUseAgent(Agent):
         self.session_id: str = uuid7str()
         self.allow_parallel_action_types = allow_parallel_action_types
 
+        browser_profile = browser_profile or DEFAULT_BROWSER_PROFILE
+
+        # Handle browser vs browser_session parameter (browser takes precedence)
+        if browser and browser_session:
+            raise ValueError(
+                'Cannot specify both "browser" and "browser_session" parameters. Use "browser" for the cleaner API.')
+        browser_session = browser or browser_session
+
+        self.browser_session = browser_session or BrowserSession(
+            browser_profile=browser_profile,
+            id=uuid7str()[:-4] + self.id[-4:],  # re-use the same 4-char suffix so they show up together in logs
+        )
+
         # Initialize available file paths as direct attribute
         self.available_file_paths = available_file_paths
 
-        # Temporary logger for initialization (will be replaced by property)
-        self._logger = None
-
         # Core components
         self.task = task
         self.llm = llm
-        self.preload = preload
+        self.directly_open_url = directly_open_url
         self.include_recent_events = include_recent_events
-        self.controller = (
-            controller if controller is not None else Controller(display_files_in_done_text=display_files_in_done_text)
-        )
+        if tools is not None:
+            self.tools = tools
+        elif controller is not None:
+            self.tools = controller
+        else:
+            self.tools = Tools(display_files_in_done_text=display_files_in_done_text)
 
         # Structured output
         self.output_model_schema = output_model_schema
         if self.output_model_schema is not None:
-            self.controller.use_structured_output_action(self.output_model_schema)
+            self.tools.use_structured_output_action(self.output_model_schema)
 
         self.sensitive_data = sensitive_data
 
         self.settings = AgentSettings(
             use_vision=use_vision,
             vision_detail_level=vision_detail_level,
-            use_vision_for_planner=False,  # Always False now (deprecated)
             save_conversation_path=save_conversation_path,
             save_conversation_path_encoding=save_conversation_path_encoding,
             max_failures=max_failures,
-            retry_delay=retry_delay,
             override_system_message=override_system_message,
             extend_system_message=extend_system_message,
-            validate_output=validate_output,
             generate_gif=generate_gif,
             include_attributes=include_attributes,
             max_actions_per_step=max_actions_per_step,
@@ -261,10 +199,6 @@ class BrowserUseAgent(Agent):
             flash_mode=flash_mode,
             max_history_items=max_history_items,
             page_extraction_llm=page_extraction_llm,
-            planner_llm=None,  # Always None now (deprecated)
-            planner_interval=1,  # Always 1 now (deprecated)
-            is_planner_reasoning=False,  # Always False now (deprecated)
-            extend_planner_system_message=None,  # Always None now (deprecated)
             calculate_cost=calculate_cost,
             include_tool_call_examples=include_tool_call_examples,
             llm_timeout=llm_timeout,
@@ -275,7 +209,6 @@ class BrowserUseAgent(Agent):
         self.token_cost_service = TokenCost(include_cost=calculate_cost)
         self.token_cost_service.register_llm(llm)
         self.token_cost_service.register_llm(page_extraction_llm)
-        # Note: No longer registering planner_llm (deprecated)
 
         # Initialize state
         self.state = injected_agent_state or AgentState()
@@ -297,8 +230,19 @@ class BrowserUseAgent(Agent):
         # Action setup
         self._setup_action_models()
         self._set_browser_use_version_and_source(source)
-        self.initial_actions = self._convert_initial_actions(initial_actions) if initial_actions else None
 
+        initial_url = None
+
+        # only load url if no initial actions are provided
+        if self.directly_open_url and not self.state.follow_up_task and not initial_actions:
+            initial_url = self._extract_url_from_task(self.task)
+            if initial_url:
+                self.logger.info(f'🔗 Found URL in task: {initial_url}, adding as initial action...')
+                initial_actions = [{'go_to_url': {'url': initial_url, 'new_tab': False}}]
+
+        self.initial_url = initial_url
+
+        self.initial_actions = self._convert_initial_actions(initial_actions) if initial_actions else None
         # Verify we can connect to the model
         self._verify_and_setup_llm()
 
@@ -308,40 +252,35 @@ class BrowserUseAgent(Agent):
             self.logger.warning(
                 '⚠️ DeepSeek models do not support use_vision=True yet. Setting use_vision=False for now...')
             self.settings.use_vision = False
-        # Note: No longer checking planner_llm for DeepSeek (deprecated)
 
         # Handle users trying to use use_vision=True with XAI models
         if 'grok' in self.llm.model.lower():
             self.logger.warning('⚠️ XAI models do not support use_vision=True yet. Setting use_vision=False for now...')
             self.settings.use_vision = False
-        # Note: No longer checking planner_llm for XAI models (deprecated)
 
         self.logger.info(f'🧠 Starting a browser-use version {self.version} with model={self.llm.model}')
-        self.logger.debug(
+        self.logger.info(
             f'{" +vision" if self.settings.use_vision else ""}'
             f' extraction_model={self.settings.page_extraction_llm.model if self.settings.page_extraction_llm else "Unknown"}'
-            # Note: No longer logging planner_model (deprecated)
             f'{" +file_system" if self.file_system else ""}'
         )
 
         # Initialize available actions for system prompt (only non-filtered actions)
         # These will be used for the system prompt to maintain caching
-        self.unfiltered_actions = self.controller.registry.get_prompt_description()
+        self.unfiltered_actions = self.tools.registry.get_prompt_description()
 
         # Initialize message manager with state
         # Initial system prompt with all actions - will be updated during each step
-        system_message = SystemPrompt(
+        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,
                 use_thinking=self.settings.use_thinking,
                 flash_mode=self.settings.flash_mode,
-            ).get_system_message()
-        self.logger.debug(system_message)
-        self._message_manager = MessageManager(
-            task=task,
-            system_message=system_message,
+            ).get_system_message(),
             file_system=self.file_system,
             state=self.state.message_manager_state,
             use_thinking=self.settings.use_thinking,
@@ -354,13 +293,6 @@ class BrowserUseAgent(Agent):
             include_recent_events=self.include_recent_events,
         )
 
-        browser_profile = browser_profile or DEFAULT_BROWSER_PROFILE
-
-        self.browser_session = browser_session or BrowserSession(
-            browser_profile=browser_profile,
-            id=uuid7str()[:-4] + self.id[-4:],  # re-use the same 4-char suffix so they show up together in logs
-        )
-
         if self.sensitive_data:
             # Check if sensitive_data has domain-specific credentials
             has_domain_specific_credentials = any(isinstance(v, dict) for v in self.sensitive_data.values())
@@ -430,9 +362,6 @@ class BrowserUseAgent(Agent):
         self.register_done_callback = register_done_callback
         self.register_external_agent_status_raise_error_callback = register_external_agent_status_raise_error_callback
 
-        # Context
-        self.context: Context | None = context
-
         # Telemetry
         self.telemetry = ProductTelemetry()
 
@@ -586,39 +515,6 @@ class BrowserUseAgent(Agent):
 
             self.logger.debug('🔧 Browser session started with watchdogs attached')
 
-            # Check if task contains a URL and add it as an initial action (only if preload is enabled)
-            if self.preload:
-                initial_url = self._extract_url_from_task(self.task)
-                if initial_url:
-                    self.logger.info(f'🔗 Found URL in task: {initial_url}, adding as initial action...')
-
-                    # Create a go_to_url action for the initial URL
-                    go_to_url_action = {
-                        'go_to_url': {
-                            'url': initial_url,
-                            'new_tab': False,  # Navigate in current tab
-                        }
-                    }
-
-                    # Add to initial_actions or create new list if none exist
-                    if self.initial_actions:
-                        # Convert back to dict format, prepend URL navigation, then convert back
-                        initial_actions_dicts = []
-                        for action in self.initial_actions:
-                            action_data = action.model_dump(exclude_unset=True)
-                            initial_actions_dicts.append(action_data)
-
-                        # Prepend the go_to_url action
-                        initial_actions_dicts = [go_to_url_action] + initial_actions_dicts
-
-                        # Convert back to ActionModel instances
-                        self.initial_actions = self._convert_initial_actions(initial_actions_dicts)
-                    else:
-                        # Create new initial_actions with just the go_to_url
-                        self.initial_actions = self._convert_initial_actions([go_to_url_action])
-
-                    self.logger.debug(f'✅ Added navigation to {initial_url} as initial action')
-
             # Execute initial actions if provided
             if self.initial_actions:
                 self.logger.debug(f'⚡ Executing {len(self.initial_actions)} initial actions...')
@@ -964,14 +860,13 @@ class BrowserUseAgent(Agent):
             self.logger.info(f'  🦾 {blue}[PARALLEL ACTION {action_index + 1}/{total_actions}]{reset} {action_params}')
             
             # Execute the action
-            result = await self.controller.act(
+            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,
-                context=self.context,
             )
             
             time_end = time.time()
@@ -1086,14 +981,13 @@ class BrowserUseAgent(Agent):
         
         self.logger.info(f'  🦾 {blue}[ACTION {action_index + 1}/{total_actions}]{reset} {action_params}')
 
-        result = await self.controller.act(
+        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,
-            context=self.context,
         )
 
         time_end = time.time()

vibe_surf/agents/vibe_surf_agent.py

@@ -30,7 +30,7 @@ from vibe_surf.agents.prompts.vibe_surf_prompt import (
     SUPERVISOR_AGENT_SYSTEM_PROMPT,
 )
 from vibe_surf.browser.browser_manager import BrowserManager
-from vibe_surf.controller.vibesurf_controller import VibeSurfController
+from vibe_surf.controller.vibesurf_tools import VibeSurfController
 
 logger = logging.getLogger(__name__)
 
@@ -798,7 +798,6 @@ async def execute_parallel_browser_tasks(state: VibeSurfState) -> List[BrowserTa
                 file_system_path=state.task_dir,
                 register_new_step_callback=step_callback,
                 extend_system_message="Please make sure the language of your output in JSON value should remain the same as the user's request or task.",
-                preload=False
             )
             agents.append(agent)
 
@@ -896,7 +895,6 @@ async def execute_single_browser_tasks(state: VibeSurfState) -> List[BrowserTask
                 task_id=f"{state.task_id}-{i}",
                 file_system_path=state.task_dir,
                 register_new_step_callback=step_callback,
-                preload=False,
                 extend_system_message="Please make sure the language of your output in JSON values should remain the same as the user's request or task."
             )
 
@@ -1502,11 +1500,14 @@ class VibeSurfAgent:
             if upload_files and not isinstance(upload_files, list):
                 upload_files = [upload_files]
             upload_files_md = format_upload_files_list(upload_files)
+            user_request = f"* User's New Request:\n{task}\n"
+            if upload_files:
+                user_request += f"* User Uploaded Files:\n{upload_files_md}\n"
             supervisor_message_history.append(
                 UserMessage(
-                    content=f"* User's New Request:\n{task}\n* Uploaded Files for Completing Task:\n{upload_files_md}\n")
+                    content=user_request)
             )
-            logger.info(f"* User's New Request:\n{task}\n* Uploaded Files for Completing Task:\n{upload_files_md}\n")
+            logger.info(user_request)
 
             if self.cur_session_id not in self.activity_logs:
                 self.activity_logs[self.cur_session_id] = []
@@ -1604,7 +1605,7 @@ class VibeSurfAgent:
         if session_id is None:
             session_id = self.cur_session_id
         
-        logger.info(f"📊 GET_ACTIVITY_LOGS DEBUG - Session: {session_id}, Message Index: {message_index}, Current Session: {self.cur_session_id}")
+        logger.debug(f"📊 GET_ACTIVITY_LOGS DEBUG - Session: {session_id}, Message Index: {message_index}, Current Session: {self.cur_session_id}")
         
         # Ensure session_id exists in activity_logs
         if session_id not in self.activity_logs:
@@ -1612,10 +1613,10 @@ class VibeSurfAgent:
             return None
             
         session_logs = self.activity_logs[session_id]
-        logger.info(f"📋 Session {session_id} has {len(session_logs)} activity logs")
+        logger.debug(f"📋 Session {session_id} has {len(session_logs)} activity logs")
         
         if message_index is None:
-            logger.info(f"📤 Returning all {len(session_logs)} activity logs for session {session_id}")
+            logger.debug(f"📤 Returning all {len(session_logs)} activity logs for session {session_id}")
             return session_logs
         else:
             if message_index >= len(session_logs):
@@ -1623,7 +1624,7 @@ class VibeSurfAgent:
                 return None
             else:
                 activity_log = session_logs[message_index]
-                logger.info(f"📤 Returning activity log at index {message_index}: {activity_log.get('agent_name', 'unknown')} - {activity_log.get('agent_status', 'unknown')}")
+                logger.debug(f"📤 Returning activity log at index {message_index}: {activity_log.get('agent_name', 'unknown')} - {activity_log.get('agent_status', 'unknown')}")
                 return activity_log
 
     async def _get_result(self, state) -> str:

vibe_surf/backend/shared_state.py

@@ -15,7 +15,7 @@ from pathlib import Path
 
 # VibeSurf components
 from vibe_surf.agents.vibe_surf_agent import VibeSurfAgent
-from vibe_surf.controller.vibesurf_controller import VibeSurfController
+from vibe_surf.controller.vibesurf_tools import VibeSurfController
 from vibe_surf.browser.browser_manager import BrowserManager
 from browser_use.llm.base import BaseChatModel
 from browser_use.llm.openai.chat import ChatOpenAI

vibe_surf/backend/utils/encryption.py

@@ -5,47 +5,17 @@ Uses machine MAC address for key derivation to encrypt sensitive data like API k
 """
 
 import hashlib
+import pdb
 import uuid
 import base64
 from cryptography.fernet import Fernet
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
-import logging
-
-logger = logging.getLogger(__name__)
+from getmac import get_mac_address
 
-import psutil
 import logging
 
-
-def get_machine_id() -> str:
-    """Get unique machine identifier based on MAC address."""
-    try:
-        nics = psutil.net_if_addrs()
-
-        priority_interfaces = ['en0', 'eth0', 'en1']
-
-        for interface in priority_interfaces:
-            if interface in nics:
-                for addr in nics[interface]:
-                    if addr.family == psutil.AF_LINK:
-                        mac = addr.address
-                        if mac and mac != '00:00:00:00:00:00':
-                            return mac.replace(':', '').upper()
-
-        for interface, addrs in nics.items():
-            for addr in addrs:
-                if addr.family == psutil.AF_LINK:
-                    mac = addr.address
-                    if (mac and mac != '00:00:00:00:00:00' and
-                            not mac.startswith('02:') and
-                            not interface.startswith(('lo', 'docker', 'veth'))):
-                        return mac.replace(':', '').upper()
-
-    except Exception as e:
-        logging.warning(f"Could not get MAC address via psutil: {e}")
-
-    return "VIBESURF_WARMSHAO"
+logger = logging.getLogger(__name__)
 
 
 def derive_key(machine_id: str, salt: bytes = None) -> bytes:
@@ -69,8 +39,8 @@ def derive_key(machine_id: str, salt: bytes = None) -> bytes:
 
 def get_encryption_key() -> bytes:
     """Get the encryption key for this machine."""
-    machine_id = get_machine_id()
-    return derive_key(machine_id)
+    machine_id1 = get_mac_address()
+    return derive_key(machine_id1)
 
 def encrypt_api_key(api_key: str) -> str:
     """

vibe_surf/browser/agen_browser_profile.py

@@ -20,8 +20,8 @@ from browser_use.browser import BrowserProfile
 
 
 class AgentBrowserProfile(BrowserProfile):
-    custom_extensions: list = Field(
-        default=lambda: [],
+    custom_extensions: list[str] | None = Field(
+        default=None,
         description="Enable Custom Extensions.",
     )
 
@@ -121,10 +121,9 @@ class AgentBrowserProfile(BrowserProfile):
             '--enable-extension-activity-logging',
             '--disable-features=DisableLoadExtensionCommandLineSwitch'
         ]
-
         if self.custom_extensions:
             extension_paths.extend(self.custom_extensions)
         if extension_paths:
             args.append(f'--load-extension={",".join(extension_paths)}')
-        print(args)
+        logger.info(f"Extension infos: {args}")
         return args