vibesurf 0.1.16__tar.gz → 0.1.18__tar.gz

{vibesurf-0.1.16 → vibesurf-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibesurf
-Version: 0.1.16
+Version: 0.1.18
 Summary: VibeSurf: A powerful browser assistant for vibe surfing
 Author: Shao Warm
 License: Apache-2.0

{vibesurf-0.1.16 → vibesurf-0.1.18}/vibe_surf/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.16'
-__version_tuple__ = version_tuple = (0, 1, 16)
+__version__ = version = '0.1.18'
+__version_tuple__ = version_tuple = (0, 1, 18)
 
-__commit_id__ = commit_id = 'gb9e253fde'
+__commit_id__ = commit_id = 'g51b12c120'

{vibesurf-0.1.16 → vibesurf-0.1.18}/vibe_surf/agents/browser_use_agent.py

@@ -566,12 +566,6 @@ class BrowserUseAgent(Agent):
                     agent_run_error = 'Agent stopped programmatically'
                     break
 
-                while self.state.paused:
-                    await asyncio.sleep(0.2)  # Small delay to prevent CPU spinning
-                    if self.state.stopped:  # Allow stopping while paused
-                        agent_run_error = 'Agent stopped programmatically while paused'
-                        break
-
                 if on_step_start is not None:
                     await on_step_start(self)
 
@@ -820,12 +814,12 @@ class BrowserUseAgent(Agent):
                     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
+                    # 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:

{vibesurf-0.1.16 → vibesurf-0.1.18}/vibe_surf/agents/report_writer_agent.py

@@ -32,7 +32,7 @@ class ReportTaskResult(BaseModel):
 class ReportWriterAgent:
     """Agent responsible for generating HTML reports using LLM-controlled flow"""
 
-    def __init__(self, llm: BaseChatModel, workspace_dir: str, step_callback=None, thinking_mode: bool = True):
+    def __init__(self, llm: BaseChatModel, workspace_dir: str, step_callback=None, use_thinking: bool = True):
         """
         Initialize ReportWriterAgent
         
@@ -44,7 +44,7 @@ class ReportWriterAgent:
         self.llm = llm
         self.workspace_dir = os.path.abspath(workspace_dir)
         self.step_callback = step_callback
-        self.thinking_mode = thinking_mode
+        self.use_thinking = use_thinking
 
         # Initialize file system and tools
         self.file_system = CustomFileSystem(self.workspace_dir)
@@ -52,7 +52,7 @@ class ReportWriterAgent:
 
         # Setup action model and agent output
         self.ActionModel = self.tools.registry.create_action_model()
-        if self.thinking_mode:
+        if self.use_thinking:
             self.AgentOutput = CustomAgentOutput.type_with_custom_actions(self.ActionModel)
         else:
             self.AgentOutput = CustomAgentOutput.type_with_custom_actions_no_thinking(self.ActionModel)

{vibesurf-0.1.16 → vibesurf-0.1.18}/vibe_surf/agents/vibe_surf_agent.py

@@ -38,6 +38,7 @@ from vibe_surf.browser.browser_manager import BrowserManager
 from vibe_surf.tools.browser_use_tools import BrowserUseTools
 from vibe_surf.tools.vibesurf_tools import VibeSurfTools
 from vibe_surf.tools.file_system import CustomFileSystem
+from vibe_surf.agents.views import VibeSurfAgentSettings
 
 from vibe_surf.logger import get_logger
 
@@ -213,11 +214,11 @@ def create_browser_agent_step_callback(state: VibeSurfState, agent_name: str):
             step_msg = f"## Step {step_num}\n\n"
 
             # Add thinking if present
-            if agent_output.thinking:
+            if hasattr(agent_output, 'thinking') and agent_output.thinking:
                 step_msg += f"**💡 Thinking:**\n{agent_output.thinking}\n\n"
 
             # Add evaluation if present
-            if agent_output.evaluation_previous_goal:
+            if hasattr(agent_output, 'evaluation_previous_goal') and agent_output.evaluation_previous_goal:
                 step_msg += f"**👍 Evaluation:**\n{agent_output.evaluation_previous_goal}\n\n"
 
             # Add memory if present
@@ -225,7 +226,7 @@ def create_browser_agent_step_callback(state: VibeSurfState, agent_name: str):
             #     step_msg += f"**🧠 Memory:** {agent_output.memory}\n\n"
 
             # Add next goal if present
-            if agent_output.next_goal:
+            if hasattr(agent_output, 'next_goal') and agent_output.next_goal:
                 step_msg += f"**🎯 Next Goal:**\n{agent_output.next_goal}\n\n"
 
             # Add action summary
@@ -352,7 +353,7 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
     # Create action model and agent output using VibeSurfTools
     vibesurf_agent = state.vibesurf_agent
     ActionModel = vibesurf_agent.tools.registry.create_action_model()
-    if vibesurf_agent.thinking_mode:
+    if vibesurf_agent.settings.agent_mode == "thinking":
         AgentOutput = CustomAgentOutput.type_with_custom_actions(ActionModel)
     else:
         AgentOutput = CustomAgentOutput.type_with_custom_actions_no_thinking(ActionModel)
@@ -632,7 +633,9 @@ async def execute_parallel_browser_tasks(state: VibeSurfState) -> List[BrowserTa
                 file_system_path=str(bu_agent_workdir),
                 register_new_step_callback=step_callback,
                 extend_system_message=EXTEND_BU_SYSTEM_PROMPT,
-                token_cost_service=state.vibesurf_agent.token_cost_service
+                token_cost_service=state.vibesurf_agent.token_cost_service,
+                flash_mode=state.vibesurf_agent.settings.agent_mode == "flash",
+                use_thinking=state.vibesurf_agent.settings.agent_mode == "thinking"
             )
             agents.append(agent)
 
@@ -783,7 +786,9 @@ async def execute_single_browser_tasks(state: VibeSurfState) -> BrowserTaskResul
             file_system_path=str(bu_agent_workdir),
             register_new_step_callback=step_callback,
             extend_system_message=EXTEND_BU_SYSTEM_PROMPT,
-            token_cost_service=state.vibesurf_agent.token_cost_service
+            token_cost_service=state.vibesurf_agent.token_cost_service,
+            flash_mode=state.vibesurf_agent.settings.agent_mode == "flash",
+            use_thinking=state.vibesurf_agent.settings.agent_mode == "thinking"
         )
         if state.vibesurf_agent and hasattr(state.vibesurf_agent, '_running_agents'):
             state.vibesurf_agent._running_agents[agent_id] = agent
@@ -861,7 +866,7 @@ async def _report_task_execution_node_impl(state: VibeSurfState) -> VibeSurfStat
             llm=state.vibesurf_agent.llm,
             workspace_dir=str(state.vibesurf_agent.file_system.get_dir()),
             step_callback=step_callback,
-            thinking_mode=state.vibesurf_agent.thinking_mode,
+            use_thinking=state.vibesurf_agent.settings.agent_mode == "thinking",
         )
         
         # Register report writer agent for control coordination
@@ -997,19 +1002,17 @@ class VibeSurfAgent:
             browser_manager: BrowserManager,
             tools: VibeSurfTools,
             workspace_dir: str = "./workspace",
-            thinking_mode: bool = True,
-            calculate_token_cost: bool = True,
+            settings: Optional[VibeSurfAgentSettings] = None
     ):
         """Initialize VibeSurfAgent with required components"""
         self.llm: BaseChatModel = llm
-        self.calculate_token_cost = calculate_token_cost
-        self.token_cost_service = TokenCost(include_cost=calculate_token_cost)
+        self.settings = settings or VibeSurfAgentSettings()
+        self.token_cost_service = TokenCost(include_cost=self.settings.calculate_cost)
         self.token_cost_service.register_llm(llm)
         self.browser_manager: BrowserManager = browser_manager
         self.tools: VibeSurfTools = tools
         self.workspace_dir = workspace_dir
         os.makedirs(self.workspace_dir, exist_ok=True)
-        self.thinking_mode = thinking_mode
 
         self.cur_session_id = None
         self.file_system: Optional[CustomFileSystem] = None
@@ -1540,7 +1543,7 @@ Please continue with your assigned work, incorporating this guidance only if it'
             task: str,
             upload_files: Optional[List[str]] = None,
             session_id: Optional[str] = None,
-            thinking_mode: bool = True
+            agent_mode: str = "thinking"
     ) -> str | None:
         """
         Main execution method that returns markdown summary with control capabilities
@@ -1554,7 +1557,7 @@ Please continue with your assigned work, incorporating this guidance only if it'
         """
         logger.info(f"🚀 Starting VibeSurfAgent execution for task: {task}. Powered by LLM model: {self.llm.model_name}")
         try:
-            self.thinking_mode = thinking_mode
+            self.settings.agent_mode = agent_mode
             session_id = session_id or self.cur_session_id or uuid7str()
             if session_id != self.cur_session_id:
                 # Load session-specific data when switching sessions

{vibesurf-0.1.16 → vibesurf-0.1.18}/vibe_surf/agents/views.py

@@ -66,11 +66,13 @@ class VibeSurfAgentSettings(BaseModel):
     max_history_items: int | None = None
     include_token_cost: bool = False
 
-    calculate_cost: bool = False
+    calculate_cost: bool = True
     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
 
+    agent_mode: str = "thinking"  # thinking, no-thinking, flash
+
 
 class CustomAgentOutput(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra='forbid')
@@ -117,7 +119,7 @@ class CustomAgentOutput(BaseModel):
                 return schema
 
         model = create_model(
-            'AgentOutput',
+            'AgentOutputNoThinking',
             __base__=AgentOutputNoThinking,
             action=(
                 list[custom_actions],  # type: ignore

{vibesurf-0.1.16 → vibesurf-0.1.18}/vibe_surf/backend/api/models.py

@@ -106,6 +106,7 @@ class TaskCreateRequest(BaseModel):
     llm_profile_name: str = Field(description="LLM profile name to use")
     upload_files_path: Optional[str] = Field(default=None, description="Path to uploaded files")
     mcp_server_config: Optional[Dict[str, Any]] = Field(default=None, description="MCP server configuration")
+    agent_mode: str = Field(default="thinking", description="Agent mode: 'thinking', 'no-thinking', or 'flash'")
 
 class TaskControlRequest(BaseModel):
     """Request model for task control operations (pause/resume/stop)"""
@@ -121,6 +122,7 @@ class TaskResponse(BaseModel):
     upload_files_path: Optional[str] = None
     workspace_dir: Optional[str] = None
     mcp_server_config: Optional[Dict[str, Any]] = None
+    agent_mode: str = "thinking"
     task_result: Optional[str] = None
     error_message: Optional[str] = None
     report_path: Optional[str] = None
@@ -145,6 +147,7 @@ class TaskResponse(BaseModel):
             upload_files_path=task.upload_files_path,
             workspace_dir=task.workspace_dir,
             mcp_server_config=task.mcp_server_config,
+            agent_mode=task.agent_mode,
             task_result=task.task_result,
             error_message=task.error_message,
             report_path=task.report_path,

{vibesurf-0.1.16 → vibesurf-0.1.18}/vibe_surf/backend/api/task.py

@@ -117,7 +117,8 @@ async def submit_task(
             mcp_server_config=mcp_server_config,
             llm_profile_name=task_request.llm_profile_name,
             workspace_dir=workspace_dir,
-            task_status="pending"
+            task_status="pending",
+            agent_mode=task_request.agent_mode
         )
         await db.commit()
 
@@ -129,6 +130,7 @@ async def submit_task(
             task=task_request.task_description,
             llm_profile_name=task_request.llm_profile_name,
             upload_files=task_request.upload_files_path,
+            agent_mode=task_request.agent_mode,
             db_session=db
         )
 

vibesurf-0.1.18/vibe_surf/backend/database/manager.py

@@ -0,0 +1,318 @@
+"""
+Database Manager for VibeSurf Session Management
+
+Handles database connections, session management, and initialization
+with optimized configuration for real-time operations.
+"""
+
+import asyncio
+import os
+import glob
+import pdb
+import re
+from pathlib import Path
+from typing import AsyncGenerator, List, Tuple, Optional
+import logging
+import aiosqlite
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+from .models import Base
+
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class DBMigrationManager:
+    """Simplified database migration manager."""
+    
+    def __init__(self, db_path: str = None):
+        """Initialize migration manager
+        
+        Args:
+            db_path: Database file path. Will be extracted from database_url if not provided.
+        """
+        if db_path is None:
+            # Extract database path from shared_state
+            from .. import shared_state
+            database_url = os.getenv(
+                'VIBESURF_DATABASE_URL',
+                f'sqlite+aiosqlite:///{os.path.join(shared_state.workspace_dir, "vibe_surf.db")}'
+            )
+            self.db_path = database_url
+        else:
+            self.db_path = db_path
+            
+        # Extract path from sqlite URL
+        if self.db_path.startswith('sqlite+aiosqlite:///'):
+            self.db_path = self.db_path[20:]  # Remove 'sqlite+aiosqlite:///' prefix
+        else:
+            raise ValueError(f"Migration manager only supports SQLite databases, got: {self.db_path}")
+            
+        self.migrations_dir = Path(__file__).parent / "migrations"
+    
+    async def get_db_version(self) -> int:
+        """Get current database version."""
+        try:
+            async with aiosqlite.connect(self.db_path) as db:
+                cursor = await db.execute("PRAGMA user_version;")
+                result = await cursor.fetchone()
+                return result[0] if result else 0
+        except Exception:
+            return 0
+    
+    async def set_db_version(self, version: int) -> None:
+        """Set database version."""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute(f"PRAGMA user_version = {version};")
+            await db.commit()
+    
+    def get_migration_files(self) -> List[Tuple[int, str]]:
+        """Get migration files sorted by version. Returns (version, filepath) tuples."""
+        migrations = []
+        pattern = str(self.migrations_dir / "v*.sql")
+        
+        for filepath in glob.glob(pattern):
+            filename = os.path.basename(filepath)
+            match = re.match(r'v(\d+)_.*\.sql$', filename)
+            if match:
+                version = int(match.group(1))
+                migrations.append((version, filepath))
+            else:
+                logger.warning(f"Migration file {filename} doesn't match pattern v000_description.sql")
+        
+        return sorted(migrations, key=lambda x: x[0])
+    
+    async def init_database(self) -> None:
+        """Initialize database directory if needed."""
+        db_dir = os.path.dirname(self.db_path)
+        os.makedirs(db_dir, exist_ok=True)
+        
+        current_version = await self.get_db_version()
+        
+        if current_version == 0:
+            logger.info("Database version is 0, will be initialized via migrations...")
+        else:
+            logger.info(f"Database already exists (version {current_version})")
+    
+    async def apply_migrations(self, target_version: Optional[int] = None) -> int:
+        """Apply pending migrations. Returns final version."""
+        await self.init_database()  # Ensure database exists
+        
+        current_version = await self.get_db_version()
+        migrations = self.get_migration_files()
+        
+        if not migrations:
+            logger.info("No migration files found")
+            return current_version
+        
+        if target_version is None:
+            target_version = max(m[0] for m in migrations)
+        
+        logger.info(f"Current version: {current_version}, Target: {target_version}")
+        
+        if current_version >= target_version:
+            logger.info("Database is up to date")
+            return current_version
+        
+        applied = 0
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys = ON;")
+            
+            for version, filepath in migrations:
+                if version <= current_version or version > target_version:
+                    continue
+                
+                try:
+                    logger.info(f"Applying migration v{version:03d}: {os.path.basename(filepath)}")
+                    
+                    with open(filepath, 'r', encoding='utf-8') as f:
+                        sql_content = f.read()
+                    
+                    await db.executescript(sql_content)
+                    await self.set_db_version(version)
+                    applied += 1
+                    
+                    logger.info(f"Successfully applied migration v{version:03d}")
+                    
+                except Exception as e:
+                    logger.error(f"Migration v{version:03d} failed: {e}")
+                    raise RuntimeError(f"Migration failed at version {version}: {e}")
+        
+        final_version = await self.get_db_version()
+        logger.info(f"Applied {applied} migrations. Final version: {final_version}")
+        return final_version
+
+
+class DatabaseManager:
+    """Database connection and session management"""
+
+    def __init__(self, database_url: str = None):
+        """Initialize database manager
+        
+        Args:
+            database_url: Database connection URL. Defaults to SQLite if not provided.
+        """
+        from .. import shared_state
+        self.database_url = database_url or os.getenv(
+            'VIBESURF_DATABASE_URL',
+            f'sqlite+aiosqlite:///{os.path.join(shared_state.workspace_dir, "vibe_surf.db")}'
+        )
+
+        # Configure engine based on database type
+        if self.database_url.startswith('sqlite'):
+            # SQLite configuration for development
+            self.engine = create_async_engine(
+                self.database_url,
+                poolclass=StaticPool,
+                connect_args={
+                    "check_same_thread": False,
+                    "timeout": 30
+                },
+                echo=False  # Set to True for SQL debugging
+            )
+        else:
+            # PostgreSQL/MySQL configuration for production
+            self.engine = create_async_engine(
+                self.database_url,
+                pool_size=20,
+                max_overflow=30,
+                pool_pre_ping=True,
+                pool_recycle=3600,
+                echo=False
+            )
+
+        self.async_session_factory = sessionmaker(
+            self.engine,
+            class_=AsyncSession,
+            expire_on_commit=False
+        )
+        
+        # Initialize migration manager for SQLite databases
+        if self.database_url.startswith('sqlite'):
+            try:
+                self.migration_manager = DBMigrationManager(db_path=self.database_url)
+            except Exception as e:
+                logger.warning(f"Failed to initialize migration manager: {e}")
+                self.migration_manager = None
+        else:
+            self.migration_manager = None
+            logger.info("Migration manager is only supported for SQLite databases")
+
+    async def create_tables(self, use_migrations: bool = True):
+        """Create all database tables
+        
+        Args:
+            use_migrations: If True, use migration system. If False, use direct table creation.
+        """
+        if use_migrations and self.migration_manager:
+            logger.info("🔄 Using migration system to initialize database...")
+            try:
+                await self.migration_manager.apply_migrations()
+                logger.info("✅ Database initialized via migrations")
+                return
+            except Exception as e:
+                logger.warning(f"Migration failed, falling back to direct table creation: {e}")
+        
+        # Fallback to direct table creation
+        logger.info("🔄 Using direct table creation...")
+        async with self.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+        logger.info("✅ Database initialized via direct table creation")
+
+    async def drop_tables(self):
+        """Drop all database tables"""
+        async with self.engine.begin() as conn:
+            await conn.run_sync(Base.metadata.drop_all)
+
+    async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
+        """Get async database session"""
+        async with self.async_session_factory() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception:
+                await session.rollback()
+                raise
+            finally:
+                await session.close()
+
+    async def apply_migrations(self, target_version: Optional[int] = None) -> int:
+        """Apply database migrations
+        
+        Args:
+            target_version: Target migration version. If None, applies all available migrations.
+            
+        Returns:
+            Final database version after applying migrations.
+            
+        Raises:
+            RuntimeError: If migration manager is not available or migration fails.
+        """
+        if not self.migration_manager:
+            raise RuntimeError("Migration manager is not available. Only SQLite databases support migrations.")
+        
+        return await self.migration_manager.apply_migrations(target_version)
+    
+    async def get_db_version(self) -> int:
+        """Get current database version
+        
+        Returns:
+            Current database version, or 0 if not available.
+        """
+        if not self.migration_manager:
+            logger.warning("Migration manager not available, cannot get database version")
+            return 0
+        
+        return await self.migration_manager.get_db_version()
+
+    async def close(self):
+        """Close database connections"""
+        await self.engine.dispose()
+
+
+# Dependency for FastAPI
+async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """FastAPI dependency for database sessions"""
+    from .. import shared_state
+
+    if not shared_state.db_manager:
+        raise RuntimeError("Database manager not initialized. Call initialize_vibesurf_components() first.")
+
+    async for session in shared_state.db_manager.get_session():
+        yield session
+
+
+# Database initialization script
+async def init_database():
+    """Initialize database with tables"""
+    from .. import shared_state
+
+    logger.info("🗄️ Initializing VibeSurf database...")
+
+    try:
+        if not shared_state.db_manager:
+            raise RuntimeError("Database manager not initialized. Call initialize_vibesurf_components() first.")
+
+        await shared_state.db_manager.create_tables()
+        logger.info("✅ Database tables created successfully")
+        logger.info("✅ VibeSurf database ready for single-task execution")
+
+    except Exception as e:
+        logger.error(f"❌ Database initialization failed: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    # For standalone execution, initialize a temporary db_manager
+    import os
+    from .. import shared_state
+
+    workspace_dir = os.getenv("VIBESURF_WORKSPACE", os.path.join(os.path.dirname(__file__), "../vibesurf_workspace"))
+    database_url = os.getenv(
+        'VIBESURF_DATABASE_URL',
+        f'sqlite+aiosqlite:///{os.path.join(workspace_dir, "vibe_surf.db")}'
+    )
+    shared_state.db_manager = DatabaseManager(database_url)
+    asyncio.run(init_database())