voice-vibecoder 2.12.3__tar.gz → 2.14.0__tar.gz

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v2.14.0 (2026-02-21)
+
+
+## v2.13.0 (2026-02-21)
+
+### Features
+
+- Add silence duration and prefix padding options
+  ([`0d7d89c`](https://github.com/snokam/voice-vibecoder/commit/0d7d89cc238cbe396b0fe30a0fbf666118e8faf5))
+
+### Refactoring
+
+- **config**: Store voice and VAD settings per provider
+  ([`fca2e8b`](https://github.com/snokam/voice-vibecoder/commit/fca2e8bf20ee16bc66a29ffb0b0c1544d3c39c35))
+
+
 ## v2.12.3 (2026-02-21)
 
 ### Bug Fixes

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.12.3
+Version: 2.14.0
 Summary: Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code
 Project-URL: Homepage, https://github.com/snokam/voice-vibecoder
 Project-URL: Repository, https://github.com/snokam/voice-vibecoder

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.12.3"
+version = "2.14.0"
 description = "Olaf The Vibecoder — a voice-controlled coding assistant using OpenAI Realtime API + Claude Code"
 readme = "README.md"
 requires-python = ">=3.10"

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/src/voice_vibecoder/__init__.py

@@ -3,7 +3,7 @@
 A voice-controlled coding assistant using OpenAI Realtime API + Claude Code.
 """
 
-__version__ = "2.12.3"
+__version__ = "2.14.0"
 
 from voice_vibecoder.app_config import VoiceConfig
 from voice_vibecoder.ui.screen import VoiceCodingScreen

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/src/voice_vibecoder/cli_serve.py

@@ -35,22 +35,34 @@ def _detect_git_root() -> Path:
 
 def _apply_env_overrides(settings: RealtimeSettings) -> RealtimeSettings:
     """Override settings with VOICE_* environment variables when present."""
-    env_map = {
+    applied = []
+
+    # Top-level overrides
+    simple_map = {
         "VOICE_PROVIDER": "provider",
         "VOICE_API_KEY": "api_key",
-        "VOICE_AZURE_ENDPOINT": "azure_endpoint",
-        "VOICE_AZURE_DEPLOYMENT": "azure_deployment",
         "VOICE_LANGUAGE": "language",
         "VOICE_PERMISSION_MODE": "permission_mode",
     }
-    applied = []
-    for env_var, attr in env_map.items():
+    for env_var, attr in simple_map.items():
         value = os.environ.get(env_var)
         if value:
             setattr(settings, attr, value)
             safe = env_var if "KEY" not in env_var else f"{env_var}=***"
             applied.append(safe)
 
+    # Nested provider overrides
+    nested_map = {
+        "VOICE_AZURE_ENDPOINT": (settings.azure, "endpoint"),
+        "VOICE_AZURE_DEPLOYMENT": (settings.azure, "deployment"),
+        "VOICE_GEMINI_MODEL": (settings.gemini, "model"),
+    }
+    for env_var, (obj, attr) in nested_map.items():
+        value = os.environ.get(env_var)
+        if value:
+            setattr(obj, attr, value)
+            applied.append(env_var)
+
     if applied:
         logger.info("Env overrides applied: %s", ", ".join(applied))
     return settings

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/src/voice_vibecoder/config.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+from dataclasses import dataclass, asdict, field
 from pathlib import Path
 from typing import Literal
 
@@ -228,7 +229,7 @@ def get_system_instructions(
     return base
 
 
-Provider = Literal["openai", "azure"]
+Provider = Literal["openai", "azure", "gemini"]
 
 VOICES = ["ash", "ballad", "coral", "sage", "shimmer", "alloy", "echo", "verse"]
 
@@ -239,6 +240,10 @@ AZURE_DEFAULT_ENDPOINT = ""
 AZURE_DEFAULT_DEPLOYMENT = ""
 AZURE_API_VERSION = "2024-10-01-preview"
 
+GEMINI_WS_URL = "wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent"
+GEMINI_DEFAULT_MODEL = "models/gemini-2.5-flash-native-audio-latest"
+GEMINI_VOICES = ["Kore", "Aoede", "Charon", "Fenrir", "Puck", "Leda", "Orus", "Zephyr"]
+
 # Module-level configurable path — set via configure_paths()
 from voice_vibecoder.app_config import _default_config_dir
 
@@ -259,6 +264,38 @@ def configure_paths(config_dir: Path) -> None:
     SETTINGS_PATH = config_dir / "realtime.json"
 
 
+@dataclass
+class OpenAIConfig:
+    """Per-provider settings for OpenAI."""
+    model: str = OPENAI_DEFAULT_MODEL
+    voice: str = "ash"
+    vad_threshold: float = 0.8
+    silence_duration_ms: int = 700
+    prefix_padding_ms: int = 300
+
+
+@dataclass
+class AzureConfig:
+    """Per-provider settings for Azure OpenAI."""
+    endpoint: str = AZURE_DEFAULT_ENDPOINT
+    deployment: str = AZURE_DEFAULT_DEPLOYMENT
+    voice: str = "ash"
+    vad_threshold: float = 0.8
+    silence_duration_ms: int = 700
+    prefix_padding_ms: int = 300
+
+
+@dataclass
+class GeminiConfig:
+    """Per-provider settings for Gemini."""
+    model: str = GEMINI_DEFAULT_MODEL
+    voice: str = "Puck"
+    start_sensitivity: str = "HIGH"   # "HIGH" or "LOW"
+    end_sensitivity: str = "LOW"      # "HIGH" or "LOW"
+    silence_duration_ms: int = 700
+    prefix_padding_ms: int = 100
+
+
 class RealtimeSettings:
     """Persisted settings for the Realtime voice coding feature."""
 
@@ -266,17 +303,10 @@ class RealtimeSettings:
         self,
         provider: Provider = "openai",
         api_key: str = "",
-        # OpenAI
-        openai_model: str = OPENAI_DEFAULT_MODEL,
-        # Azure
-        azure_endpoint: str = AZURE_DEFAULT_ENDPOINT,
-        azure_deployment: str = AZURE_DEFAULT_DEPLOYMENT,
-        # Voice & session
-        voice: str = "ash",
-        # VAD — higher threshold = less sensitive to background noise
-        vad_threshold: float = 0.8,
-        silence_duration_ms: int = 700,
-        prefix_padding_ms: int = 300,
+        # Per-provider configs
+        openai: OpenAIConfig | None = None,
+        azure: AzureConfig | None = None,
+        gemini: GeminiConfig | None = None,
         # Agent
         agent_timeout: int = 300,
         # Language
@@ -290,33 +320,51 @@ class RealtimeSettings:
     ) -> None:
         self.provider = provider
         self.api_key = api_key
-        self.openai_model = openai_model
-        self.azure_endpoint = azure_endpoint
-        self.azure_deployment = azure_deployment
-        self.voice = voice
-        self.vad_threshold = vad_threshold
-        self.silence_duration_ms = silence_duration_ms
-        self.prefix_padding_ms = prefix_padding_ms
+        self.openai = openai or OpenAIConfig()
+        self.azure = azure or AzureConfig()
+        self.gemini = gemini or GeminiConfig()
         self.agent_timeout = agent_timeout
         self.language = language
         self.permission_mode = permission_mode
         self.input_mode = input_mode
         self.enabled_agents: list[str] = enabled_agents or ["claude"]
 
+    @property
+    def active_voice(self) -> str:
+        """Return the voice setting for the active provider."""
+        if self.provider == "azure":
+            return self.azure.voice
+        if self.provider == "gemini":
+            return self.gemini.voice
+        return self.openai.voice
+
+    @property
+    def active_provider_config(self) -> OpenAIConfig | AzureConfig | GeminiConfig:
+        """Return the config object for the active provider."""
+        if self.provider == "azure":
+            return self.azure
+        if self.provider == "gemini":
+            return self.gemini
+        return self.openai
+
     @property
     def ws_url(self) -> str:
         if self.provider == "azure":
             return (
-                f"wss://{self.azure_endpoint}/openai/realtime"
+                f"wss://{self.azure.endpoint}/openai/realtime"
                 f"?api-version={AZURE_API_VERSION}"
-                f"&deployment={self.azure_deployment}"
+                f"&deployment={self.azure.deployment}"
             )
-        return f"{OPENAI_WS_URL}?model={self.openai_model}"
+        if self.provider == "gemini":
+            return f"{GEMINI_WS_URL}?key={self.api_key}"
+        return f"{OPENAI_WS_URL}?model={self.openai.model}"
 
     @property
     def ws_headers(self) -> dict[str, str]:
         if self.provider == "azure":
             return {"api-key": self.api_key}
+        if self.provider == "gemini":
+            return {}
         return {
             "Authorization": f"Bearer {self.api_key}",
             "OpenAI-Beta": "realtime=v1",
@@ -329,8 +377,10 @@ class RealtimeSettings:
     @property
     def provider_label(self) -> str:
         if self.provider == "azure":
-            return f"Azure ({self.azure_deployment})"
-        return f"OpenAI ({self.openai_model})"
+            return f"Azure ({self.azure.deployment})"
+        if self.provider == "gemini":
+            return f"Gemini ({self.gemini.model})"
+        return f"OpenAI ({self.openai.model})"
 
     def save(self) -> None:
         SETTINGS_PATH.parent.mkdir(parents=True, exist_ok=True)
@@ -340,13 +390,9 @@ class RealtimeSettings:
         return {
             "provider": self.provider,
             "api_key": self.api_key,
-            "openai_model": self.openai_model,
-            "azure_endpoint": self.azure_endpoint,
-            "azure_deployment": self.azure_deployment,
-            "voice": self.voice,
-            "vad_threshold": self.vad_threshold,
-            "silence_duration_ms": self.silence_duration_ms,
-            "prefix_padding_ms": self.prefix_padding_ms,
+            "openai": asdict(self.openai),
+            "azure": asdict(self.azure),
+            "gemini": asdict(self.gemini),
             "agent_timeout": self.agent_timeout,
             "language": self.language,
             "permission_mode": self.permission_mode,
@@ -360,16 +406,15 @@ class RealtimeSettings:
             return cls()
         try:
             data = json.loads(SETTINGS_PATH.read_text())
+            # Migrate flat format → nested format
+            if "openai_model" in data or "vad_threshold" in data:
+                data = cls._migrate_flat(data)
             return cls(
                 provider=data.get("provider", "openai"),
                 api_key=data.get("api_key", ""),
-                openai_model=data.get("openai_model", OPENAI_DEFAULT_MODEL),
-                azure_endpoint=data.get("azure_endpoint", AZURE_DEFAULT_ENDPOINT),
-                azure_deployment=data.get("azure_deployment", AZURE_DEFAULT_DEPLOYMENT),
-                voice=data.get("voice", "ash"),
-                vad_threshold=data.get("vad_threshold", 0.8),
-                silence_duration_ms=data.get("silence_duration_ms", 700),
-                prefix_padding_ms=data.get("prefix_padding_ms", 300),
+                openai=cls._load_openai(data.get("openai", {})),
+                azure=cls._load_azure(data.get("azure", {})),
+                gemini=cls._load_gemini(data.get("gemini", {})),
                 agent_timeout=data.get("agent_timeout", 300),
                 language=data.get("language", "en"),
                 permission_mode=data.get("permission_mode", "bypass"),
@@ -379,6 +424,72 @@ class RealtimeSettings:
         except (json.JSONDecodeError, OSError):
             return cls()
 
+    @staticmethod
+    def _load_openai(d: dict) -> OpenAIConfig:
+        return OpenAIConfig(
+            model=d.get("model", OPENAI_DEFAULT_MODEL),
+            voice=d.get("voice", "ash"),
+            vad_threshold=d.get("vad_threshold", 0.8),
+            silence_duration_ms=d.get("silence_duration_ms", 700),
+            prefix_padding_ms=d.get("prefix_padding_ms", 300),
+        )
+
+    @staticmethod
+    def _load_azure(d: dict) -> AzureConfig:
+        return AzureConfig(
+            endpoint=d.get("endpoint", AZURE_DEFAULT_ENDPOINT),
+            deployment=d.get("deployment", AZURE_DEFAULT_DEPLOYMENT),
+            voice=d.get("voice", "ash"),
+            vad_threshold=d.get("vad_threshold", 0.8),
+            silence_duration_ms=d.get("silence_duration_ms", 700),
+            prefix_padding_ms=d.get("prefix_padding_ms", 300),
+        )
+
+    @staticmethod
+    def _load_gemini(d: dict) -> GeminiConfig:
+        return GeminiConfig(
+            model=d.get("model", GEMINI_DEFAULT_MODEL),
+            voice=d.get("voice", "Puck"),
+            start_sensitivity=d.get("start_sensitivity", "HIGH"),
+            end_sensitivity=d.get("end_sensitivity", "LOW"),
+            silence_duration_ms=d.get("silence_duration_ms", 700),
+            prefix_padding_ms=d.get("prefix_padding_ms", 100),
+        )
+
+    @staticmethod
+    def _migrate_flat(data: dict) -> dict:
+        """Migrate old flat-key format into nested provider dicts."""
+        voice = data.get("voice", "ash")
+        vad_t = data.get("vad_threshold", 0.8)
+        silence = data.get("silence_duration_ms", 700)
+        prefix = data.get("prefix_padding_ms", 300)
+
+        data["openai"] = {
+            "model": data.pop("openai_model", OPENAI_DEFAULT_MODEL),
+            "voice": voice,
+            "vad_threshold": vad_t,
+            "silence_duration_ms": silence,
+            "prefix_padding_ms": prefix,
+        }
+        data["azure"] = {
+            "endpoint": data.pop("azure_endpoint", AZURE_DEFAULT_ENDPOINT),
+            "deployment": data.pop("azure_deployment", AZURE_DEFAULT_DEPLOYMENT),
+            "voice": voice,
+            "vad_threshold": vad_t,
+            "silence_duration_ms": silence,
+            "prefix_padding_ms": prefix,
+        }
+        data["gemini"] = {
+            "model": data.pop("gemini_model", GEMINI_DEFAULT_MODEL),
+            "voice": voice if voice in GEMINI_VOICES else "Puck",
+            "start_sensitivity": "HIGH",
+            "end_sensitivity": "HIGH",
+        }
+        # Remove migrated flat keys
+        for k in ("voice", "vad_threshold", "silence_duration_ms", "prefix_padding_ms"):
+            data.pop(k, None)
+        return data
+
     @staticmethod
     def clear() -> None:
         try:

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/src/voice_vibecoder/server.py

@@ -9,12 +9,14 @@ Protocol (client -> server):
   {"type": "sync_state"}                       — request full state sync from backend
   {"type": "audio", "data": "<base64 PCM16 24kHz>"}
   {"type": "audio.commit"}
+  {"type": "update_settings", "settings": {...}}  — partial settings update, reconnects provider
 
 Protocol (server -> client):
   {"type": "auth_ok"}
   {"type": "audio", "data": "<base64>"}
   {"type": "transcript", "role": "user"|"assistant", "text": "..."}
-  {"type": "status", "status": "ready"|"listening"|"processing"|"responding"}
+  {"type": "status", "status": "ready"|"listening"|"processing"|"responding"|"reconnecting"}
+  {"type": "settings_updated", "settings": {...}}
   {"type": "agent_output", "instanceId": "...", "line": "..."}
   {"type": "instance_status", "instanceId": "...", "status": "...", "branch": "..."}
   {"type": "tool_call", "name": "...", "arguments": {...}}
@@ -29,6 +31,7 @@ import asyncio
 import json
 import logging
 import os
+from dataclasses import asdict, fields
 from pathlib import Path
 from typing import Any
 
@@ -40,7 +43,7 @@ from voice_vibecoder.app_config import VoiceConfig
 from voice_vibecoder.config import RealtimeSettings
 from voice_vibecoder.instances import InstanceStatus
 from voice_vibecoder.session import RealtimeSession
-from voice_vibecoder.voice_providers.openai import OpenAIVoiceProvider
+from voice_vibecoder.voice_providers import create_provider
 
 logger = logging.getLogger(__name__)
 
@@ -49,6 +52,34 @@ logger = logging.getLogger(__name__)
 AUTH_TIMEOUT_SECONDS = 10
 
 
+def _merge_settings(settings: RealtimeSettings, incoming: dict[str, Any]) -> None:
+    """Merge a partial settings dict into an existing RealtimeSettings.
+
+    Top-level scalar keys (provider, language, etc.) are replaced directly.
+    Nested provider dicts (openai, azure, gemini) are merged at the field level
+    so the frontend can send e.g. ``{"gemini": {"model": "..."}}`` without
+    needing to include every field.
+    """
+    from voice_vibecoder.config import OpenAIConfig, AzureConfig, GeminiConfig
+
+    _PROVIDER_ATTRS = {
+        "openai": OpenAIConfig,
+        "azure": AzureConfig,
+        "gemini": GeminiConfig,
+    }
+
+    for key, value in incoming.items():
+        if key in _PROVIDER_ATTRS and isinstance(value, dict):
+            # Merge sub-keys into the existing dataclass
+            cfg = getattr(settings, key)
+            valid_fields = {f.name for f in fields(cfg)}
+            for sub_key, sub_value in value.items():
+                if sub_key in valid_fields:
+                    setattr(cfg, sub_key, sub_value)
+        elif hasattr(settings, key):
+            setattr(settings, key, value)
+
+
 class WebSocketBridge:
     """One bridge per browser connection. Thin adapter between WS frames and RealtimeSession."""
 
@@ -68,12 +99,10 @@ class WebSocketBridge:
         self._voice_config = voice_config
         self._user_email = user_email
         self._user_jwt = user_jwt
+        self._messages_task: asyncio.Task | None = None
 
     async def run(self) -> None:
-        provider = OpenAIVoiceProvider(
-            ws_url=self._settings.ws_url,
-            ws_headers=self._settings.ws_headers,
-        )
+        provider = create_provider(self._settings)
 
         self._session = RealtimeSession(
             provider=provider,
@@ -102,21 +131,17 @@ class WebSocketBridge:
         # Sending it here too would cause duplicate output lines.
         self._send({"type": "status", "status": "ready"})
 
-        receive_task = asyncio.create_task(self._receive_loop())
-        messages_task = asyncio.create_task(self._session.handle_messages())
+        self._messages_task = asyncio.create_task(self._session.handle_messages())
 
         try:
-            done, pending = await asyncio.wait(
-                [receive_task, messages_task],
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-            for task in pending:
-                task.cancel()
+            await self._receive_loop()
+        finally:
+            if self._messages_task:
+                self._messages_task.cancel()
                 try:
-                    await task
+                    await self._messages_task
                 except (asyncio.CancelledError, Exception):
                     pass
-        finally:
             if self._session.connected:
                 await self._session.disconnect()
 
@@ -142,6 +167,8 @@ class WebSocketBridge:
                     if text and self._session:
                         # Transcript sent by session.inject_user_message
                         await self._session.inject_user_message(text)
+                elif msg_type == "update_settings":
+                    await self._handle_settings_update(msg.get("settings", {}))
                 elif msg_type == "sync_state":
                     # Frontend requests full state sync from backend
                     self._send({"type": "status", "status": "syncing"})
@@ -183,6 +210,42 @@ class WebSocketBridge:
                     "line": f"text:{inst.output_buffer}",
                 })
 
+    async def _handle_settings_update(self, incoming: dict[str, Any]) -> None:
+        """Apply a partial settings update, save to disk, and reconnect the provider."""
+        if not incoming:
+            self._send({"type": "error", "message": "Empty settings update"})
+            return
+
+        _merge_settings(self._settings, incoming)
+        self._settings.save()
+        logger.info("Settings updated: %s", list(incoming.keys()))
+
+        if self._session:
+            self._send({"type": "status", "status": "reconnecting"})
+            try:
+                # Stop the current message listener before swapping providers
+                if self._messages_task:
+                    self._messages_task.cancel()
+                    try:
+                        await self._messages_task
+                    except (asyncio.CancelledError, Exception):
+                        pass
+
+                await self._session.update_provider(self._settings)
+
+                # Restart the message listener with the new provider
+                self._messages_task = asyncio.create_task(
+                    self._session.handle_messages()
+                )
+                self._send({"type": "status", "status": "ready"})
+                self._send({
+                    "type": "settings_updated",
+                    "settings": self._settings._to_dict(),
+                })
+            except Exception as e:
+                logger.error("Failed to reconnect after settings update: %s", e, exc_info=True)
+                self._send({"type": "error", "message": f"Reconnect failed: {e}"})
+
     # -- Callbacks (called from RealtimeSession, possibly from background threads) --
 
     def _send(self, msg: dict[str, Any]) -> None:

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/src/voice_vibecoder/session.py

@@ -30,6 +30,7 @@ from voice_vibecoder.voice_providers import (
     AudioCommitted,
     AudioDelta,
     FunctionCall,
+    GeminiVADSettings,
     ResponseCreated,
     ResponseDone,
     SpeechStarted,
@@ -127,6 +128,22 @@ class RealtimeSession:
         if self._on_status:
             self._on_status("connected")
 
+    async def update_provider(self, new_settings: RealtimeSettings) -> None:
+        """Swap the voice provider and reconnect with new settings.
+
+        Preserves the InstanceRegistry, callbacks, and all agent instances.
+        Only the voice provider connection is torn down and recreated.
+        """
+        self._settings = new_settings
+        # Disconnect old provider
+        await self._provider.disconnect()
+        # Create new provider
+        from voice_vibecoder.voice_providers import create_provider
+        self._provider = create_provider(new_settings)
+        # Connect and reconfigure
+        await self._provider.connect()
+        await self.configure_session()
+
     async def configure_session(self) -> None:
         from voice_vibecoder.tools.agent_task import warm_mcp_cache
         from voice_vibecoder.tools.handlers import get_active_instances_text, get_startup_context
@@ -142,17 +159,26 @@ class RealtimeSession:
             active_instances=get_active_instances_text(),
         )
 
-        vad: VADSettings | None = None
+        vad: VADSettings | GeminiVADSettings | None = None
         if s.input_mode != "ptt":
-            vad = VADSettings(
-                threshold=s.vad_threshold,
-                silence_duration_ms=s.silence_duration_ms,
-                prefix_padding_ms=s.prefix_padding_ms,
-            )
+            if s.provider == "gemini":
+                vad = GeminiVADSettings(
+                    start_sensitivity=s.gemini.start_sensitivity,
+                    end_sensitivity=s.gemini.end_sensitivity,
+                    silence_duration_ms=s.gemini.silence_duration_ms,
+                    prefix_padding_ms=s.gemini.prefix_padding_ms,
+                )
+            else:
+                cfg = s.openai if s.provider == "openai" else s.azure
+                vad = VADSettings(
+                    threshold=cfg.vad_threshold,
+                    silence_duration_ms=cfg.silence_duration_ms,
+                    prefix_padding_ms=cfg.prefix_padding_ms,
+                )
 
         await self._provider.configure(
             instructions=instructions,
-            voice=s.voice,
+            voice=s.active_voice,
             tools=get_tool_definitions(),
             vad=vad,
         )

{voice_vibecoder-2.12.3 → voice_vibecoder-2.14.0}/src/voice_vibecoder/ui/screen.py

@@ -174,7 +174,7 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
         self._input_mode = settings.input_mode
 
         self.app.call_from_thread(
-            self._log, f"[dim]{settings.provider_label}  |  voice: {settings.voice}[/dim]"
+            self._log, f"[dim]{settings.provider_label}  |  voice: {settings.active_voice}[/dim]"
         )
         self.app.call_from_thread(self._log, "[dim]Connecting...[/dim]")
         self.app.call_from_thread(self._start_session, settings)
@@ -315,14 +315,10 @@ class VoiceCodingScreen(PanelMixin, CallbackMixin, Screen):
     # -- Session lifecycle --
 
     def _start_session(self, settings) -> None:
-        from voice_vibecoder.voice_providers.openai import OpenAIVoiceProvider
+        from voice_vibecoder.voice_providers import create_provider
         from voice_vibecoder.session import RealtimeSession
 
-        provider = OpenAIVoiceProvider(
-            ws_url=settings.ws_url,
-            ws_headers=settings.ws_headers,
-            transcription_model="gpt-4o-mini-transcribe",
-        )
+        provider = create_provider(settings)
 
         self._session = RealtimeSession(
             provider=provider,