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

vibe_surf/agents/views.py

@@ -0,0 +1,130 @@
+import asyncio
+import json
+import logging
+import os
+import pickle
+import time
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from uuid_extensions import uuid7str
+from json_repair import repair_json
+
+from browser_use.browser.session import BrowserSession
+from browser_use.llm.base import BaseChatModel
+from browser_use.llm.messages import UserMessage, SystemMessage, BaseMessage, AssistantMessage, ContentPartTextParam, \
+    ContentPartImageParam, ImageURL
+from browser_use.browser.views import TabInfo, BrowserStateSummary
+from browser_use.filesystem.file_system import FileSystem
+from browser_use.agent.views import AgentSettings
+from pydantic import BaseModel, Field, ConfigDict, create_model
+from browser_use.agent.views import AgentSettings, DEFAULT_INCLUDE_ATTRIBUTES
+from browser_use.tools.registry.views import ActionModel
+
+
+class VibeSurfAgentOutput(BaseModel):
+    """Agent output model following browser_use patterns"""
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra='forbid')
+
+    thinking: str | None = None
+    action: List[Any] = Field(
+        ...,
+        description='List of actions to execute',
+        json_schema_extra={'min_items': 1},
+    )
+
+    @classmethod
+    def model_json_schema(cls, **kwargs):
+        schema = super().model_json_schema(**kwargs)
+        schema['required'] = ['thinking', 'action']
+        return schema
+
+    @staticmethod
+    def type_with_custom_actions(custom_actions: type) -> type:
+        """Extend actions with custom actions"""
+        model_ = create_model(
+            'VibeSurfAgentOutput',
+            __base__=VibeSurfAgentOutput,
+            action=(
+                list[custom_actions],  # type: ignore
+                Field(..., description='List of actions to execute', json_schema_extra={'min_items': 1}),
+            ),
+            __module__=VibeSurfAgentOutput.__module__,
+        )
+        model_.__doc__ = 'VibeSurfAgentOutput model with custom actions'
+        return model_
+
+
+class VibeSurfAgentSettings(BaseModel):
+    use_vision: bool = True
+    max_failures: int = 3
+    override_system_message: str | None = None
+    extend_system_message: str | None = None
+    include_attributes: list[str] | None = DEFAULT_INCLUDE_ATTRIBUTES
+    max_actions_per_step: int = 4
+    max_history_items: int | None = None
+    include_token_cost: bool = False
+
+    calculate_cost: bool = False
+    include_tool_call_examples: bool = False
+    llm_timeout: int = 60  # Timeout in seconds for LLM calls
+    step_timeout: int = 180  # Timeout in seconds for each step
+
+
+class CustomAgentOutput(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra='forbid')
+
+    thinking: str | None = None
+    action: list[ActionModel] = Field(
+        ...,
+        description='List of actions to execute',
+        json_schema_extra={'min_items': 1},  # Ensure at least one action is provided
+    )
+
+    @classmethod
+    def model_json_schema(cls, **kwargs):
+        schema = super().model_json_schema(**kwargs)
+        schema['required'] = ['action']
+        return schema
+
+    @staticmethod
+    def type_with_custom_actions(custom_actions: type[ActionModel]) -> type['CustomAgentOutput']:
+        """Extend actions with custom actions"""
+
+        model_ = create_model(
+            'AgentOutput',
+            __base__=CustomAgentOutput,
+            action=(
+                list[custom_actions],  # type: ignore
+                Field(..., description='List of actions to execute', json_schema_extra={'min_items': 1}),
+            ),
+            __module__=CustomAgentOutput.__module__,
+        )
+        model_.__doc__ = 'AgentOutput model with custom actions'
+        return model_
+
+    @staticmethod
+    def type_with_custom_actions_no_thinking(custom_actions: type[ActionModel]) -> type['CustomAgentOutput']:
+        """Extend actions with custom actions and exclude thinking field"""
+
+        class AgentOutputNoThinking(CustomAgentOutput):
+            @classmethod
+            def model_json_schema(cls, **kwargs):
+                schema = super().model_json_schema(**kwargs)
+                del schema['properties']['thinking']
+                schema['required'] = ['action']
+                return schema
+
+        model = create_model(
+            'AgentOutput',
+            __base__=AgentOutputNoThinking,
+            action=(
+                list[custom_actions],  # type: ignore
+                Field(..., description='List of actions to execute', json_schema_extra={'min_items': 1}),
+            ),
+            __module__=AgentOutputNoThinking.__module__,
+        )
+
+        model.__doc__ = 'AgentOutput model with custom actions'
+        return model

vibe_surf/backend/api/activity.py

@@ -14,7 +14,9 @@ from ..database import get_db_session
 from ..database.queries import TaskQueries
 from .models import ActivityQueryRequest, SessionActivityQueryRequest
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 router = APIRouter(prefix="/activity", tags=["activity"])
 

vibe_surf/backend/api/browser.py

@@ -8,16 +8,16 @@ from fastapi import APIRouter, HTTPException
 from typing import Dict, Any, Optional
 import logging
 
-# Import global variables from shared_state
-from ..shared_state import browser_manager
+from vibe_surf.logger import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 router = APIRouter(prefix="/browser", tags=["browser"])
 
 
 @router.get("/active-tab")
 async def get_active_tab() -> Dict[str, Dict[str, str]]:
+    from ..shared_state import browser_manager
     """Get the current active tab information"""
     if not browser_manager:
         raise HTTPException(status_code=503, detail="Browser manager not initialized")
@@ -27,11 +27,13 @@ async def get_active_tab() -> Dict[str, Dict[str, str]]:
         active_tab_info = await browser_manager.get_activate_tab()
 
         if not active_tab_info:
+            logger.info("No active tab found!")
             return {}
 
+        logger.info(active_tab_info)
         # Return dict format: {tab_id: {url: , title: }}
         return {
-            active_tab_info.target_id: {
+            active_tab_info.target_id[:-4]: {
                 "url": active_tab_info.url,
                 "title": active_tab_info.title
             }
@@ -45,6 +47,8 @@ async def get_active_tab() -> Dict[str, Dict[str, str]]:
 @router.get("/all-tabs")
 async def get_all_tabs() -> Dict[str, Dict[str, str]]:
     """Get all browser tabs information"""
+    from ..shared_state import browser_manager
+
     if not browser_manager:
         raise HTTPException(status_code=503, detail="Browser manager not initialized")
 
@@ -54,7 +58,7 @@ async def get_all_tabs() -> Dict[str, Dict[str, str]]:
         # Filter only page targets and build result dict
         result = {}
         for tab_info in all_tab_infos:
-            result[tab_info.target_id] = {
+            result[tab_info.target_id[-4:]] = {
                 "url": tab_info.url,
                 "title": tab_info.title
             }

vibe_surf/backend/api/config.py

@@ -1,7 +1,7 @@
 """
 Configuration API endpoints for VibeSurf Backend
 
-Handles LLM Profile and controller configuration management.
+Handles LLM Profile and tools configuration management.
 """
 
 from fastapi import APIRouter, HTTPException, Depends
@@ -18,7 +18,10 @@ from .models import (
 )
 
 router = APIRouter(prefix="/config", tags=["config"])
-logger = logging.getLogger(__name__)
+
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 def _profile_to_response_dict(profile) -> dict:
     """Convert SQLAlchemy LLMProfile to dict for Pydantic validation - safe extraction"""
@@ -654,8 +657,8 @@ async def get_configuration_status(db: AsyncSession = Depends(get_db_session)):
                 "default_profile": default_profile.profile_name if default_profile else None,
                 "has_default": default_profile is not None
             },
-            "controller": {
-                "initialized": shared_state.controller is not None
+            "tools": {
+                "initialized": shared_state.vibesurf_tools is not None
             },
             "browser_manager": {
                 "initialized": shared_state.browser_manager is not None
@@ -666,7 +669,7 @@ async def get_configuration_status(db: AsyncSession = Depends(get_db_session)):
             },
             "overall_status": "ready" if (
                     default_profile and
-                    shared_state.controller and
+                    shared_state.vibesurf_tools and
                     shared_state.browser_manager and
                     shared_state.vibesurf_agent
             ) else "partial"

vibe_surf/backend/api/files.py

@@ -21,39 +21,44 @@ from ..database import get_db_session
 from ..database.queries import UploadedFileQueries
 from .models import FileListQueryRequest, SessionFilesQueryRequest
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 router = APIRouter(prefix="/files", tags=["files"])
 
+
 def get_upload_directory(session_id: Optional[str] = None) -> str:
     from ..shared_state import workspace_dir
     """Get the upload directory path for a session or global uploads"""
     if session_id:
-        upload_dir = os.path.join(workspace_dir, session_id, "upload_files")
+        upload_dir = os.path.join(workspace_dir, "sessions", session_id, "upload_files")
     else:
-        upload_dir = os.path.join(workspace_dir, "upload_files")
-    
+        upload_dir = os.path.join(workspace_dir, "sessions", "upload_files")
+
     # Create directory if it doesn't exist
     os.makedirs(upload_dir, exist_ok=True)
     return upload_dir
 
+
 def is_safe_path(basedir: str, path: str) -> bool:
     """Check if the path is safe (within basedir)"""
     try:
         # Resolve both paths to absolute paths
         basedir = os.path.abspath(basedir)
         path = os.path.abspath(path)
-        
+
         # Check if path starts with basedir
         return path.startswith(basedir)
     except:
         return False
 
+
 @router.post("/upload")
 async def upload_files(
-    files: List[UploadFile] = File(...),
-    session_id: Optional[str] = Form(None),
-    db: AsyncSession = Depends(get_db_session)
+        files: List[UploadFile] = File(...),
+        session_id: Optional[str] = Form(None),
+        db: AsyncSession = Depends(get_db_session)
 ):
     """Upload files to workspace/upload_files folder or session-specific folder"""
     try:
@@ -61,18 +66,18 @@ async def upload_files(
 
         upload_dir = get_upload_directory(session_id)
         uploaded_file_info = []
-        
+
         for file in files:
             if not file.filename:
                 continue
-                
+
             # Generate unique file ID
             file_id = uuid7str()
-            
+
             # Create safe filename
             filename = file.filename
             file_path = os.path.join(upload_dir, filename)
-            
+
             # Handle duplicate filenames by adding suffix
             counter = 1
             base_name, ext = os.path.splitext(filename)
@@ -81,21 +86,21 @@ async def upload_files(
                 file_path = os.path.join(upload_dir, new_filename)
                 filename = new_filename
                 counter += 1
-            
+
             # Ensure path is safe
             if not is_safe_path(upload_dir, file_path):
                 raise HTTPException(status_code=400, detail=f"Invalid file path: {filename}")
-            
+
             # Save file
             try:
                 with open(file_path, "wb") as buffer:
                     shutil.copyfileobj(file.file, buffer)
-                
+
                 # Get file info
                 file_size = os.path.getsize(file_path)
                 mime_type, _ = mimetypes.guess_type(file_path)
                 relative_path = os.path.relpath(file_path, workspace_dir)
-                
+
                 # Store file metadata in database
                 uploaded_file = await UploadedFileQueries.create_file_record(
                     db=db,
@@ -108,7 +113,7 @@ async def upload_files(
                     mime_type=mime_type or "application/octet-stream",
                     relative_path=relative_path
                 )
-                
+
                 # Create response metadata
                 file_metadata = {
                     "file_id": uploaded_file.file_id,
@@ -120,11 +125,11 @@ async def upload_files(
                     "upload_time": uploaded_file.upload_time.isoformat(),
                     "file_path": file_path
                 }
-                
+
                 uploaded_file_info.append(file_metadata)
-                
+
                 logger.info(f"File uploaded: {filename} (ID: {file_id}) to {upload_dir}")
-                
+
             except Exception as e:
                 logger.error(f"Failed to save file {filename}: {e}")
                 # If database record was created but file save failed, clean up
@@ -133,20 +138,21 @@ async def upload_files(
                 except:
                     pass
                 raise HTTPException(status_code=500, detail=f"Failed to save file {filename}: {str(e)}")
-        
+
         # Commit all database changes
         await db.commit()
-        
+
         return {
             "message": f"Successfully uploaded {len(uploaded_file_info)} files",
             "files": uploaded_file_info,
             "upload_directory": upload_dir
         }
-        
+
     except Exception as e:
         logger.error(f"File upload failed: {e}")
         raise HTTPException(status_code=500, detail=f"File upload failed: {str(e)}")
 
+
 @router.get("/{file_id}")
 async def download_file(file_id: str, db: AsyncSession = Depends(get_db_session)):
     """Download file by file ID"""
@@ -155,26 +161,27 @@ async def download_file(file_id: str, db: AsyncSession = Depends(get_db_session)
     uploaded_file = await UploadedFileQueries.get_file(db, file_id)
     if not uploaded_file:
         raise HTTPException(status_code=404, detail="File not found")
-    
+
     file_path = uploaded_file.file_path
-    
+
     if not os.path.exists(file_path):
         raise HTTPException(status_code=404, detail="File not found on disk")
-    
+
     # Ensure path is safe
     if not is_safe_path(workspace_dir, file_path):
         raise HTTPException(status_code=403, detail="Access denied")
-    
+
     return FileResponse(
         path=file_path,
         filename=uploaded_file.original_filename,
         media_type=uploaded_file.mime_type
     )
 
+
 @router.get("")
 async def list_uploaded_files(
-    query: FileListQueryRequest = Depends(),
-    db: AsyncSession = Depends(get_db_session)
+        query: FileListQueryRequest = Depends(),
+        db: AsyncSession = Depends(get_db_session)
 ):
     """List uploaded files, optionally filtered by session"""
     try:
@@ -186,14 +193,14 @@ async def list_uploaded_files(
             offset=query.offset,
             active_only=True
         )
-        
+
         # Get total count
         total_count = await UploadedFileQueries.count_files(
             db=db,
             session_id=query.session_id,
             active_only=True
         )
-        
+
         # Convert to response format (exclude file_path for security)
         files_response = []
         for file_record in uploaded_files:
@@ -207,7 +214,7 @@ async def list_uploaded_files(
                 "upload_time": file_record.upload_time.isoformat(),
                 "file_path": file_record.file_path
             })
-        
+
         return {
             "files": files_response,
             "total_count": total_count,
@@ -216,11 +223,12 @@ async def list_uploaded_files(
             "has_more": query.limit != -1 and (query.offset + query.limit < total_count),
             "session_id": query.session_id
         }
-        
+
     except Exception as e:
         logger.error(f"Failed to list files: {e}")
         raise HTTPException(status_code=500, detail=f"Failed to list files: {str(e)}")
 
+
 @router.delete("/{file_id}")
 async def delete_file(file_id: str, db: AsyncSession = Depends(get_db_session)):
     """Delete uploaded file by file ID"""
@@ -228,40 +236,41 @@ async def delete_file(file_id: str, db: AsyncSession = Depends(get_db_session)):
     uploaded_file = await UploadedFileQueries.get_file(db, file_id)
     if not uploaded_file:
         raise HTTPException(status_code=404, detail="File not found")
-    
+
     try:
         # Remove file from disk
         if os.path.exists(uploaded_file.file_path):
             os.remove(uploaded_file.file_path)
-        
+
         # Soft delete from database
         success = await UploadedFileQueries.delete_file(db, file_id)
         if not success:
             raise HTTPException(status_code=500, detail="Failed to delete file record")
-        
+
         await db.commit()
-        
+
         return {
             "message": f"File {uploaded_file.original_filename} deleted successfully",
             "file_id": file_id
         }
-        
+
     except HTTPException:
         raise
     except Exception as e:
         logger.error(f"Failed to delete file {file_id}: {e}")
         raise HTTPException(status_code=500, detail=f"Failed to delete file: {str(e)}")
 
+
 @router.get("/session/{session_id}")
 async def list_session_files(
-    session_id: str,
-    query: SessionFilesQueryRequest = Depends()
+        session_id: str,
+        query: SessionFilesQueryRequest = Depends()
 ):
     """List all files in a session directory"""
     try:
         from ..shared_state import workspace_dir
         session_dir = os.path.join(workspace_dir, session_id)
-        
+
         if not os.path.exists(session_dir):
             return {
                 "session_id": session_id,
@@ -269,16 +278,16 @@ async def list_session_files(
                 "directories": [],
                 "message": "Session directory not found"
             }
-        
+
         files = []
         directories = []
-        
+
         for root, dirs, filenames in os.walk(session_dir):
             # Calculate relative path from session directory
             rel_root = os.path.relpath(root, session_dir)
             if rel_root == ".":
                 rel_root = ""
-            
+
             # Add directories if requested
             if query.include_directories:
                 for dirname in dirs:
@@ -288,16 +297,16 @@ async def list_session_files(
                         "path": dir_path,
                         "type": "directory"
                     })
-            
+
             # Add files
             for filename in filenames:
                 file_path = os.path.join(root, filename)
                 rel_path = os.path.join(rel_root, filename) if rel_root else filename
-                
+
                 try:
                     stat = os.stat(file_path)
                     mime_type, _ = mimetypes.guess_type(file_path)
-                    
+
                     files.append({
                         "name": filename,
                         "path": rel_path,
@@ -308,7 +317,7 @@ async def list_session_files(
                     })
                 except Exception as e:
                     logger.warning(f"Could not get stats for file {file_path}: {e}")
-        
+
         return {
             "session_id": session_id,
             "files": files,
@@ -316,7 +325,7 @@ async def list_session_files(
             "total_files": len(files),
             "total_directories": len(directories) if query.include_directories else 0
         }
-        
+
     except Exception as e:
         logger.error(f"Failed to list session files for {session_id}: {e}")
-        raise HTTPException(status_code=500, detail=f"Failed to list session files: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to list session files: {str(e)}")

vibe_surf/backend/api/models.py

@@ -245,13 +245,13 @@ class LLMConfigResponse(BaseModel):
     available_providers: List[str] = []
 
 class ControllerConfigRequest(BaseModel):
-    """Request model for updating controller configuration"""
+    """Request model for updating tools configuration"""
     exclude_actions: Optional[List[str]] = Field(default=None, description="Actions to exclude from execution")
     max_actions_per_task: Optional[int] = Field(default=None, gt=0, description="Maximum actions per task")
     display_files_in_done_text: Optional[bool] = Field(default=None, description="Whether to display files in done text")
 
 class ControllerConfigResponse(BaseModel):
-    """Response model for controller configuration"""
+    """Response model for tools configuration"""
     exclude_actions: List[str] = []
     max_actions_per_task: int = 100
     display_files_in_done_text: bool = True

vibe_surf/backend/api/task.py

@@ -25,7 +25,9 @@ from ..shared_state import (
     browser_manager
 )
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 router = APIRouter(prefix="/tasks", tags=["tasks"])
 
@@ -76,16 +78,16 @@ async def submit_task(
         task_id = uuid7str()
 
         # Get MCP server config for saving
-        from ..shared_state import controller, active_mcp_server
+        from ..shared_state import vibesurf_tools, active_mcp_server
         mcp_server_config = task_request.mcp_server_config
-        if not mcp_server_config and controller and hasattr(controller, 'mcp_server_config'):
-            mcp_server_config = controller.mcp_server_config
-        
+        if not mcp_server_config and vibesurf_tools and hasattr(vibesurf_tools, 'mcp_server_config'):
+            mcp_server_config = vibesurf_tools.mcp_server_config
+
         # Ensure we have a valid MCP server config (never None)
         if mcp_server_config is None:
             mcp_server_config = {"mcpServers": {}}
             logger.info("Using default empty MCP server configuration")
-        
+
         # DEBUG: Log the type and content of mcp_server_config
         logger.info(f"mcp_server_config type: {type(mcp_server_config)}, value: {mcp_server_config}")
 
@@ -140,16 +142,17 @@ async def _ensure_llm_initialized(llm_profile):
     """Ensure LLM is initialized with the specified profile"""
     from ..utils.llm_factory import create_llm_from_profile
     from ..shared_state import vibesurf_agent
-    
+
     if not vibesurf_agent:
         raise HTTPException(status_code=503, detail="VibeSurf agent not initialized")
-    
+
     # Always create new LLM instance to ensure we're using the right profile
     new_llm = create_llm_from_profile(llm_profile)
-    
-    # Update vibesurf agent's LLM
-    vibesurf_agent.llm = new_llm
-    logger.info(f"LLM updated for profile: {llm_profile['profile_name']}")
+
+    # Update vibesurf agent's LLM and register with token cost service
+    if vibesurf_agent and vibesurf_agent.token_cost_service:
+        vibesurf_agent.llm = vibesurf_agent.token_cost_service.register_llm(new_llm)
+        logger.info(f"LLM updated and registered for token tracking for profile: {llm_profile['profile_name']}")
 
 
 @router.post("/pause")
@@ -260,6 +263,36 @@ async def stop_task(control_request: TaskControlRequest):
         raise HTTPException(status_code=500, detail=f"Failed to stop task: {str(e)}")
 
 
+@router.post("/add-new-task")
+async def add_new_task(control_request: TaskControlRequest):
+    """Add a new task or follow-up instruction during execution"""
+    from ..shared_state import vibesurf_agent
+
+    if not vibesurf_agent:
+        raise HTTPException(status_code=503, detail="VibeSurf agent not initialized")
+
+    if not is_task_running():
+        raise HTTPException(status_code=400, detail="No active task to add new instruction to")
+
+    try:
+        # Use the reason field as the new task content
+        new_task = control_request.reason or "No additional task provided"
+        
+        # Add the new task to the running agent
+        await vibesurf_agent.add_new_task(new_task)
+
+        return {
+            "success": True,
+            "message": "New task added successfully",
+            "operation": "add_new_task",
+            "new_task": new_task
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to add new task: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to add new task: {str(e)}")
+
+
 @router.get("/detailed-status")
 async def get_detailed_task_status():
     """Get detailed task execution status with vibesurf information"""