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

voice_mode/frontend/.next/types/app/api/connection-details/route.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-z_iazuah/voice_mode-4.4.0/voice_mode/frontend/app/api/connection-details/route.ts
+// File: /tmp/build-via-sdist-yrh8rni2/voice_mode-4.5.0/voice_mode/frontend/app/api/connection-details/route.ts
 import * as entry from '../../../../../app/api/connection-details/route.js'
 import type { NextRequest } from 'next/server.js'
 

voice_mode/frontend/.next/types/app/layout.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-z_iazuah/voice_mode-4.4.0/voice_mode/frontend/app/layout.tsx
+// File: /tmp/build-via-sdist-yrh8rni2/voice_mode-4.5.0/voice_mode/frontend/app/layout.tsx
 import * as entry from '../../../app/layout.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/.next/types/app/page.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-z_iazuah/voice_mode-4.4.0/voice_mode/frontend/app/page.tsx
+// File: /tmp/build-via-sdist-yrh8rni2/voice_mode-4.5.0/voice_mode/frontend/app/page.tsx
 import * as entry from '../../../app/page.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/package-lock.json

@@ -1328,6 +1328,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.5.tgz",
+      "integrity": "sha512-TiU4qUT9jdCuh4aVOG7H1QozyeI2sZRqoRPdqBIaslfNt4WUSanRBueAwl2x5jt4rXBMim3lIN2x6yT8PDi24Q==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.js"
+      }
+    },
     "node_modules/binary-extensions": {
       "version": "2.3.0",
       "dev": true,
@@ -1360,9 +1370,9 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.25.4",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.25.4.tgz",
-      "integrity": "sha512-4jYpcjabC606xJ3kw2QwGEZKX0Aw7sgQdZCvIK9dhVSPh76BKo+C+btT1RRofH7B+8iNpEbgGNVWiLki5q93yg==",
+      "version": "4.26.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.26.2.tgz",
+      "integrity": "sha512-ECFzp6uFOSB+dcZ5BK/IBaGWssbSYBHvuMeMt3MMFyhI0Z8SqGgEkBLARgpRH3hutIgPVsALcMwbDrJqPxQ65A==",
       "dev": true,
       "funding": [
         {
@@ -1380,9 +1390,10 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "caniuse-lite": "^1.0.30001737",
-        "electron-to-chromium": "^1.5.211",
-        "node-releases": "^2.0.19",
+        "baseline-browser-mapping": "^2.8.3",
+        "caniuse-lite": "^1.0.30001741",
+        "electron-to-chromium": "^1.5.218",
+        "node-releases": "^2.0.21",
         "update-browserslist-db": "^1.1.3"
       },
       "bin": {
@@ -1489,9 +1500,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001741",
-      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001741.tgz",
-      "integrity": "sha512-QGUGitqsc8ARjLdgAfxETDhRbJ0REsP6O3I96TAth/mVjh2cYzN2u+3AzPP3aVSm2FehEItaJw1xd+IGBXWeSw==",
+      "version": "1.0.30001743",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001743.tgz",
+      "integrity": "sha512-e6Ojr7RV14Un7dz6ASD0aZDmQPT/A+eZU+nuTNfjqmRrmkmQlnTNWH0SKmqagx9PeW87UVqapSurtAXifmtdmw==",
       "dev": true,
       "funding": [
         {
@@ -1774,9 +1785,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.215",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.215.tgz",
-      "integrity": "sha512-TIvGp57UpeNetj/wV/xpFNpWGb0b/ROw372lHPx5Aafx02gjTBtWnEEcaSX3W2dLM3OSdGGyHX/cHl01JQsLaQ==",
+      "version": "1.5.220",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.220.tgz",
+      "integrity": "sha512-TWXijEwR1ggr4BdAKrb1nMNqYLTx1/4aD1fkeZU+FVJGTKu53/T7UyHKXlqEX3Ub02csyHePbHmkvnrjcaYzMA==",
       "dev": true,
       "license": "ISC"
     },
@@ -3799,9 +3810,9 @@
       }
     },
     "node_modules/node-releases": {
-      "version": "2.0.20",
-      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.20.tgz",
-      "integrity": "sha512-7gK6zSXEH6neM212JgfYFXe+GmZQM+fia5SsusuBIUgnPheLFBmIPhtFoAQRj8/7wASYQnbDlHPVwY0BefoFgA==",
+      "version": "2.0.21",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.21.tgz",
+      "integrity": "sha512-5b0pgg78U3hwXkCM8Z9b2FJdPZlr9Psr9V2gQPESdGHqbntyFJKFW4r5TeWGFzafGY3hzs1JC62VEQMbl1JFkw==",
       "dev": true,
       "license": "MIT"
     },

voice_mode/provider_discovery.py

@@ -26,6 +26,8 @@ logger = logging.getLogger("voice-mode")
 
 def detect_provider_type(base_url: str) -> str:
     """Detect provider type from base URL."""
+    if not base_url:
+        return "unknown"
     if "openai.com" in base_url:
         return "openai"
     elif ":8880" in base_url:
@@ -47,6 +49,8 @@ def detect_provider_type(base_url: str) -> str:
 
 def is_local_provider(base_url: str) -> bool:
     """Check if a provider URL is for a local service."""
+    if not base_url:
+        return False
     provider_type = detect_provider_type(base_url)
     return provider_type in ["kokoro", "whisper", "local"] or \
            "127.0.0.1" in base_url or \
@@ -57,13 +61,11 @@ def is_local_provider(base_url: str) -> bool:
 class EndpointInfo:
     """Information about a discovered endpoint."""
     base_url: str
-    healthy: bool
     models: List[str]
     voices: List[str]  # Only for TTS
-    last_health_check: str  # ISO format timestamp
-    response_time_ms: Optional[float] = None
-    error: Optional[str] = None
     provider_type: Optional[str] = None  # e.g., "openai", "kokoro", "whisper"
+    last_check: Optional[str] = None  # ISO format timestamp of last attempt
+    last_error: Optional[str] = None  # Last error if any
 
 
 class ProviderRegistry:
@@ -78,44 +80,38 @@ class ProviderRegistry:
         self._initialized = False
     
     async def initialize(self):
-        """Initialize the registry by assuming all configured endpoints are healthy."""
+        """Initialize the registry with configured endpoints."""
         if self._initialized:
             return
-        
+
         async with self._discovery_lock:
             if self._initialized:  # Double-check after acquiring lock
                 return
-            
-            logger.info("Initializing provider registry (optimistic mode)...")
-            
-            # Initialize TTS endpoints as healthy
+
+            logger.info("Initializing provider registry...")
+
+            # Initialize TTS endpoints
             for url in TTS_BASE_URLS:
                 provider_type = detect_provider_type(url)
                 self.registry["tts"][url] = EndpointInfo(
                     base_url=url,
-                    healthy=True,
                     models=["gpt4o-mini-tts", "tts-1", "tts-1-hd"] if provider_type == "openai" else ["tts-1"],
                     voices=["alloy", "echo", "fable", "nova", "onyx", "shimmer"] if provider_type == "openai" else ["af_alloy", "af_aoede", "af_bella", "af_heart", "af_jadzia", "af_jessica", "af_kore", "af_nicole", "af_nova", "af_river", "af_sarah", "af_sky", "af_v0", "af_v0bella", "af_v0irulan", "af_v0nicole", "af_v0sarah", "af_v0sky", "am_adam", "am_echo", "am_eric", "am_fenrir", "am_liam", "am_michael", "am_onyx", "am_puck", "am_santa", "am_v0adam", "am_v0gurney", "am_v0michael", "bf_alice", "bf_emma", "bf_lily", "bf_v0emma", "bf_v0isabella", "bm_daniel", "bm_fable", "bm_george", "bm_lewis", "bm_v0george", "bm_v0lewis", "ef_dora", "em_alex", "em_santa", "ff_siwis", "hf_alpha", "hf_beta", "hm_omega", "hm_psi", "if_sara", "im_nicola", "jf_alpha", "jf_gongitsune", "jf_nezumi", "jf_tebukuro", "jm_kumo", "pf_dora", "pm_alex", "pm_santa", "zf_xiaobei", "zf_xiaoni", "zf_xiaoxiao", "zf_xiaoyi", "zm_yunjian", "zm_yunxi", "zm_yunxia", "zm_yunyang"],
-                    last_health_check=datetime.now(timezone.utc).isoformat(),
-                    response_time_ms=None,
                     provider_type=provider_type
                 )
             
-            # Initialize STT endpoints as healthy
+            # Initialize STT endpoints
             for url in STT_BASE_URLS:
                 provider_type = detect_provider_type(url)
                 self.registry["stt"][url] = EndpointInfo(
                     base_url=url,
-                    healthy=True,
                     models=["whisper-1"],
-                    voices=[],
-                    last_health_check=datetime.now(timezone.utc).isoformat(),
-                    response_time_ms=None,
+                    voices=[],  # STT doesn't have voices
                     provider_type=provider_type
                 )
-            
+
             self._initialized = True
-            logger.info(f"Provider registry initialized with {len(self.registry['tts'])} TTS and {len(self.registry['stt'])} STT endpoints (all assumed healthy)")
+            logger.info(f"Provider registry initialized with {len(self.registry['tts'])} TTS and {len(self.registry['stt'])} STT endpoints")
     
     async def _discover_endpoints(self, service_type: str, base_urls: List[str]):
         """Discover all endpoints for a service type."""
@@ -131,12 +127,11 @@ class ProviderRegistry:
                     logger.error(f"Failed to discover {service_type} endpoint {url}: {result}")
                     self.registry[service_type][url] = EndpointInfo(
                         base_url=url,
-                        healthy=False,
                         models=[],
                         voices=[],
-                        last_health_check=datetime.now(timezone.utc).isoformat(),
-                        error=str(result),
-                        provider_type=detect_provider_type(url)
+                        provider_type=detect_provider_type(url),
+                        last_check=datetime.now(timezone.utc).isoformat(),
+                        last_error=str(result)
                     )
     
     async def _discover_endpoint(self, service_type: str, base_url: str) -> None:
@@ -201,12 +196,11 @@ class ProviderRegistry:
             # Store endpoint info
             self.registry[service_type][base_url] = EndpointInfo(
                 base_url=base_url,
-                healthy=True,
                 models=models,
                 voices=voices,
-                last_health_check=datetime.now(timezone.utc).isoformat(),
-                response_time_ms=response_time,
-                provider_type=detect_provider_type(base_url)
+                provider_type=detect_provider_type(base_url),
+                last_check=datetime.now(timezone.utc).isoformat(),
+                last_error=None
             )
             
             logger.info(f"Successfully discovered {service_type} endpoint {base_url} with {len(models)} models and {len(voices)} voices")
@@ -215,12 +209,11 @@ class ProviderRegistry:
             logger.warning(f"Endpoint {base_url} discovery failed: {e}")
             self.registry[service_type][base_url] = EndpointInfo(
                 base_url=base_url,
-                healthy=False,
                 models=[],
                 voices=[],
-                last_health_check=datetime.now(timezone.utc).isoformat(),
-                error=str(e),
-                provider_type=detect_provider_type(base_url)
+                provider_type=detect_provider_type(base_url),
+                last_check=datetime.now(timezone.utc).isoformat(),
+                last_error=str(e)
             )
     
     async def _discover_voices(self, base_url: str, client: AsyncOpenAI) -> List[str]:
@@ -247,41 +240,35 @@ class ProviderRegistry:
         # The system will use configured defaults instead
         return []
     
-    async def check_health(self, service_type: str, base_url: str) -> bool:
-        """Check the health of a specific endpoint and update registry."""
-        logger.debug(f"Health check for {service_type} endpoint: {base_url}")
-        
-        # Re-discover the endpoint
-        await self._discover_endpoint(service_type, base_url)
-        
-        # Return health status
-        endpoint_info = self.registry[service_type].get(base_url)
-        return endpoint_info.healthy if endpoint_info else False
     
-    def get_healthy_endpoints(self, service_type: str) -> List[EndpointInfo]:
-        """Get all healthy endpoints for a service type."""
+    def get_endpoints(self, service_type: str) -> List[EndpointInfo]:
+        """Get all endpoints for a service type in priority order."""
         endpoints = []
-        
+
         # Return endpoints in the order they were configured
         base_urls = TTS_BASE_URLS if service_type == "tts" else STT_BASE_URLS
-        
+
         for url in base_urls:
             info = self.registry[service_type].get(url)
-            if info and info.healthy:
+            if info:
                 endpoints.append(info)
-        
+
         return endpoints
+
+    def get_healthy_endpoints(self, service_type: str) -> List[EndpointInfo]:
+        """Deprecated: Use get_endpoints instead. Returns all endpoints."""
+        return self.get_endpoints(service_type)
     
     def find_endpoint_with_voice(self, voice: str) -> Optional[EndpointInfo]:
-        """Find the first healthy TTS endpoint that supports a specific voice."""
-        for endpoint in self.get_healthy_endpoints("tts"):
+        """Find the first TTS endpoint that supports a specific voice."""
+        for endpoint in self.get_endpoints("tts"):
             if voice in endpoint.voices:
                 return endpoint
         return None
-    
+
     def find_endpoint_with_model(self, service_type: str, model: str) -> Optional[EndpointInfo]:
-        """Find the first healthy endpoint that supports a specific model."""
-        for endpoint in self.get_healthy_endpoints(service_type):
+        """Find the first endpoint that supports a specific model."""
+        for endpoint in self.get_endpoints(service_type):
             if model in endpoint.models:
                 return endpoint
         return None
@@ -291,47 +278,36 @@ class ProviderRegistry:
         return {
             "tts": {
                 url: {
-                    "healthy": info.healthy,
                     "models": info.models,
                     "voices": info.voices,
-                    "response_time_ms": info.response_time_ms,
-                    "last_check": info.last_health_check,
-                    "error": info.error
+                    "provider_type": info.provider_type,
+                    "last_check": info.last_check,
+                    "last_error": info.last_error
                 }
                 for url, info in self.registry["tts"].items()
             },
             "stt": {
                 url: {
-                    "healthy": info.healthy,
                     "models": info.models,
-                    "response_time_ms": info.response_time_ms,
-                    "last_check": info.last_health_check,
-                    "error": info.error
+                    "provider_type": info.provider_type,
+                    "last_check": info.last_check,
+                    "last_error": info.last_error
                 }
                 for url, info in self.registry["stt"].items()
             }
         }
     
-    async def mark_unhealthy(self, service_type: str, base_url: str, error: str):
-        """Mark an endpoint as unhealthy after a failure.
-        
-        If ALWAYS_TRY_LOCAL is enabled and the provider is local, it will not be
-        permanently marked as unhealthy - it will be retried on next request.
+    async def mark_failed(self, service_type: str, base_url: str, error: str):
+        """Record that an endpoint failed.
+
+        This updates the last_error and last_check fields for diagnostics,
+        but doesn't prevent the endpoint from being tried again.
         """
         if base_url in self.registry[service_type]:
-            # Check if we should skip marking local providers as unhealthy
-            if config.ALWAYS_TRY_LOCAL and is_local_provider(base_url):
-                # Log the error but don't mark as unhealthy
-                logger.info(f"Local {service_type} endpoint {base_url} failed ({error}) but will be retried (ALWAYS_TRY_LOCAL enabled)")
-                # Update error and last check time for diagnostics, but keep healthy=True
-                self.registry[service_type][base_url].error = f"{error} (will retry)"
-                self.registry[service_type][base_url].last_health_check = datetime.now(timezone.utc).isoformat()
-            else:
-                # Normal behavior - mark as unhealthy
-                self.registry[service_type][base_url].healthy = False
-                self.registry[service_type][base_url].error = error
-                self.registry[service_type][base_url].last_health_check = datetime.now(timezone.utc).isoformat()
-                logger.warning(f"Marked {service_type} endpoint {base_url} as unhealthy: {error}")
+            # Update error and last check time for diagnostics
+            self.registry[service_type][base_url].last_error = error
+            self.registry[service_type][base_url].last_check = datetime.now(timezone.utc).isoformat()
+            logger.info(f"{service_type} endpoint {base_url} failed: {error}")
 
 
 # Global registry instance

voice_mode/providers.py

@@ -10,7 +10,7 @@ from typing import Dict, Optional, List, Any, Tuple
 from openai import AsyncOpenAI
 
 from .config import TTS_VOICES, TTS_MODELS, TTS_BASE_URLS, OPENAI_API_KEY, get_voice_preferences
-from .provider_discovery import provider_registry, EndpointInfo
+from .provider_discovery import provider_registry, EndpointInfo, is_local_provider
 
 logger = logging.getLogger("voice-mode")
 
@@ -49,21 +49,24 @@ async def get_tts_client_and_voice(
     if base_url:
         logger.info(f"TTS Provider Selection: Using specific base URL: {base_url}")
         endpoint_info = provider_registry.registry["tts"].get(base_url)
-        if not endpoint_info or not endpoint_info.healthy:
-            raise ValueError(f"Requested base URL {base_url} is not available")
-        
+        if not endpoint_info:
+            raise ValueError(f"Requested base URL {base_url} is not configured")
+
         selected_voice = voice or _select_voice_for_endpoint(endpoint_info)
         selected_model = model or _select_model_for_endpoint(endpoint_info)
-        
+
+        # 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=OPENAI_API_KEY or "dummy-key-for-local",
-            base_url=base_url
+            base_url=base_url,
+            max_retries=max_retries
         )
-        
+
         logger.info(f"  • Selected endpoint: {base_url}")
         logger.info(f"  • Selected voice: {selected_voice}")
         logger.info(f"  • Selected model: {selected_model}")
-        
+
         return client, selected_voice, selected_model, endpoint_info
     
     # Voice-first selection algorithm
@@ -83,69 +86,75 @@ async def get_tts_client_and_voice(
         logger.info(f"  Specific voice requested: {voice}")
         for url in TTS_BASE_URLS:
             endpoint_info = provider_registry.registry["tts"].get(url)
-            if not endpoint_info or not endpoint_info.healthy:
+            if not endpoint_info:
                 continue
-            
+
             if voice in endpoint_info.voices:
                 selected_voice = voice
                 selected_model = _select_model_for_endpoint(endpoint_info, model)
-                
+
                 api_key = OPENAI_API_KEY if endpoint_info.provider_type == "openai" else (OPENAI_API_KEY or "dummy-key-for-local")
-                client = AsyncOpenAI(api_key=api_key, base_url=url)
-                
+                # Disable retries for local endpoints - they either work or don't
+                max_retries = 0 if is_local_provider(url) else 2
+                client = AsyncOpenAI(api_key=api_key, base_url=url, max_retries=max_retries)
+
                 logger.info(f"  ✓ Selected endpoint: {url} ({endpoint_info.provider_type})")
                 logger.info(f"  ✓ Selected voice: {selected_voice}")
                 logger.info(f"  ✓ Selected model: {selected_model}")
-                
+
                 return client, selected_voice, selected_model, endpoint_info
     
     # No specific voice requested - iterate through voice preferences
     logger.info("  No specific voice requested, checking voice preferences...")
     for preferred_voice in combined_voice_list:
         logger.debug(f"  Looking for voice: {preferred_voice}")
-        
+
         # Check each endpoint for this voice
         for url in TTS_BASE_URLS:
             endpoint_info = provider_registry.registry["tts"].get(url)
-            if not endpoint_info or not endpoint_info.healthy:
+            if not endpoint_info:
                 continue
-            
+
             if preferred_voice in endpoint_info.voices:
                 logger.info(f"  Found voice '{preferred_voice}' at {url} ({endpoint_info.provider_type})")
                 selected_voice = preferred_voice
                 selected_model = _select_model_for_endpoint(endpoint_info, model)
-                
+
                 api_key = OPENAI_API_KEY if endpoint_info.provider_type == "openai" else (OPENAI_API_KEY or "dummy-key-for-local")
-                client = AsyncOpenAI(api_key=api_key, base_url=url)
-                
+                # Disable retries for local endpoints - they either work or don't
+                max_retries = 0 if is_local_provider(url) else 2
+                client = AsyncOpenAI(api_key=api_key, base_url=url, max_retries=max_retries)
+
                 logger.info(f"  ✓ Selected endpoint: {url} ({endpoint_info.provider_type})")
                 logger.info(f"  ✓ Selected voice: {selected_voice}")
                 logger.info(f"  ✓ Selected model: {selected_model}")
-                
+
                 return client, selected_voice, selected_model, endpoint_info
     
     # No preferred voices found - fall back to any available endpoint
     logger.warning("  No preferred voices available, using any available endpoint...")
     for url in TTS_BASE_URLS:
         endpoint_info = provider_registry.registry["tts"].get(url)
-        if not endpoint_info or not endpoint_info.healthy:
+        if not endpoint_info:
             continue
-        
+
         if endpoint_info.voices:
             selected_voice = endpoint_info.voices[0]
             selected_model = _select_model_for_endpoint(endpoint_info, model)
-            
+
             api_key = OPENAI_API_KEY if endpoint_info.provider_type == "openai" else (OPENAI_API_KEY or "dummy-key-for-local")
-            client = AsyncOpenAI(api_key=api_key, base_url=url)
-            
+            # Disable retries for local endpoints - they either work or don't
+            max_retries = 0 if is_local_provider(url) else 2
+            client = AsyncOpenAI(api_key=api_key, base_url=url, max_retries=max_retries)
+
             logger.info(f"  ✓ Selected endpoint: {url} ({endpoint_info.provider_type})")
             logger.info(f"  ✓ Selected voice: {selected_voice}")
             logger.info(f"  ✓ Selected model: {selected_model}")
-            
+
             return client, selected_voice, selected_model, endpoint_info
-    
+
     # No suitable endpoint found
-    raise ValueError("No healthy TTS endpoints found that support requested voice/model preferences")
+    raise ValueError("No TTS endpoints found that support requested voice/model preferences")
 
 
 async def get_stt_client(
@@ -171,30 +180,36 @@ async def get_stt_client(
     # If specific base_url is requested, use it directly
     if base_url:
         endpoint_info = provider_registry.registry["stt"].get(base_url)
-        if not endpoint_info or not endpoint_info.healthy:
-            raise ValueError(f"Requested base URL {base_url} is not available")
-        
+        if not endpoint_info:
+            raise ValueError(f"Requested base URL {base_url} is not configured")
+
         selected_model = model or "whisper-1"  # Default STT model
-        
+
+        # 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=OPENAI_API_KEY or "dummy-key-for-local",
-            base_url=base_url
+            base_url=base_url,
+            max_retries=max_retries
         )
-        
+
         return client, selected_model, endpoint_info
-    
-    # Get any healthy STT endpoint
-    healthy_endpoints = provider_registry.get_healthy_endpoints("stt")
-    if not healthy_endpoints:
-        raise ValueError("No healthy STT endpoints available")
-    
-    endpoint_info = healthy_endpoints[0]
+
+    # Get STT endpoints in priority order
+    endpoints = provider_registry.get_endpoints("stt")
+    if not endpoints:
+        raise ValueError("No STT endpoints available")
+
+    endpoint_info = endpoints[0]
     selected_model = model or "whisper-1"
     
     api_key = OPENAI_API_KEY if endpoint_info.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(endpoint_info.base_url) else 2
     client = AsyncOpenAI(
         api_key=api_key,
-        base_url=endpoint_info.base_url
+        base_url=endpoint_info.base_url,
+        max_retries=max_retries
     )
     
     return client, selected_model, endpoint_info
@@ -256,8 +271,9 @@ async def is_provider_available(provider_id: str, timeout: float = 2.0) -> bool:
     # Check in appropriate registry
     service_type = "tts" if provider_id in ["kokoro", "openai"] else "stt"
     endpoint_info = provider_registry.registry[service_type].get(base_url)
-    
-    return endpoint_info.healthy if endpoint_info else False
+
+    # Without health checks, we just return if the endpoint is configured
+    return endpoint_info is not None
 
 
 def get_provider_by_voice(voice: str) -> Optional[Dict[str, Any]]: