voice-mode 4.4.0__py3-none-any.whl → 4.5.0__py3-none-any.whl

voice_mode/simple_failover.py

@@ -8,11 +8,12 @@ Connection refused errors are instant, so there's no performance penalty.
 import logging
 from typing import Optional, Tuple, Dict, Any
 from openai import AsyncOpenAI
+from .provider_discovery import is_local_provider
 
 from .config import TTS_BASE_URLS, STT_BASE_URLS, OPENAI_API_KEY
 from .provider_discovery import detect_provider_type
 
-logger = logging.getLogger("voice-mode")
+logger = logging.getLogger("voicemode")
 
 
 async def simple_tts_failover(
@@ -71,10 +72,13 @@ async def simple_tts_failover(
             else:
                 selected_voice = voice  # Use original voice for Kokoro
             
+            # Disable retries for local endpoints - they either work or don't
+            max_retries = 0 if is_local_provider(base_url) else 2
             client = AsyncOpenAI(
                 api_key=api_key,
                 base_url=base_url,
-                timeout=30.0  # Reasonable timeout
+                timeout=30.0,  # Reasonable timeout
+                max_retries=max_retries
             )
             
             # Create clients dict for text_to_speech
@@ -132,19 +136,31 @@ async def simple_stt_failover(
     """
     last_error = None
     
+    # Log STT request details
+    logger.info("STT: Starting speech-to-text conversion")
+    logger.info(f"  Available endpoints: {STT_BASE_URLS}")
+
     # Try each STT endpoint in order
-    for base_url in STT_BASE_URLS:
+    for i, base_url in enumerate(STT_BASE_URLS):
         try:
-            logger.info(f"Trying STT endpoint: {base_url}")
-            
-            # Create client for this endpoint
+            # Detect provider type for logging
             provider_type = detect_provider_type(base_url)
+
+            if i == 0:
+                logger.info(f"STT: Attempting primary endpoint: {base_url} ({provider_type})")
+            else:
+                logger.warning(f"STT: Primary failed, attempting fallback #{i}: {base_url} ({provider_type})")
+
+            # Create client for this endpoint
             api_key = OPENAI_API_KEY if provider_type == "openai" else (OPENAI_API_KEY or "dummy-key-for-local")
             
+            # Disable retries for local endpoints - they either work or don't
+            max_retries = 0 if is_local_provider(base_url) else 2
             client = AsyncOpenAI(
                 api_key=api_key,
                 base_url=base_url,
-                timeout=30.0
+                timeout=30.0,
+                max_retries=max_retries
             )
             
             # Try STT with this endpoint
@@ -155,17 +171,30 @@ async def simple_stt_failover(
             )
             
             text = transcription.strip() if isinstance(transcription, str) else transcription.text.strip()
-            
+
             if text:
-                logger.info(f"STT succeeded with {base_url}")
-                return text
+                logger.info(f"✓ STT succeeded with {provider_type} at {base_url}")
+                logger.info(f"  Transcribed: {text[:100]}{'...' if len(text) > 100 else ''}")
+                # Return both text and provider info for display
+                return {"text": text, "provider": provider_type, "endpoint": base_url}
+            else:
+                logger.warning(f"STT returned empty result from {base_url} ({provider_type})")
                 
         except Exception as e:
             last_error = str(e)
-            logger.debug(f"STT failed for {base_url}: {e}")
+            provider_type = detect_provider_type(base_url)
+
+            # Log failure with appropriate level based on whether we have fallbacks
+            if i < len(STT_BASE_URLS) - 1:
+                logger.warning(f"STT failed for {base_url} ({provider_type}): {e}")
+                logger.info("  Will try next endpoint...")
+            else:
+                logger.error(f"STT failed for final endpoint {base_url} ({provider_type}): {e}")
+
             # Continue to next endpoint
             continue
     
     # All endpoints failed
-    logger.error(f"All STT endpoints failed. Last error: {last_error}")
+    logger.error(f"✗ All STT endpoints failed after {len(STT_BASE_URLS)} attempts")
+    logger.error(f"  Last error: {last_error}")
     return None

voice_mode/tools/__init__.py

@@ -9,42 +9,150 @@ logger = logging.getLogger("voice-mode")
 # Get the directory containing this file
 tools_dir = Path(__file__).parent
 
-# Check if we should only load specific tools
-# This can be set in .voicemode.env, shell environment, or .mcp.json
-allowed_tools = os.environ.get("VOICEMODE_TOOLS", "").strip()
-
-if allowed_tools:
-    # Only load specified tools (comma-separated list)
-    tool_list = [t.strip() for t in allowed_tools.split(",")]
-    
-    logger.info(f"Selective tool loading enabled. Loading only: {', '.join(tool_list)}")
-    
-    for tool_name in tool_list:
-        tool_file = tools_dir / f"{tool_name}.py"
-        if tool_file.exists():
-            logger.debug(f"Loading tool: {tool_name}")
-            importlib.import_module(f".{tool_name}", package=__name__)
-        else:
-            logger.warning(f"Tool module not found: {tool_name}.py")
-else:
-    # Default behavior: load all tools
-    logger.info("Loading all available tools (set VOICEMODE_TOOLS to limit)")
-    
-    # Import all Python files in this directory (except __init__.py)
+def get_all_available_tools() -> set[str]:
+    """
+    Get all available tool names from the filesystem.
+
+    Returns:
+        Set of tool module names (without .py extension)
+    """
+    available_tools = set()
+
+    # Get tools from main directory
     for file in tools_dir.glob("*.py"):
         if file.name != "__init__.py" and not file.name.startswith("_"):
-            module_name = file.stem
-            logger.debug(f"Loading tool: {module_name}")
-            importlib.import_module(f".{module_name}", package=__name__)
+            available_tools.add(file.stem)
 
-    # Import all service tools from subdirectories
+    # Get tools from services subdirectories
     services_dir = tools_dir / "services"
     if services_dir.exists():
         for service_dir in services_dir.iterdir():
             if service_dir.is_dir() and not service_dir.name.startswith("_"):
-                # Import all Python files in each service directory
                 for file in service_dir.glob("*.py"):
                     if file.name != "__init__.py" and not file.name.startswith("_") and file.name != "helpers.py":
-                        module_path = f".services.{service_dir.name}.{file.stem}"
-                        logger.debug(f"Loading service tool: {module_path}")
-                        importlib.import_module(module_path, package=__name__)
+                        # Use flattened naming: service_toolname
+                        tool_name = f"{service_dir.name}_{file.stem}"
+                        available_tools.add(tool_name)
+
+    return available_tools
+
+def parse_tool_list(tool_string: str) -> set[str]:
+    """
+    Parse comma-separated tool list into a set of tool names.
+
+    Args:
+        tool_string: Comma-separated string of tool names
+
+    Returns:
+        Set of trimmed tool names
+    """
+    if not tool_string:
+        return set()
+    return {t.strip() for t in tool_string.split(",") if t.strip()}
+
+def determine_tools_to_load() -> tuple[set[str], str]:
+    """
+    Determine which tools should be loaded based on environment variables.
+
+    Returns:
+        Tuple of (tools_to_load, mode_description)
+    """
+    # Check for new environment variables
+    enabled_tools = os.environ.get("VOICEMODE_TOOLS_ENABLED", "").strip()
+    disabled_tools = os.environ.get("VOICEMODE_TOOLS_DISABLED", "").strip()
+
+    # Check for legacy variable
+    legacy_tools = os.environ.get("VOICEMODE_TOOLS", "").strip()
+
+    # Get all available tools
+    all_tools = get_all_available_tools()
+
+    # Determine which tools to load
+    if enabled_tools:
+        # Whitelist mode - only load specified tools
+        requested = parse_tool_list(enabled_tools)
+        tools_to_load = requested & all_tools  # Only load tools that exist
+        invalid = requested - all_tools
+
+        if invalid:
+            logger.warning(f"Requested tools not found: {', '.join(sorted(invalid))}")
+
+        return tools_to_load, f"whitelist mode ({len(tools_to_load)} tools)"
+
+    elif disabled_tools:
+        # Blacklist mode - load all except specified
+        excluded = parse_tool_list(disabled_tools)
+        tools_to_load = all_tools - excluded
+
+        # Log if any excluded tools don't exist (informational)
+        nonexistent = excluded - all_tools
+        if nonexistent:
+            logger.debug(f"Excluded tools not found (ignoring): {', '.join(sorted(nonexistent))}")
+
+        return tools_to_load, f"blacklist mode (excluding {len(excluded & all_tools)} tools)"
+
+    elif legacy_tools:
+        # Legacy support with deprecation warning
+        logger.warning(
+            "VOICEMODE_TOOLS is deprecated and will be removed in v5.0. "
+            "Please use VOICEMODE_TOOLS_ENABLED or VOICEMODE_TOOLS_DISABLED instead."
+        )
+        requested = parse_tool_list(legacy_tools)
+        tools_to_load = requested & all_tools
+        invalid = requested - all_tools
+
+        if invalid:
+            logger.warning(f"Requested tools not found: {', '.join(sorted(invalid))}")
+
+        return tools_to_load, f"legacy mode ({len(tools_to_load)} tools)"
+
+    else:
+        # Default - load everything
+        return all_tools, "default mode (all tools)"
+
+def load_tool(tool_name: str) -> bool:
+    """
+    Load a single tool by name.
+
+    Args:
+        tool_name: Name of the tool to load
+
+    Returns:
+        True if successfully loaded, False otherwise
+    """
+    try:
+        # Check if it's a service tool (contains underscore)
+        if "_" in tool_name:
+            parts = tool_name.split("_", 1)
+            if len(parts) == 2:
+                service_name, tool_file = parts
+                module_path = f".services.{service_name}.{tool_file}"
+                logger.debug(f"Loading service tool: {tool_name}")
+                importlib.import_module(module_path, package=__name__)
+                return True
+
+        # Try as a regular tool
+        tool_file = tools_dir / f"{tool_name}.py"
+        if tool_file.exists():
+            logger.debug(f"Loading tool: {tool_name}")
+            importlib.import_module(f".{tool_name}", package=__name__)
+            return True
+
+        logger.warning(f"Tool not found: {tool_name}")
+        return False
+
+    except ImportError as e:
+        logger.error(f"Failed to import tool {tool_name}: {e}")
+        return False
+
+# Main loading logic
+tools_to_load, mode = determine_tools_to_load()
+
+if tools_to_load:
+    logger.info(f"Tool loading: {mode} - loading {len(tools_to_load)} tools")
+
+    # Sort for consistent loading order
+    for tool_name in sorted(tools_to_load):
+        load_tool(tool_name)
+else:
+    logger.warning("No tools to load based on current configuration")