vibesurf 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

vibe_surf/backend/database/schemas.py

@@ -58,7 +58,7 @@ class McpServerConfig(BaseModel):
     mcpServers: Dict[str, McpServerParams] = Field(default_factory=dict)
 
 class ControllerConfiguration(BaseModel):
-    """Schema for Task.mcp_server_config JSON field (legacy controller config)"""
+    """Schema for Task.mcp_server_config JSON field (legacy tools config)"""
     
     # Action control
     exclude_actions: List[str] = Field(default_factory=list)

vibe_surf/backend/main.py

@@ -25,8 +25,10 @@ from .api.browser import router as browser_router
 from . import shared_state
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 app = FastAPI(
     title="VibeSurf Backend API",

vibe_surf/backend/shared_state.py

@@ -15,7 +15,8 @@ from pathlib import Path
 
 # VibeSurf components
 from vibe_surf.agents.vibe_surf_agent import VibeSurfAgent
-from vibe_surf.controller.vibesurf_tools import VibeSurfController
+from vibe_surf.tools.browser_use_tools import BrowserUseTools
+from vibe_surf.tools.vibesurf_tools import VibeSurfTools
 from vibe_surf.browser.browser_manager import BrowserManager
 from browser_use.llm.base import BaseChatModel
 from browser_use.llm.openai.chat import ChatOpenAI
@@ -29,7 +30,7 @@ logger = logging.getLogger(__name__)
 # Global VibeSurf components
 vibesurf_agent: Optional[VibeSurfAgent] = None
 browser_manager: Optional[BrowserManager] = None
-controller: Optional[VibeSurfController] = None
+vibesurf_tools: Optional[VibeSurfTools] = None
 llm: Optional[BaseChatModel] = None
 db_manager: Optional['DatabaseManager'] = None
 
@@ -50,10 +51,13 @@ active_task: Optional[Dict[str, Any]] = None
 
 def get_all_components():
     """Get all components as a dictionary"""
+    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager
+    global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs
+
     return {
         "vibesurf_agent": vibesurf_agent,
         "browser_manager": browser_manager,
-        "controller": controller,
+        "tools": vibesurf_tools,
         "llm": llm,
         "db_manager": db_manager,
         "workspace_dir": workspace_dir,
@@ -67,15 +71,15 @@ def get_all_components():
 
 def set_components(**kwargs):
     """Update global components"""
-    global vibesurf_agent, browser_manager, controller, llm, db_manager
+    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager
     global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs
 
     if "vibesurf_agent" in kwargs:
         vibesurf_agent = kwargs["vibesurf_agent"]
     if "browser_manager" in kwargs:
         browser_manager = kwargs["browser_manager"]
-    if "controller" in kwargs:
-        controller = kwargs["controller"]
+    if "tools" in kwargs:
+        vibesurf_tools = kwargs["tools"]
     if "llm" in kwargs:
         llm = kwargs["llm"]
     if "db_manager" in kwargs:
@@ -223,8 +227,8 @@ def clear_active_task():
 
 
 async def _check_and_update_mcp_servers(db_session):
-    """Check if MCP server configuration has changed and update controller if needed"""
-    global controller, active_mcp_server
+    """Check if MCP server configuration has changed and update tools if needed"""
+    global vibesurf_tools, active_mcp_server
 
     try:
         if not db_session:
@@ -238,21 +242,21 @@ async def _check_and_update_mcp_servers(db_session):
 
         # Compare with shared state
         if current_active_servers != active_mcp_server:
-            logger.info(f"MCP server configuration changed. Updating controller...")
+            logger.info(f"MCP server configuration changed. Updating tools...")
             logger.info(f"Old config: {active_mcp_server}")
             logger.info(f"New config: {current_active_servers}")
 
             # Update shared state
             active_mcp_server = current_active_servers.copy()
 
-            # Create new MCP server config for controller
+            # Create new MCP server config for tools
             mcp_server_config = await _build_mcp_server_config(active_profiles)
 
             # Unregister old MCP clients and register new ones
-            if controller:
-                await controller.unregister_mcp_clients()
-                controller.mcp_server_config = mcp_server_config
-                await controller.register_mcp_clients()
+            if vibesurf_tools:
+                await vibesurf_tools.unregister_mcp_clients()
+                vibesurf_tools.mcp_server_config = mcp_server_config
+                await vibesurf_tools.register_mcp_clients()
                 logger.info("✅ Controller MCP configuration updated successfully")
 
     except Exception as e:
@@ -310,25 +314,13 @@ async def _load_active_mcp_servers():
 
 async def initialize_vibesurf_components():
     """Initialize VibeSurf components from environment variables and default LLM profile"""
-    global vibesurf_agent, browser_manager, controller, llm, db_manager
+    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager
     global workspace_dir, browser_execution_path, browser_user_data, envs
+    from vibe_surf import common
 
     try:
         # Load environment variables
-        env_workspace_dir = os.getenv("VIBESURF_WORKSPACE", "")
-        if not env_workspace_dir or not env_workspace_dir.strip():
-            # Set default workspace directory based on OS
-            if platform.system() == "Windows":
-                default_workspace = os.path.join(os.environ.get("APPDATA", ""), "VibeSurf")
-            elif platform.system() == "Darwin":  # macOS
-                default_workspace = os.path.join(os.path.expanduser("~"), "Library", "Application Support", "VibeSurf")
-            else:  # Linux and others
-                default_workspace = os.path.join(os.path.expanduser("~"), ".vibesurf")
-            workspace_dir = default_workspace
-        else:
-            workspace_dir = env_workspace_dir
-        workspace_dir = os.path.abspath(workspace_dir)
-        os.makedirs(workspace_dir, exist_ok=True)
+        workspace_dir = common.get_workspace_dir()
         logger.info("WorkSpace directory: {}".format(workspace_dir))
 
         # Load environment configuration from envs.json
@@ -438,19 +430,19 @@ async def initialize_vibesurf_components():
         # Load active MCP servers from database
         mcp_server_config = await _load_active_mcp_servers()
 
-        # Initialize vibesurf controller with MCP server config
-        controller = VibeSurfController(mcp_server_config=mcp_server_config)
+        # Initialize vibesurf tools with MCP server config
+        vibesurf_tools = VibeSurfTools(mcp_server_config=mcp_server_config)
 
         # Register MCP clients if there are any active MCP servers
         if mcp_server_config and mcp_server_config.get("mcpServers"):
-            await controller.register_mcp_clients()
+            await vibesurf_tools.register_mcp_clients()
             logger.info(f"✅ Registered {len(mcp_server_config['mcpServers'])} MCP servers")
 
         # Initialize VibeSurfAgent
         vibesurf_agent = VibeSurfAgent(
             llm=llm,
             browser_manager=browser_manager,
-            controller=controller,
+            tools=vibesurf_tools,
             workspace_dir=workspace_dir
         )
 
@@ -532,8 +524,9 @@ async def update_llm_from_profile(profile_name: str):
 
                 # Update global state
                 llm = new_llm
-                if vibesurf_agent:
-                    vibesurf_agent.llm = new_llm
+                if vibesurf_agent and vibesurf_agent.token_cost_service:
+                    # FIX: Register new LLM with token cost service to maintain tracking
+                    vibesurf_agent.llm = vibesurf_agent.token_cost_service.register_llm(new_llm)
 
                 logger.info(f"✅ LLM updated to profile: {profile_name}")
                 return True

vibe_surf/backend/utils/encryption.py

@@ -15,7 +15,9 @@ from getmac import get_mac_address
 
 import logging
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 def derive_key(machine_id: str, salt: bytes = None) -> bytes:

vibe_surf/backend/utils/llm_factory.py

@@ -6,26 +6,29 @@ from typing import Optional
 import logging
 from ..llm_config import get_supported_providers, is_provider_supported
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
+
 
 def create_llm_from_profile(llm_profile):
     """Create LLM instance from LLMProfile database record (dict or object)"""
     try:
         # Import LLM classes from browser_use and vibe_surf
         from browser_use.llm import (
-            ChatOpenAI, ChatAnthropic, ChatGoogle, ChatAzureOpenAI, 
-            ChatGroq, ChatOllama, ChatOpenRouter, ChatDeepSeek, 
+            ChatOpenAI, ChatAnthropic, ChatGoogle, ChatAzureOpenAI,
+            ChatGroq, ChatOllama, ChatOpenRouter, ChatDeepSeek,
             ChatAWSBedrock, ChatAnthropicBedrock
         )
         from vibe_surf.llm import ChatOpenAICompatible
-        
+
         # Handle both dict and object access patterns
         def get_attr(obj, key, default=None):
             if isinstance(obj, dict):
                 return obj.get(key, default)
             else:
                 return getattr(obj, key, default)
-        
+
         provider = get_attr(llm_profile, 'provider')
         model = get_attr(llm_profile, 'model')
         api_key = get_attr(llm_profile, 'api_key')  # Should already be decrypted by queries
@@ -36,11 +39,11 @@ def create_llm_from_profile(llm_profile):
         frequency_penalty = get_attr(llm_profile, 'frequency_penalty')
         seed = get_attr(llm_profile, 'seed')
         provider_config = get_attr(llm_profile, 'provider_config', {})
-        
+
         # Validate provider
         if not is_provider_supported(provider):
             raise ValueError(f"Unsupported provider: {provider}. Supported: {get_supported_providers()}")
-        
+
         # Define provider-specific parameter support
         provider_param_support = {
             "openai": ["temperature"],
@@ -55,11 +58,11 @@ def create_llm_from_profile(llm_profile):
             "anthropic_bedrock": ["temperature"],
             "openai_compatible": ["temperature"]
         }
-        
+
         # Build common parameters based on provider support
         supported_params = provider_param_support.get(provider, [])
         common_params = {}
-        
+
         if temperature is not None and "temperature" in supported_params:
             common_params["temperature"] = temperature
         if max_tokens is not None and "max_tokens" in supported_params:
@@ -70,11 +73,11 @@ def create_llm_from_profile(llm_profile):
             common_params["frequency_penalty"] = frequency_penalty
         if seed is not None and "seed" in supported_params:
             common_params["seed"] = seed
-        
+
         # Add provider-specific config if available
         if provider_config:
             common_params.update(provider_config)
-        
+
         # Create LLM instance based on provider
         if provider == "openai":
             params = {
@@ -85,21 +88,21 @@ def create_llm_from_profile(llm_profile):
             if base_url:
                 params["base_url"] = base_url
             return ChatOpenAI(**params)
-        
+
         elif provider == "anthropic":
             return ChatAnthropic(
                 model=model,
                 api_key=api_key,
                 **common_params
             )
-        
+
         elif provider == "google":
             return ChatGoogle(
                 model=model,
                 api_key=api_key,
                 **common_params
             )
-        
+
         elif provider == "azure_openai":
             if not base_url:
                 raise ValueError("Azure OpenAI requires base_url (azure_endpoint)")
@@ -110,14 +113,14 @@ def create_llm_from_profile(llm_profile):
                 azure_endpoint=base_url,
                 **common_params
             )
-        
+
         elif provider == "groq":
             return ChatGroq(
                 model=model,
                 api_key=api_key,
                 **common_params
             )
-        
+
         elif provider == "ollama":
             params = {
                 "model": model,
@@ -128,21 +131,21 @@ def create_llm_from_profile(llm_profile):
             else:
                 params["host"] = "http://localhost:11434"  # Default Ollama URL
             return ChatOllama(**params)
-        
+
         elif provider == "openrouter":
             return ChatOpenRouter(
                 model=model,
                 api_key=api_key,
                 **common_params
             )
-        
+
         elif provider == "deepseek":
             return ChatDeepSeek(
                 model=model,
                 api_key=api_key,
                 **common_params
             )
-        
+
         elif provider == "aws_bedrock":
             params = {
                 "model": model,
@@ -157,7 +160,7 @@ def create_llm_from_profile(llm_profile):
             if 'aws_region' not in params:
                 params["aws_region"] = "us-east-1"
             return ChatAWSBedrock(**params)
-        
+
         elif provider == "anthropic_bedrock":
             params = {
                 "model": model,
@@ -170,7 +173,7 @@ def create_llm_from_profile(llm_profile):
             if "region_name" in provider_config:
                 params["region_name"] = provider_config["region_name"]
             return ChatAnthropicBedrock(**params)
-        
+
         elif provider == "openai_compatible":
             if not base_url:
                 raise ValueError("OpenAI Compatible provider requires base_url")
@@ -180,61 +183,63 @@ def create_llm_from_profile(llm_profile):
                 base_url=base_url,
                 **common_params
             )
-        
+
         else:
             raise ValueError(f"Unsupported provider: {provider}")
-            
+
     except Exception as e:
         logger.error(f"Failed to create LLM from profile: {e}")
         raise RuntimeError(f"Failed to create LLM from profile: {str(e)}")
 
+
 def validate_llm_configuration(provider: str, model: str, api_key: str, base_url: Optional[str] = None):
     """Validate LLM configuration parameters"""
     if not provider:
         raise ValueError("Provider is required")
-    
+
     if not model:
         raise ValueError("Model is required")
-    
+
     if not is_provider_supported(provider):
         raise ValueError(f"Unsupported provider: {provider}. Supported: {get_supported_providers()}")
-    
+
     # Provider-specific validation
     from ..llm_config import get_provider_metadata
     metadata = get_provider_metadata(provider)
-    
+
     if metadata.get("requires_api_key", True) and not api_key:
         raise ValueError(f"API key is required for provider: {provider}")
-    
+
     if metadata.get("requires_base_url", False) and not base_url:
         raise ValueError(f"Base URL is required for provider: {provider}")
-    
+
     return True
 
+
 def get_llm_creation_parameters(provider: str):
     """Get the required and optional parameters for creating an LLM instance"""
     from ..llm_config import get_provider_metadata
-    
+
     if not is_provider_supported(provider):
         raise ValueError(f"Unsupported provider: {provider}")
-    
+
     metadata = get_provider_metadata(provider)
-    
+
     required_params = ["model"]
     optional_params = ["temperature", "max_tokens", "top_p", "frequency_penalty", "seed"]
-    
+
     if metadata.get("requires_api_key", True):
         required_params.append("api_key")
-    
+
     if metadata.get("requires_base_url", False):
         required_params.append("base_url")
     elif metadata.get("supports_base_url", False):
         optional_params.append("base_url")
-    
+
     # Special cases for AWS Bedrock
     if provider in ["aws_bedrock", "anthropic_bedrock"]:
         required_params.extend(["aws_secret_access_key", "region_name"])
-    
+
     return {
         "required": required_params,
         "optional": optional_params,

vibe_surf/browser/agent_browser_session.py

@@ -720,10 +720,6 @@ class AgentBrowserSession(BrowserSession):
             # Wait for reload
             await asyncio.sleep(1.0)
 
-            # Note: We don't clear cached state here - let the next state fetch rebuild as needed
-
-            # Navigation is handled by BrowserSession via events
-
             self.logger.info('🔄 Target refreshed')
         except Exception as e:
             raise

vibe_surf/browser/browser_manager.py

@@ -16,7 +16,9 @@ from vibe_surf.browser.agent_browser_session import AgentBrowserSession
 if TYPE_CHECKING:
     from browser_use.browser.session import BrowserSession
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class BrowserManager:
@@ -80,11 +82,17 @@ class BrowserManager:
 
         # Validate target assignment
         if target_id:
-            target_id_owner = self.get_target_owner(target_id)
-            if target_id_owner and target_id_owner != agent_id:
-                logger.warning(
-                    f"Target id: {target_id} belongs to {target_id_owner}. You cannot assign it to {target_id_owner}.")
-                return False
+            try:
+                target_id = await self.main_browser_session.get_target_id_from_tab_id(target_id)
+            except Exception:
+                logger.warning(f"Target ID '{target_id}' not found.")
+                target_id = None
+            if target_id:
+                target_id_owner = self.get_target_owner(target_id)
+                if target_id_owner and target_id_owner != agent_id:
+                    logger.warning(
+                        f"Target id: {target_id} belongs to {target_id_owner}. You cannot assign it to {target_id_owner}.")
+                    return False
 
         # Get or create available target
         if target_id is None:
@@ -166,8 +174,6 @@ class BrowserManager:
             except Exception as e:
                 logger.warning(f"Error during agent {agent_id} cleanup: {e}")
 
-        # Note: We don't close the root browser session here as it's managed externally
-
     async def __aenter__(self) -> "BrowserManager":
         """Async context manager entry."""
         return self

vibe_surf/browser/utils.py

@@ -22,7 +22,9 @@ import numpy as np
 from typing import Optional, Tuple, List, Any
 import io
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 # List of common font file names (Prioritize preferred ones first)
@@ -601,7 +603,7 @@ def highlight_screenshot(screenshot_base64: str, elements: List[List[Any]]) -> s
 
         # --- Default if all corners overlap (Logic unchanged) ---
         if not found_non_overlapping_spot:
-            logger.debug(f"Could not avoid label overlap for index {highlight_index}. Defaulting to top-left.")
+            # logger.debug(f"Could not avoid label overlap for index {highlight_index}. Defaulting to top-left.")
             chosen_label_bg_box, potential_text_ref_pos = calculate_label_placement(
                 corner='top_left',  # Default corner from original code
                 outline_box=draw_box_outline,
@@ -618,7 +620,7 @@ def highlight_screenshot(screenshot_base64: str, elements: List[List[Any]]) -> s
                     potential_text_ref_pos[0] + w_padding // 2,
                     potential_text_ref_pos[1] + h_padding // 2)  # ** OFFSET FROM ORIGINAL CODE **
             else:
-                logger.debug(f"Default top-left placement failed for index {highlight_index}. Skipping label.")
+                # logger.debug(f"Default top-left placement failed for index {highlight_index}. Skipping label.")
                 chosen_label_bg_box = None
                 chosen_text_pos = None
 

vibe_surf/browser/watchdogs/dom_watchdog.py

@@ -72,51 +72,6 @@ class CustomDOMWatchdog(DOMWatchdog):
         self.logger.debug(f'🔍 DOMWatchdog.on_BrowserStateRequestEvent: Tabs info: {tabs_info}')
 
         try:
-            # Fast path for empty pages
-            # if not_a_meaningful_website:
-            #     self.logger.debug(f'⚡ Skipping BuildDOMTree for empty target: {page_url}')
-            #     self.logger.info(f'📸 Not taking screenshot for empty page: {page_url} (non-http/https URL)')
-            #
-            #     # Create minimal DOM state
-            #     content = SerializedDOMState(_root=None, selector_map={})
-            #
-            #     # Skip screenshot for empty pages
-            #     screenshot_b64 = None
-            #
-            #     # Try to get page info from CDP, fall back to defaults if unavailable
-            #     try:
-            #         page_info = await self._get_page_info()
-            #     except Exception as e:
-            #         self.logger.debug(f'Failed to get page info from CDP for empty page: {e}, using fallback')
-            #         # Use default viewport dimensions
-            #         viewport = self.browser_session.browser_profile.viewport or {'width': 1280, 'height': 720}
-            #         page_info = PageInfo(
-            #             viewport_width=viewport['width'],
-            #             viewport_height=viewport['height'],
-            #             page_width=viewport['width'],
-            #             page_height=viewport['height'],
-            #             scroll_x=0,
-            #             scroll_y=0,
-            #             pixels_above=0,
-            #             pixels_below=0,
-            #             pixels_left=0,
-            #             pixels_right=0,
-            #         )
-            #
-            #     return BrowserStateSummary(
-            #         dom_state=content,
-            #         url=page_url,
-            #         title='Empty Tab',
-            #         tabs=tabs_info,
-            #         screenshot=screenshot_b64,
-            #         page_info=page_info,
-            #         pixels_above=0,
-            #         pixels_below=0,
-            #         browser_errors=[],
-            #         is_pdf_viewer=False,
-            #         recent_events=self._get_recent_events_str() if include_recent_events else None,
-            #     )
-
             # Execute DOM building and screenshot capture in parallel
             dom_task = None
             screenshot_task = None

vibe_surf/chrome_extension/background.js

@@ -202,6 +202,10 @@ class VibeSurfBackground {
             result = await this.openFileSystem(message.data?.filePath);
             break;
             
+          case 'GET_ALL_TABS':
+            result = await this.getAllTabs();
+            break;
+            
           default:
             console.warn('[VibeSurf] Unknown message type:', message.type);
             result = { error: 'Unknown message type' };

vibe_surf/chrome_extension/scripts/api-client.js

@@ -235,6 +235,10 @@ class VibeSurfAPIClient {
     return this.post('/tasks/stop', { reason });
   }
 
+  async addNewTask(newTask) {
+    return this.post('/tasks/add-new-task', { reason: newTask });
+  }
+
   // Activity APIs
   async getTaskInfo(taskId) {
     return this.get(`/activity/${taskId}`);
@@ -416,6 +420,15 @@ class VibeSurfAPIClient {
     return this.put('/config/controller', configData);
   }
 
+  // Browser APIs
+  async getActiveBrowserTab() {
+    return this.get('/browser/active-tab');
+  }
+
+  async getAllBrowserTabs() {
+    return this.get('/browser/all-tabs');
+  }
+
   // Utility methods
   delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));