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

vibe_surf/agents/browser_use_agent.py

@@ -525,7 +525,7 @@ class BrowserUseAgent(Agent):
         signal_handler.register()
 
         try:
-            self._log_agent_run()
+            await self._log_agent_run()
 
             self.logger.debug(
                 f'🔧 Agent setup: Task ID {self.task_id[-4:]}, Session ID {self.session_id[-4:]}, Browser Session ID {self.browser_session.id[-4:] if self.browser_session else "None"}'

vibe_surf/agents/prompts/vibe_surf_prompt.py

@@ -86,4 +86,5 @@ EXTEND_BU_SYSTEM_PROMPT = """
 * Regarding file operations, please note that you need the full relative path (including subfolders), not just the file name.
 * Especially when a file operation reports an error, please reflect whether the file path is not written correctly, such as the subfolder is not written.
 * If you are operating on files in the filesystem, be sure to use relative paths (relative to the workspace dir) instead of absolute paths.
+* If you are typing in the search box, please use Enter key to search instead of clicking.
 """

vibe_surf/backend/api/task.py

@@ -287,7 +287,7 @@ async def stop_task(control_request: TaskControlRequest):
                 active_task["end_time"] = datetime.now()
 
             # Clear active task
-            clear_active_task()
+            # clear_active_task()
 
             return {
                 "success": True,

vibe_surf/backend/api/voices.py

@@ -0,0 +1,481 @@
+"""
+Tools API endpoints for VibeSurf Backend
+
+Handles voice recognition and other tool-related operations.
+"""
+import pdb
+
+from fastapi import APIRouter, HTTPException, Depends, UploadFile, File
+from fastapi.responses import JSONResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import Dict, List, Optional, Any
+from pydantic import BaseModel
+import os
+import logging
+from datetime import datetime
+
+from vibe_surf.tools.voice_asr import QwenASR, OpenAIASR, GeminiASR
+
+from ..database.manager import get_db_session
+from ..database.queries import VoiceProfileQueries
+from ..voice_model_config import VOICE_MODELS
+
+
+router = APIRouter(prefix="/voices", tags=["voices"])
+
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+# Pydantic models for request validation
+class VoiceProfileCreate(BaseModel):
+    voice_profile_name: str
+    voice_model_type: str  # "asr" or "tts"
+    voice_model_name: str
+    api_key: Optional[str] = None
+    voice_meta_params: Optional[Dict[str, Any]] = None
+    description: Optional[str] = None
+
+class VoiceProfileUpdate(BaseModel):
+    voice_model_type: Optional[str] = None
+    voice_model_name: Optional[str] = None
+    api_key: Optional[str] = None
+    voice_meta_params: Optional[Dict[str, Any]] = None
+    description: Optional[str] = None
+    is_active: Optional[bool] = None
+
+
+@router.post("/voice-profiles")
+async def create_voice_profile(
+    profile_data: VoiceProfileCreate,
+    db: AsyncSession = Depends(get_db_session)
+):
+    """Create a new voice profile"""
+    try:
+        # Validate voice_model_type
+        if profile_data.voice_model_type not in ["asr", "tts"]:
+            raise HTTPException(
+                status_code=400,
+                detail="voice_model_type must be 'asr' or 'tts'"
+            )
+        
+        # Check if profile name already exists
+        existing_profile = await VoiceProfileQueries.get_profile(db, profile_data.voice_profile_name)
+        if existing_profile:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Voice profile '{profile_data.voice_profile_name}' already exists"
+            )
+        
+        # Create the profile
+        created_profile = await VoiceProfileQueries.create_profile(
+            db=db,
+            voice_profile_name=profile_data.voice_profile_name,
+            voice_model_type=profile_data.voice_model_type,
+            voice_model_name=profile_data.voice_model_name,
+            api_key=profile_data.api_key,
+            voice_meta_params=profile_data.voice_meta_params,
+            description=profile_data.description
+        )
+        
+        await db.commit()
+        
+        return {
+            "success": True,
+            "message": f"Voice profile '{profile_data.voice_profile_name}' created successfully",
+            "profile": created_profile
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        await db.rollback()
+        logger.error(f"Failed to create voice profile: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to create voice profile: {str(e)}"
+        )
+
+
+@router.put("/voice-profiles/{voice_profile_name}")
+async def update_voice_profile(
+    voice_profile_name: str,
+    profile_data: VoiceProfileUpdate,
+    db: AsyncSession = Depends(get_db_session)
+):
+    """Update an existing voice profile"""
+    try:
+        # Check if profile exists
+        existing_profile = await VoiceProfileQueries.get_profile(db, voice_profile_name)
+        if not existing_profile:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Voice profile '{voice_profile_name}' not found"
+            )
+        
+        # Validate voice_model_type if provided
+        if profile_data.voice_model_type and profile_data.voice_model_type not in ["asr", "tts"]:
+            raise HTTPException(
+                status_code=400,
+                detail="voice_model_type must be 'asr' or 'tts'"
+            )
+        
+        # Prepare update data (exclude None values)
+        update_data = {}
+        for field, value in profile_data.dict(exclude_unset=True).items():
+            if value is not None:
+                update_data[field] = value
+        
+        if not update_data:
+            raise HTTPException(
+                status_code=400,
+                detail="No valid fields provided for update"
+            )
+        
+        # Update the profile
+        success = await VoiceProfileQueries.update_profile(
+            db=db,
+            voice_profile_name=voice_profile_name,
+            updates=update_data
+        )
+        
+        if not success:
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to update voice profile"
+            )
+        
+        await db.commit()
+        
+        # Get updated profile
+        updated_profile = await VoiceProfileQueries.get_profile(db, voice_profile_name)
+        
+        return {
+            "success": True,
+            "message": f"Voice profile '{voice_profile_name}' updated successfully",
+            "profile": {
+                "profile_id": updated_profile.profile_id,
+                "voice_profile_name": updated_profile.voice_profile_name,
+                "voice_model_type": updated_profile.voice_model_type.value,
+                "voice_model_name": updated_profile.voice_model_name,
+                "voice_meta_params": updated_profile.voice_meta_params,
+                "description": updated_profile.description,
+                "is_active": updated_profile.is_active,
+                "created_at": updated_profile.created_at,
+                "updated_at": updated_profile.updated_at,
+                "last_used_at": updated_profile.last_used_at
+            }
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        await db.rollback()
+        logger.error(f"Failed to update voice profile: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to update voice profile: {str(e)}"
+        )
+
+
+@router.delete("/voice-profiles/{voice_profile_name}")
+async def delete_voice_profile(
+    voice_profile_name: str,
+    db: AsyncSession = Depends(get_db_session)
+):
+    """Delete a voice profile"""
+    try:
+        # Check if profile exists
+        existing_profile = await VoiceProfileQueries.get_profile(db, voice_profile_name)
+        if not existing_profile:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Voice profile '{voice_profile_name}' not found"
+            )
+        
+        # Delete the profile
+        success = await VoiceProfileQueries.delete_profile(db, voice_profile_name)
+        
+        if not success:
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to delete voice profile"
+            )
+        
+        await db.commit()
+        
+        return {
+            "success": True,
+            "message": f"Voice profile '{voice_profile_name}' deleted successfully"
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        await db.rollback()
+        logger.error(f"Failed to delete voice profile: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to delete voice profile: {str(e)}"
+        )
+
+
+@router.post("/asr")
+async def voice_recognition(
+    audio_file: UploadFile = File(...),
+    voice_profile_name: str = None,
+    db: AsyncSession = Depends(get_db_session)
+):
+    """
+    Voice recognition using specified voice profile
+    
+    Args:
+        audio_file: Audio file to transcribe
+        voice_profile_name: Name of the voice profile to use (required)
+        db: Database session
+    
+    Returns:
+        Dict with recognized text
+    """
+    from .. import shared_state
+    try:
+        # Validate required parameters
+        if not voice_profile_name:
+            raise HTTPException(
+                status_code=400,
+                detail="voice_profile_name parameter is required"
+            )
+        
+        if not audio_file or not audio_file.filename:
+            raise HTTPException(
+                status_code=400,
+                detail="audio_file is required and must have a filename"
+            )
+        
+        # Log the incoming request for debugging
+        logger.info(f"ASR request: voice_profile_name='{voice_profile_name}', audio_file='{audio_file.filename}', size={audio_file.size if hasattr(audio_file, 'size') else 'unknown'}")
+        
+        # Get voice profile with decrypted API key
+        profile_data = await VoiceProfileQueries.get_profile_with_decrypted_key(db, voice_profile_name)
+        if not profile_data:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Voice profile '{voice_profile_name}' not found"
+            )
+        
+        # Check if profile is active
+        if not profile_data.get("is_active"):
+            raise HTTPException(
+                status_code=400,
+                detail=f"Voice profile '{voice_profile_name}' is inactive"
+            )
+        
+        # Check if profile is for ASR
+        if profile_data.get("voice_model_type") != "asr":
+            raise HTTPException(
+                status_code=400,
+                detail=f"Voice profile '{voice_profile_name}' is not an ASR profile"
+            )
+        
+        # Get model configuration
+        voice_model_name = profile_data.get("voice_model_name")
+        model_config = VOICE_MODELS.get(voice_model_name)
+        if not model_config:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Voice model '{voice_model_name}' is not supported"
+            )
+        
+        # Save uploaded file permanently in workspace_dir/audios/
+        saved_file_path = None
+        try:
+            # Get workspace directory
+            workspace_dir = shared_state.workspace_dir
+            if not workspace_dir:
+                raise HTTPException(
+                    status_code=500,
+                    detail="Workspace directory not configured"
+                )
+            
+            # Create audios directory if it doesn't exist
+            audios_dir = os.path.join(workspace_dir, "audios")
+            os.makedirs(audios_dir, exist_ok=True)
+            
+            # Generate timestamp-based filename
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]  # microseconds to milliseconds
+            file_extension = ".wav"  # Default to wav
+            if audio_file.filename:
+                original_ext = os.path.splitext(audio_file.filename)[1]
+                if original_ext:
+                    file_extension = original_ext
+            
+            saved_filename = f"asr-{timestamp}{file_extension}"
+            saved_file_path = os.path.join(audios_dir, saved_filename)
+            
+            # Save the audio file
+            content = await audio_file.read()
+            with open(saved_file_path, "wb") as f:
+                f.write(content)
+            
+            # Initialize ASR
+            api_key = profile_data.get("api_key")
+            voice_meta_params = profile_data.get("voice_meta_params", {})
+            asr_model_name = voice_meta_params.get("asr_model_name", "")
+            recognized_text = ""
+            if voice_model_name == "qwen-asr":
+                asr = QwenASR(model=asr_model_name, api_key=api_key)
+                recognized_text = asr.asr(wav_url=saved_file_path)
+            elif voice_model_name == "openai-asr":
+                # Support custom base_url for OpenAI
+                base_url = voice_meta_params.get("base_url")
+                asr = OpenAIASR(model=asr_model_name, api_key=api_key, base_url=base_url)
+                recognized_text = asr.asr(wav_url=saved_file_path)
+            elif voice_model_name == "gemini-asr":
+                asr = GeminiASR(model=asr_model_name, api_key=api_key)
+                recognized_text = asr.asr(wav_url=saved_file_path)
+            else:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Voice model '{voice_model_name}' is not supported"
+                )
+            logger.debug(f"Recognized text: {recognized_text}")
+            # Update last used timestamp
+            await VoiceProfileQueries.update_last_used(db, voice_profile_name)
+            await db.commit()
+            
+            return {
+                "success": True,
+                "voice_profile_name": voice_profile_name,
+                "voice_model_name": voice_model_name,
+                "recognized_text": recognized_text,
+                "filename": audio_file.filename,
+                "saved_audio_path": saved_file_path
+            }
+            
+        except Exception as e:
+            # If there's an error, we might want to clean up the saved file
+            if saved_file_path and os.path.exists(saved_file_path):
+                try:
+                    os.unlink(saved_file_path)
+                except:
+                    pass  # Ignore cleanup errors
+            raise e
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to perform voice recognition: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Voice recognition failed: {str(e)}"
+        )
+
+
+@router.get("/voice-profiles")
+async def list_voice_profiles(
+    voice_model_type: Optional[str] = None,
+    active_only: bool = True,
+    limit: int = 50,
+    offset: int = 0,
+    db: AsyncSession = Depends(get_db_session)
+):
+    """List voice profiles"""
+    try:
+        profiles = await VoiceProfileQueries.list_profiles(
+            db=db,
+            voice_model_type=voice_model_type,
+            active_only=active_only,
+            limit=limit,
+            offset=offset
+        )
+        
+        profile_list = []
+        for profile in profiles:
+            profile_data = {
+                "profile_id": profile.profile_id,
+                "voice_profile_name": profile.voice_profile_name,
+                "voice_model_type": profile.voice_model_type.value,
+                "voice_model_name": profile.voice_model_name,
+                "voice_meta_params": profile.voice_meta_params,
+                "description": profile.description,
+                "is_active": profile.is_active,
+                "created_at": profile.created_at,
+                "updated_at": profile.updated_at,
+                "last_used_at": profile.last_used_at
+            }
+            profile_list.append(profile_data)
+        
+        return {
+            "profiles": profile_list,
+            "total": len(profile_list),
+            "voice_model_type": voice_model_type,
+            "active_only": active_only
+        }
+        
+    except Exception as e:
+        logger.error(f"Failed to list voice profiles: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to list voice profiles: {str(e)}"
+        )
+
+
+@router.get("/models")
+async def get_available_voice_models(model_type: Optional[str] = None):
+    """Get list of all available voice models"""
+    models = []
+    for model_name, config in VOICE_MODELS.items():
+        # Filter by model_type if provided
+        config_model_type = config.get("model_type", "asr")
+        if model_type and config_model_type != model_type:
+            continue
+            
+        model_info = {
+            "model_name": model_name,
+            "model_type": config_model_type,
+            "requires_api_key": config.get("requires_api_key", True)
+        }
+        models.append(model_info)
+    
+    return {
+        "models": models,
+        "total_models": len(models)
+    }
+
+
+@router.get("/{voice_profile_name}")
+async def get_voice_profile(
+    voice_profile_name: str,
+    db: AsyncSession = Depends(get_db_session)
+):
+    """Get specific voice profile by name (without API key)"""
+    try:
+        profile = await VoiceProfileQueries.get_profile(db, voice_profile_name)
+        if not profile:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Voice profile '{voice_profile_name}' not found"
+            )
+        
+        return {
+            "profile_id": profile.profile_id,
+            "voice_profile_name": profile.voice_profile_name,
+            "voice_model_type": profile.voice_model_type.value,
+            "voice_model_name": profile.voice_model_name,
+            "voice_meta_params": profile.voice_meta_params,
+            "description": profile.description,
+            "is_active": profile.is_active,
+            "created_at": profile.created_at,
+            "updated_at": profile.updated_at,
+            "last_used_at": profile.last_used_at
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get voice profile: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to get voice profile: {str(e)}"
+        )

vibe_surf/backend/database/migrations/v004_add_voice_profiles.sql

@@ -0,0 +1,35 @@
+-- Migration: v004_add_voice_profiles.sql
+-- Description: Add voice_profiles table for voice model management
+-- Version: 0.0.4
+
+-- Enable foreign keys
+PRAGMA foreign_keys = ON;
+
+-- Create Voice Profiles table
+CREATE TABLE IF NOT EXISTS voice_profiles (
+    profile_id VARCHAR(36) NOT NULL PRIMARY KEY,
+    voice_profile_name VARCHAR(100) NOT NULL UNIQUE,
+    voice_model_type VARCHAR(3) NOT NULL,
+    voice_model_name VARCHAR(100) NOT NULL,
+    encrypted_api_key TEXT,
+    voice_meta_params JSON,
+    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,
+    CHECK (voice_model_type IN ('asr', 'tts'))
+);
+
+-- Create indexes for voice profiles
+CREATE INDEX IF NOT EXISTS idx_voice_profiles_name ON voice_profiles(voice_profile_name);
+CREATE INDEX IF NOT EXISTS idx_voice_profiles_type ON voice_profiles(voice_model_type);
+CREATE INDEX IF NOT EXISTS idx_voice_profiles_active ON voice_profiles(is_active);
+
+-- Create trigger for automatic timestamp updates
+CREATE TRIGGER IF NOT EXISTS update_voice_profiles_updated_at
+AFTER UPDATE ON voice_profiles
+FOR EACH ROW
+BEGIN
+    UPDATE voice_profiles SET updated_at = CURRENT_TIMESTAMP WHERE profile_id = OLD.profile_id;
+END;

vibe_surf/backend/database/models.py

@@ -22,6 +22,38 @@ class TaskStatus(enum.Enum):
     FAILED = "failed"
     STOPPED = "stopped"
 
+class VoiceModelType(enum.Enum):
+    ASR = "asr"
+    TTS = "tts"
+
+class VoiceProfile(Base):
+    """Voice Profile model for managing voice model configurations with encrypted API keys"""
+    __tablename__ = 'voice_profiles'
+    
+    # Primary identifier
+    profile_id = Column(String(36), primary_key=True, default=lambda: str(uuid4()))
+    voice_profile_name = Column(String(100), nullable=False, unique=True)  # User-defined unique name
+    
+    # Voice Model Configuration
+    voice_model_type = Column(Enum(VoiceModelType, values_callable=lambda obj: [e.value for e in obj]), nullable=False)  # asr or tts
+    voice_model_name = Column(String(100), nullable=False)
+    encrypted_api_key = Column(Text, nullable=True)  # Encrypted API key using MAC address
+    
+    # Voice model parameters (stored as JSON to allow flexibility)
+    voice_meta_params = Column(JSON, nullable=True)  # Model-specific parameters
+    
+    # Profile metadata
+    description = Column(Text, nullable=True)
+    is_active = Column(Boolean, default=True, nullable=False)
+    
+    # Timestamps
+    created_at = Column(DateTime, nullable=False, default=func.now())
+    updated_at = Column(DateTime, nullable=False, default=func.now(), onupdate=func.now())
+    last_used_at = Column(DateTime, nullable=True)
+    
+    def __repr__(self):
+        return f"<VoiceProfile(voice_profile_name={self.voice_profile_name}, voice_model_name={self.voice_model_name}, type={self.voice_model_type.value})>"
+
 class LLMProfile(Base):
     """LLM Profile model for managing LLM configurations with encrypted API keys"""
     __tablename__ = 'llm_profiles'
@@ -164,4 +196,9 @@ Index('idx_uploaded_files_filename', UploadedFile.original_filename)
 # MCP Profile indexes
 Index('idx_mcp_profiles_display_name', McpProfile.display_name)
 Index('idx_mcp_profiles_server_name', McpProfile.mcp_server_name)
-Index('idx_mcp_profiles_active', McpProfile.is_active)
+Index('idx_mcp_profiles_active', McpProfile.is_active)
+
+# Voice Profile indexes
+Index('idx_voice_profiles_name', VoiceProfile.voice_profile_name)
+Index('idx_voice_profiles_type', VoiceProfile.voice_model_type)
+Index('idx_voice_profiles_active', VoiceProfile.is_active)