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

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:

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)

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

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

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,

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
         )
 

vibe_surf/backend/database/manager.py

@@ -6,18 +6,145 @@ 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 typing import AsyncGenerator
-import logging
 
 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"""
 
@@ -61,11 +188,38 @@ class DatabaseManager:
             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):
-        """Create all database tables"""
+    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"""
@@ -84,6 +238,35 @@ class DatabaseManager:
             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()

vibe_surf/backend/database/migrations/v001_initial_schema.sql

@@ -0,0 +1,118 @@
+-- Migration: v001_initial_schema.sql
+-- Description: Initial database schema creation
+-- Version: 0.0.1
+
+-- Enable foreign keys
+PRAGMA foreign_keys = ON;
+
+-- Create LLM Profiles table
+CREATE TABLE IF NOT EXISTS llm_profiles (
+    profile_id VARCHAR(36) NOT NULL PRIMARY KEY,
+    profile_name VARCHAR(100) NOT NULL UNIQUE,
+    provider VARCHAR(50) NOT NULL,
+    model VARCHAR(100) NOT NULL,
+    base_url VARCHAR(500),
+    encrypted_api_key TEXT,
+    temperature JSON,
+    max_tokens JSON,
+    top_p JSON,
+    frequency_penalty JSON,
+    seed JSON,
+    provider_config JSON,
+    description TEXT,
+    is_active BOOLEAN NOT NULL DEFAULT 1,
+    is_default BOOLEAN NOT NULL DEFAULT 0,
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    last_used_at DATETIME
+);
+
+-- Create Tasks table
+CREATE TABLE IF NOT EXISTS tasks (
+    task_id VARCHAR(36) NOT NULL PRIMARY KEY,
+    session_id VARCHAR(36) NOT NULL,
+    task_description TEXT NOT NULL,
+    status VARCHAR(9) NOT NULL DEFAULT 'pending',
+    llm_profile_name VARCHAR(100) NOT NULL,
+    upload_files_path VARCHAR(500),
+    workspace_dir VARCHAR(500),
+    mcp_server_config TEXT,
+    task_result TEXT,
+    error_message TEXT,
+    report_path VARCHAR(500),
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    started_at DATETIME,
+    completed_at DATETIME,
+    task_metadata JSON,
+    CHECK (status IN ('pending', 'running', 'paused', 'completed', 'failed', 'stopped'))
+);
+
+-- Create Uploaded Files table
+CREATE TABLE IF NOT EXISTS uploaded_files (
+    file_id VARCHAR(36) NOT NULL PRIMARY KEY,
+    original_filename VARCHAR(255) NOT NULL,
+    stored_filename VARCHAR(255) NOT NULL,
+    file_path TEXT NOT NULL,
+    session_id VARCHAR(255),
+    file_size BIGINT NOT NULL,
+    mime_type VARCHAR(100) NOT NULL,
+    upload_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    relative_path TEXT NOT NULL,
+    is_deleted BOOLEAN NOT NULL DEFAULT 0,
+    deleted_at DATETIME
+);
+
+-- Create MCP Profiles table
+CREATE TABLE IF NOT EXISTS mcp_profiles (
+    mcp_id VARCHAR(36) NOT NULL PRIMARY KEY,
+    display_name VARCHAR(100) NOT NULL UNIQUE,
+    mcp_server_name VARCHAR(100) NOT NULL UNIQUE,
+    mcp_server_params JSON NOT NULL,
+    description TEXT,
+    is_active BOOLEAN NOT NULL DEFAULT 1,
+    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    last_used_at DATETIME
+);
+
+-- Create indexes for performance
+CREATE INDEX IF NOT EXISTS idx_llm_profiles_name ON llm_profiles(profile_name);
+CREATE INDEX IF NOT EXISTS idx_llm_profiles_active ON llm_profiles(is_active);
+CREATE INDEX IF NOT EXISTS idx_llm_profiles_default ON llm_profiles(is_default);
+CREATE INDEX IF NOT EXISTS idx_llm_profiles_provider ON llm_profiles(provider);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_session ON tasks(session_id);
+CREATE INDEX IF NOT EXISTS idx_tasks_llm_profile ON tasks(llm_profile_name);
+CREATE INDEX IF NOT EXISTS idx_tasks_created ON tasks(created_at);
+
+CREATE INDEX IF NOT EXISTS idx_uploaded_files_session_time ON uploaded_files(session_id, upload_time);
+CREATE INDEX IF NOT EXISTS idx_uploaded_files_active ON uploaded_files(is_deleted, upload_time);
+CREATE INDEX IF NOT EXISTS idx_uploaded_files_filename ON uploaded_files(original_filename);
+
+CREATE INDEX IF NOT EXISTS idx_mcp_profiles_display_name ON mcp_profiles(display_name);
+CREATE INDEX IF NOT EXISTS idx_mcp_profiles_server_name ON mcp_profiles(mcp_server_name);
+CREATE INDEX IF NOT EXISTS idx_mcp_profiles_active ON mcp_profiles(is_active);
+
+-- Create triggers for automatic timestamp updates
+CREATE TRIGGER IF NOT EXISTS update_llm_profiles_updated_at
+AFTER UPDATE ON llm_profiles
+FOR EACH ROW
+BEGIN
+    UPDATE llm_profiles SET updated_at = CURRENT_TIMESTAMP WHERE profile_id = OLD.profile_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_tasks_updated_at
+AFTER UPDATE ON tasks
+FOR EACH ROW
+BEGIN
+    UPDATE tasks SET updated_at = CURRENT_TIMESTAMP WHERE task_id = OLD.task_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_mcp_profiles_updated_at
+AFTER UPDATE ON mcp_profiles
+FOR EACH ROW
+BEGIN
+    UPDATE mcp_profiles SET updated_at = CURRENT_TIMESTAMP WHERE mcp_id = OLD.mcp_id;
+END;

vibe_surf/backend/database/migrations/v002_add_agent_mode.sql

@@ -0,0 +1,6 @@
+-- Migration: v002_add_agent_mode.sql
+-- Description: Add agent_mode column to tasks table
+-- Version: 0.0.2
+
+-- Add agent_mode column to tasks table with default value 'thinking'
+ALTER TABLE tasks ADD COLUMN agent_mode VARCHAR(50) DEFAULT 'thinking';

vibe_surf/backend/database/models.py

@@ -71,7 +71,7 @@ class Task(Base):
     
     # Task definition
     task_description = Column(Text, nullable=False)
-    status = Column(Enum(TaskStatus), nullable=False, default=TaskStatus.PENDING)
+    status = Column(Enum(TaskStatus, values_callable=lambda obj: [e.value for e in obj]), nullable=False, default=TaskStatus.PENDING)
     
     # LLM Profile reference (instead of storing LLM config directly)
     llm_profile_name = Column(String(100), nullable=False)  # Reference to LLMProfile.profile_name
@@ -83,6 +83,9 @@ class Task(Base):
     # Configuration (JSON strings without API keys)
     mcp_server_config = Column(Text, nullable=True)  # MCP server config as JSON string
     
+    # Agent execution mode
+    agent_mode = Column(String(50), nullable=False, default='thinking')  # Agent mode: 'thinking' or 'direct'
+    
     # Results
     task_result = Column(Text, nullable=True)  # Final markdown result
     error_message = Column(Text, nullable=True)

vibe_surf/backend/database/queries.py

@@ -454,7 +454,8 @@ class TaskQueries:
             task_result: Optional[str] = None,
             task_status: str = "pending",
             error_message: Optional[str] = None,
-            report_path: Optional[str] = None
+            report_path: Optional[str] = None,
+            agent_mode: str = "thinking"
     ) -> Task:
         """Create or update a task record"""
         try:
@@ -507,7 +508,8 @@ class TaskQueries:
                     mcp_server_config=mcp_server_config_json,
                     task_result=task_result,
                     error_message=error_message,
-                    report_path=report_path
+                    report_path=report_path,
+                    agent_mode=agent_mode
                 )
 
                 db.add(task)

vibe_surf/backend/shared_state.py

@@ -106,6 +106,7 @@ async def execute_task_background(
         task: str,
         llm_profile_name: str,
         upload_files: Optional[List[str]] = None,
+        agent_mode: str = "thinking",
         db_session=None
 ):
     """Background task execution function for single task with LLM profile support"""
@@ -141,7 +142,8 @@ async def execute_task_background(
         result = await vibesurf_agent.run(
             task=task,
             upload_files=upload_files,
-            session_id=session_id
+            session_id=session_id,
+            agent_mode=agent_mode
         )
 
         # Update task status to completed
@@ -400,8 +402,8 @@ async def initialize_vibesurf_components():
 
         db_manager = DatabaseManager(database_url)
 
-        # Initialize database tables
-        await db_manager.create_tables()
+        # Initialize database tables with migration support
+        await db_manager.create_tables(use_migrations=True)
         logger.info("✅ Database manager initialized successfully")
 
         # Initialize LLM from default profile (if available) or fallback to environment variables