voice-vibecoder 2.12.2__tar.gz → 2.13.0__tar.gz

{voice_vibecoder-2.12.2 → voice_vibecoder-2.13.0}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 <!-- version list -->
 
+## 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
+
+- Remove duplicate transcript send on text input
+  ([`21bd69b`](https://github.com/snokam/voice-vibecoder/commit/21bd69b61d1b5ceb788110fcb7a847d3e7b74d80))
+
+
 ## v2.12.2 (2026-02-21)
 
 ### Bug Fixes

{voice_vibecoder-2.12.2 → voice_vibecoder-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-vibecoder
-Version: 2.12.2
+Version: 2.13.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.2 → voice_vibecoder-2.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "voice-vibecoder"
-version = "2.12.2"
+version = "2.13.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.2 → voice_vibecoder-2.13.0}/src/voice_vibecoder/__init__.py

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

{voice_vibecoder-2.12.2 → voice_vibecoder-2.13.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.2 → voice_vibecoder-2.13.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.2 → voice_vibecoder-2.13.0}/src/voice_vibecoder/server.py

@@ -40,7 +40,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__)
 
@@ -70,10 +70,7 @@ class WebSocketBridge:
         self._user_jwt = user_jwt
 
     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,
@@ -140,7 +137,7 @@ class WebSocketBridge:
                     # Text-only mode: inject user message directly
                     text = msg.get("text", "") or msg.get("message", "")
                     if text and self._session:
-                        self._send({"type": "transcript", "role": "user", "text": text})
+                        # Transcript sent by session.inject_user_message
                         await self._session.inject_user_message(text)
                 elif msg_type == "sync_state":
                     # Frontend requests full state sync from backend

{voice_vibecoder-2.12.2 → voice_vibecoder-2.13.0}/src/voice_vibecoder/session.py

@@ -30,6 +30,7 @@ from voice_vibecoder.voice_providers import (
     AudioCommitted,
     AudioDelta,
     FunctionCall,
+    GeminiVADSettings,
     ResponseCreated,
     ResponseDone,
     SpeechStarted,
@@ -142,17 +143,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.2 → voice_vibecoder-2.13.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,