heyhank 0.1.0 → 0.2.0

package/server/voice-pipeline/manager.ts

@@ -0,0 +1,249 @@
+// ─── Voice Engine Manager ────────────────────────────────────────────────────
+// Decides per-call which engine to use (Pipeline vs Gemini Live).
+// Handles caller-ID lookup for personalized greetings.
+// On pipeline failure, falls back to Gemini Live.
+
+import type { TelephonyContact, TranscriptEntry, CallState, TelephonySettings } from "../telephony/call-types.js";
+import type { VoicePipelineSettings, PipelineSessionConfig, LLMToolCall, LLMToolDef, LLMToolResult } from "./types.js";
+import { DEFAULT_VOICE_PIPELINE_SETTINGS } from "./types.js";
+import { findContactByPhone, getOrRenderGreeting, buildGreetingText } from "./greeting-cache.js";
+import { startPipelineSession } from "./pipeline.js";
+
+/** Pipeline-friendly tool definitions (JSON-Schema instead of Gemini's OBJECT/STRING shape) */
+export const PIPELINE_TELEPHONY_TOOLS: LLMToolDef[] = [
+  {
+    name: "end_call",
+    description: "Hang up the phone. CRITICAL RULES: (1) NEVER call this tool proactively. (2) Only call this AFTER you said goodbye AND heard the other person's final response. (3) If you have a script, you MUST complete EVERY step first. (4) There must be a natural pause in the conversation before you use this. (5) When in doubt, do NOT hang up — let the other person hang up instead.",
+    parameters: { type: "object", properties: {} },
+  },
+  {
+    name: "transfer_call",
+    description: "Request to transfer the call to a human or another number. Use when the AI can't handle the request.",
+    parameters: {
+      type: "object",
+      properties: {
+        reason: { type: "string", description: "Why the transfer is needed" },
+      },
+    },
+  },
+];
+
+/**
+ * Public interface — the call-manager creates one of these per call.
+ * Mirrors the AudioBridge surface so call-manager doesn't need big refactors.
+ */
+export interface VoiceEngineSession {
+  /** Connect/start the engine (idempotent) */
+  connect(): Promise<void>;
+  /** Push caller audio (PCM 8kHz from FreeSWITCH) */
+  sendCallerAudio(pcm: Buffer | Uint8Array): void;
+  /** Tear down */
+  disconnect(): void;
+  /** Engine identifier (for transcript label / debug) */
+  readonly engineLabel: string;
+  /** When connected, send pre-rendered greeting immediately (Pipeline only) */
+  playGreetingIfReady?(): void;
+  /** Audio out callback — call-manager sets this to forward PCM to FreeSWITCH */
+  onAudio: (pcm8k: Uint8Array) => void;
+  /** Turn-complete callback (Gemini parity) */
+  onTurnComplete?: () => void;
+  readonly isReady: boolean;
+}
+
+/**
+ * Build the system prompt for an inbound call from an unknown caller.
+ * Adds an instruction to ask for the name if the caller doesn't introduce themselves.
+ */
+function augmentInboundPromptForUnknownCaller(basePrompt: string): string {
+  return basePrompt + `
+
+ZUSÄTZLICHE ANWEISUNG (unbekannte Nummer):
+Falls der Anrufer seinen Namen nicht von selbst nennt, frag höflich nach: "Mit wem spreche ich denn?"`;
+}
+
+/**
+ * When a pre-rendered greeting is played server-side on call answer, the LLM
+ * doesn't realise it has already greeted. Combined with prompt phrasing like
+ * "Answer warmly" or "DEFAULT INBOUND CALL FLOW: 1. Answer warmly...", the LLM
+ * tends to greet again on its first turn — caller hears the welcome twice.
+ * This appendix tells the LLM exactly what was already said and to skip step 1.
+ */
+function augmentPromptForPreRenderedGreeting(basePrompt: string, greetingText: string): string {
+  if (!greetingText) return basePrompt;
+  return basePrompt + `
+
+WICHTIG — BEGRÜSSUNG WURDE BEREITS GESPROCHEN:
+Du hast soeben folgende Begrüssung gesagt (sie wurde bereits abgespielt, der Anrufer hat sie gehört):
+"${greetingText}"
+Wiederhole sie NICHT. Begrüsse den Anrufer nicht erneut. Reagiere stattdessen direkt und natürlich auf das, was der Anrufer als Nächstes sagt. Überspringe Schritt 1 ("Answer warmly" / "Greet the person") im Standard-Call-Flow — der ist bereits erledigt.`;
+}
+
+interface CreateEngineParams {
+  callId: string;
+  direction: "inbound" | "outbound";
+  /** Remote phone number — for outbound, the number we're calling; for inbound, the caller's number */
+  remoteNumber: string;
+  /** Outbound: known contact; Inbound: looked up from caller-ID */
+  contact: TelephonyContact | null;
+  /** System prompt (script for outbound, inbound prompt for inbound) */
+  systemPrompt: string;
+  /** Settings to consult */
+  telephonySettings: TelephonySettings;
+  pipelineSettings: VoicePipelineSettings;
+  /** LLM tool definitions the pipeline may invoke (default: PIPELINE_TELEPHONY_TOOLS) */
+  tools?: LLMToolDef[];
+  /** Tool-call handler — typically call-manager.handleToolCalls(callId, …) */
+  onToolCall?: (calls: LLMToolCall[]) => Promise<LLMToolResult[]>;
+  /** Callbacks (proxied through to engine) */
+  onTranscript: (entry: TranscriptEntry) => void;
+  onStatusChange: (status: CallState["status"]) => void;
+}
+
+/**
+ * Resolve which engine to use for this call.
+ * Returns "pipeline" or "gemini-live".
+ */
+export function resolveEngine(pipelineSettings: VoicePipelineSettings): "pipeline" | "gemini-live" {
+  if (!pipelineSettings.enabled) return "gemini-live";
+  return pipelineSettings.engine;
+}
+
+/**
+ * Look up contact by phone number for inbound calls.
+ * For outbound calls, the contact is already known from the UI selection.
+ */
+export function lookupContactForCall(
+  direction: "inbound" | "outbound",
+  remoteNumber: string,
+  knownContact: TelephonyContact | null,
+  contacts: TelephonyContact[],
+  defaultCountryCode: string = "",
+): TelephonyContact | null {
+  if (knownContact) return knownContact;
+  if (direction === "inbound") {
+    return findContactByPhone(contacts, remoteNumber, defaultCountryCode);
+  }
+  return null;
+}
+
+/**
+ * Pre-render the greeting for an upcoming call.
+ * For OUTBOUND: render immediately so it's ready by the time the call connects.
+ * For INBOUND: should already be cached (rendered on contact create/settings change).
+ */
+export async function prepareGreeting(params: {
+  direction: "inbound" | "outbound";
+  contact: TelephonyContact | null;
+  pipelineSettings: VoicePipelineSettings;
+}): Promise<{ text: string; pcm: Uint8Array | null }> {
+  if (!params.pipelineSettings.enabled) return { text: "", pcm: null };
+  try {
+    const r = await getOrRenderGreeting({
+      direction: params.direction,
+      contact: params.contact,
+      settings: params.pipelineSettings,
+    });
+    return { text: r.text, pcm: r.pcm };
+  } catch (e) {
+    console.error("[voice-pipeline] greeting prep failed:", e);
+    return { text: buildGreetingText(params.direction, params.contact), pcm: null };
+  }
+}
+
+/**
+ * Create a Pipeline-engine voice session for a call.
+ * Throws on init failure → caller should catch and fall back to Gemini Live.
+ */
+export async function createPipelineEngine(params: CreateEngineParams & {
+  greetingText: string;
+  greetingPcm: Uint8Array | null;
+}): Promise<VoiceEngineSession> {
+  // Augment inbound prompt for unknown callers
+  let finalPrompt = (params.direction === "inbound" && !params.contact)
+    ? augmentInboundPromptForUnknownCaller(params.systemPrompt)
+    : params.systemPrompt;
+  // If we have a pre-rendered greeting, tell the LLM it was already played
+  // so the LLM doesn't greet again on its first turn (caller would hear it twice).
+  if (params.greetingPcm && params.greetingText) {
+    finalPrompt = augmentPromptForPreRenderedGreeting(finalPrompt, params.greetingText);
+  }
+
+  // Wire callbacks: onAudio (patched by caller) + onTurnComplete (patched by call-manager)
+  let onAudioCallback: (pcm: Uint8Array) => void = () => {};
+  let onTurnCompleteCallback: (() => void) | undefined;
+
+  const sessionConfig: PipelineSessionConfig = {
+    callId: params.callId,
+    direction: params.direction,
+    contact: params.contact ? { id: params.contact.id, name: params.contact.name, phone: params.contact.phone } : null,
+    remoteNumber: params.remoteNumber,
+    systemPrompt: finalPrompt,
+    greetingPcm: params.greetingPcm,
+    tools: params.tools ?? PIPELINE_TELEPHONY_TOOLS,
+    settings: params.pipelineSettings,
+    onTranscript: params.onTranscript,
+    onStatusChange: params.onStatusChange,
+    onAudioOut: (pcm) => onAudioCallback(pcm),
+    onToolCall: params.onToolCall,
+    onTurnComplete: () => onTurnCompleteCallback?.(),
+  };
+
+  const session = await startPipelineSession(sessionConfig);
+
+  const wrapper: VoiceEngineSession = {
+    engineLabel: "Pipeline (Google STT/TTS)",
+    onAudio: () => {},
+    async connect() {
+      // Pipeline starts on construction — no extra connect step needed
+    },
+    sendCallerAudio(pcm) {
+      session.pushAudio(pcm);
+    },
+    playGreetingIfReady() {
+      if (params.greetingPcm) {
+        // The PipelineSessionImpl exposes a .sendGreetingNow() method
+        (session as unknown as { sendGreetingNow: (txt: string) => void }).sendGreetingNow(params.greetingText);
+      }
+    },
+    disconnect() {
+      session.close().catch(() => {});
+    },
+    get isReady() {
+      return session.isReady;
+    },
+  };
+
+  // Wire the audio callback to whoever sets wrapper.onAudio
+  Object.defineProperty(wrapper, "onAudio", {
+    get() { return onAudioCallback; },
+    set(fn: (pcm: Uint8Array) => void) { onAudioCallback = fn; },
+  });
+  // Wire onTurnComplete getter/setter (so call-manager's pendingHangup logic works)
+  Object.defineProperty(wrapper, "onTurnComplete", {
+    get() { return onTurnCompleteCallback; },
+    set(fn: () => void) { onTurnCompleteCallback = fn; },
+  });
+
+  return wrapper;
+}
+
+// ─── Pipeline settings persistence ───────────────────────────────────────────
+// Stored alongside telephony settings as a sub-object: settings.voicePipeline
+
+export function getPipelineSettingsFrom(telephonySettings: TelephonySettings): VoicePipelineSettings {
+  const fromSettings = (telephonySettings as TelephonySettings & { voicePipeline?: VoicePipelineSettings }).voicePipeline;
+  if (!fromSettings) return { ...DEFAULT_VOICE_PIPELINE_SETTINGS };
+  const merged: VoicePipelineSettings = {
+    ...DEFAULT_VOICE_PIPELINE_SETTINGS,
+    ...fromSettings,
+    stt: { ...DEFAULT_VOICE_PIPELINE_SETTINGS.stt, ...(fromSettings.stt || {}) },
+    tts: { ...DEFAULT_VOICE_PIPELINE_SETTINGS.tts, ...(fromSettings.tts || {}) },
+    llm: { ...DEFAULT_VOICE_PIPELINE_SETTINGS.llm, ...(fromSettings.llm || {}) },
+  };
+  // Migrate legacy "auto" value → the new default (groq). "auto" was removed
+  // in favor of explicit per-pipeline selection.
+  if ((merged.llm.provider as string) === "auto") {
+    merged.llm.provider = DEFAULT_VOICE_PIPELINE_SETTINGS.llm.provider;
+  }
+  return merged;
+}

package/server/voice-pipeline/pipeline.ts

@@ -0,0 +1,335 @@
+// ─── Voice Pipeline Orchestrator ────────────────────────────────────────────
+// Connects STT → LLM → TTS for a single call.
+//
+// Flow:
+//  1. Caller audio (8kHz LINEAR16) → STT.pushAudio()
+//  2. STT emits final transcript → LLM.generateStream()
+//  3. LLM tokens accumulated until sentence boundary → TTS.synthesize()
+//  4. TTS PCM 8kHz → onAudioOut()
+//
+// Turn-taking:
+//  - Whenever caller speaks (interim STT result), we cancel any in-flight LLM/TTS (barge-in).
+//  - Final transcript triggers a new LLM turn.
+
+import type {
+  LLMMessage,
+  PipelineSession,
+  PipelineSessionConfig,
+  STTResult,
+  STTSession,
+  TTSConfig,
+} from "./types.js";
+import { getLLMProvider, getSTTProvider, getTTSProvider } from "./providers/index.js";
+
+/**
+ * Remove tool-call markup that some LLMs leak into the text stream instead
+ * of emitting through the provider's structured tool-call channel. Common
+ * patterns: `<function=name>{...}</function>`, `<tool_call>...</tool_call>`,
+ * `<|python_tag|>...`, and bare `<function=name/>` self-closing tags.
+ * Without this, goodbye lines like
+ *   "Schönen Tag noch! <function=end_call></function>"
+ * get TTS'd literally by the German voice.
+ */
+function sanitizeForTts(text: string): string {
+  return text
+    .replace(/<function\b[^>]*>[\s\S]*?<\/function>/gi, "")
+    .replace(/<function\b[^>]*\/>/gi, "")
+    .replace(/<tool_call\b[^>]*>[\s\S]*?<\/tool_call>/gi, "")
+    .replace(/<\|python_tag\|>[\s\S]*$/g, "")
+    .replace(/<\|?[a-z_]+\|?>/gi, "")
+    .replace(/\s{2,}/g, " ")
+    .trim();
+}
+
+/** Split text into sentence-like chunks for incremental TTS playback */
+function* splitSentences(buffer: string): Generator<{ sentence: string; rest: string }> {
+  // Split on sentence-ending punctuation followed by space or end
+  const re = /([^.!?…]+[.!?…]+)(\s+|$)/g;
+  let match;
+  let lastIdx = 0;
+  while ((match = re.exec(buffer)) !== null) {
+    yield { sentence: match[1].trim(), rest: "" };
+    lastIdx = match.index + match[0].length;
+  }
+  // Return any unfinished tail as `rest`
+  if (lastIdx < buffer.length) {
+    yield { sentence: "", rest: buffer.slice(lastIdx) };
+  } else {
+    yield { sentence: "", rest: "" };
+  }
+}
+
+class PipelineSessionImpl implements PipelineSession {
+  private stt: STTSession | null = null;
+  private history: LLMMessage[] = [];
+  private closed = false;
+  private ready = false;
+  /** Counter to invalidate in-flight LLM/TTS when user starts talking */
+  private currentTurnId = 0;
+  /** Initial greeting PCM (set in constructor for instant playback) */
+  private greetingPcm: Uint8Array | null = null;
+  /** Whether we've already sent the greeting */
+  private greetingSent = false;
+  /** Buffer for accumulating LLM tokens until sentence boundary */
+  private llmBuffer = "";
+
+  constructor(private config: PipelineSessionConfig) {
+    this.greetingPcm = config.greetingPcm ?? null;
+    // Seed history with the system prompt
+    this.history.push({ role: "system", content: config.systemPrompt });
+    // If we have a greeting, prime the assistant's first turn so the LLM knows
+    // what was already said and continues naturally.
+    // We'll add the greeting to history when sendGreeting() runs.
+  }
+
+  async start(): Promise<void> {
+    // Start STT stream
+    const sttProvider = getSTTProvider(this.config.settings.stt.provider);
+    this.stt = await sttProvider.start({
+      language: this.config.settings.stt.language,
+      sampleRateHertz: 8000,
+      interimResults: true,
+    });
+
+    this.stt.onResult((r) => this.handleSTTResult(r));
+    this.stt.onError((err) => {
+      console.error(`[voice-pipeline] STT error on call ${this.config.callId}:`, err.message);
+    });
+
+    this.ready = true;
+    this.config.onStatusChange("active");
+    this.config.onTranscript({
+      speaker: "system",
+      text: `Pipeline engine connected (Google STT/TTS, ${this.config.settings.llm.provider} LLM)`,
+      isFinal: true,
+      ts: Date.now(),
+    });
+  }
+
+  /** Send pre-rendered greeting immediately on call answer */
+  sendGreetingNow(greetingText: string): void {
+    if (this.greetingSent || !this.greetingPcm) return;
+    this.greetingSent = true;
+
+    // Stream PCM to FreeSWITCH
+    this.config.onAudioOut(this.greetingPcm);
+
+    // Add greeting to history + transcript
+    this.history.push({ role: "assistant", content: greetingText });
+    this.config.onTranscript({
+      speaker: "ai",
+      text: greetingText,
+      isFinal: true,
+      ts: Date.now(),
+    });
+  }
+
+  pushAudio(pcm: Buffer | Uint8Array): void {
+    if (this.closed || !this.stt) return;
+    this.stt.pushAudio(pcm);
+  }
+
+  async sendText(text: string, role: "user" | "system" = "user"): Promise<void> {
+    this.history.push({ role, content: text });
+    if (role === "user") {
+      await this.runLLMTurn();
+    }
+  }
+
+  getGreetingPcm(): Uint8Array | null {
+    return this.greetingPcm;
+  }
+
+  private handleSTTResult(r: STTResult): void {
+    if (this.closed) return;
+
+    // Interim result → barge-in: cancel any in-flight LLM/TTS
+    if (!r.isFinal) {
+      // Increment turnId so any in-flight TTS becomes stale
+      this.currentTurnId++;
+      // Optionally emit interim transcript (for live UI)
+      if (r.text.trim()) {
+        this.config.onTranscript({
+          speaker: "callee",
+          text: r.text.trim(),
+          isFinal: false,
+          ts: Date.now(),
+        });
+      }
+      return;
+    }
+
+    // Final transcript → add to history + run LLM turn
+    const trimmed = r.text.trim();
+    if (!trimmed) return;
+    this.config.onTranscript({
+      speaker: "callee",
+      text: trimmed,
+      isFinal: true,
+      ts: Date.now(),
+    });
+    this.history.push({ role: "user", content: trimmed });
+    const tSttFinal = Date.now();
+    console.log(`[voice-pipeline][timing] call=${this.config.callId} STT_FINAL t=${tSttFinal} text="${trimmed.slice(0, 80)}"`);
+    this.runLLMTurn(tSttFinal).catch((e) => {
+      console.error(`[voice-pipeline] LLM turn error:`, e);
+    });
+  }
+
+  private async runLLMTurn(tSttFinal: number = Date.now()): Promise<void> {
+    const myTurnId = ++this.currentTurnId;
+    const llm = getLLMProvider(this.config.settings.llm.provider);
+    const ttsProvider = getTTSProvider(this.config.settings.tts.provider);
+    const callId = this.config.callId;
+    const tLlmStart = Date.now();
+
+    // Reset buffer for this turn
+    this.llmBuffer = "";
+    let assistantText = "";
+    let firstChunkLogged = false;
+    let firstTtsLogged = false;
+    /** Track in-flight TTS promises so we can await them before signalling turn-complete */
+    const ttsInflight: Promise<void>[] = [];
+
+    const ttsConfig: TTSConfig = {
+      voice: this.config.settings.tts.voice,
+      language: this.config.settings.stt.language,
+      format: "PCM_8000",
+      speakingRate: this.config.settings.tts.speakingRate,
+    };
+
+    /** Synthesize a sentence and pipe to FreeSWITCH (if turn still active) */
+    const speakSentence = async (sentence: string): Promise<void> => {
+      const cleaned = sanitizeForTts(sentence);
+      if (!cleaned.trim()) return;
+      if (myTurnId !== this.currentTurnId) return; // barge-in cancelled this turn
+      const tTtsStart = Date.now();
+      try {
+        // Phonetic fix: German TTS says "Hank" with a long A ("Haank").
+        // Spelling it "Henk" yields the English short-A pronunciation.
+        const ttsText = cleaned.replace(/\bHank\b/g, "Henk");
+        const result = await ttsProvider.synthesize(ttsText, ttsConfig);
+        if (myTurnId !== this.currentTurnId) return; // double-check after await
+        const tTtsDone = Date.now();
+        if (!firstTtsLogged) {
+          firstTtsLogged = true;
+          console.log(`[voice-pipeline][timing] call=${callId} FIRST_TTS_AUDIO t=${tTtsDone} dSinceSttFinal=${tTtsDone - tSttFinal}ms dSinceLlmStart=${tTtsDone - tLlmStart}ms synthMs=${tTtsDone - tTtsStart} len=${sentence.length}`);
+        }
+        this.config.onAudioOut(result.audio);
+      } catch (e) {
+        console.error(`[voice-pipeline] TTS error:`, e);
+      }
+    };
+
+    const enqueueTts = (sentence: string): void => {
+      const p = speakSentence(sentence);
+      ttsInflight.push(p);
+    };
+
+    const onChunk = (chunk: string): void => {
+      if (!firstChunkLogged) {
+        firstChunkLogged = true;
+        const now = Date.now();
+        console.log(`[voice-pipeline][timing] call=${callId} LLM_FIRST_TOKEN t=${now} dSinceSttFinal=${now - tSttFinal}ms dSinceLlmStart=${now - tLlmStart}ms`);
+      }
+      assistantText += chunk;
+      this.llmBuffer += chunk;
+      // Try to extract a complete sentence and speak it immediately (low latency)
+      let sentence = "";
+      let rest = this.llmBuffer;
+      for (const part of splitSentences(this.llmBuffer)) {
+        if (part.sentence) {
+          sentence = part.sentence;
+          rest = part.rest;
+          break;
+        }
+      }
+      if (sentence) {
+        this.llmBuffer = rest;
+        enqueueTts(sentence);
+      }
+    };
+
+    /** Forward LLM tool calls to the call-manager handler */
+    const onToolCalls = this.config.onToolCall
+      ? async (calls: import("./types.js").LLMToolCall[]) => {
+          if (myTurnId !== this.currentTurnId) return [];
+          this.config.onTranscript({
+            speaker: "system",
+            text: `Tool calls: ${calls.map((c) => c.name).join(", ")}`,
+            isFinal: true,
+            ts: Date.now(),
+          });
+          return await this.config.onToolCall!(calls);
+        }
+      : undefined;
+
+    const result = llm.generateStream
+      ? await llm.generateStream(
+          this.history,
+          { onChunk, onToolCalls },
+          { ...this.config.settings.llm, tools: this.config.tools },
+        )
+      : await llm.generate(this.history, { ...this.config.settings.llm, tools: this.config.tools });
+
+    if (!result.ok) {
+      console.error(`[voice-pipeline] LLM error: ${result.error}`);
+      return;
+    }
+
+    // Speak any leftover buffer (last sentence without trailing punctuation)
+    if (this.llmBuffer.trim()) {
+      enqueueTts(this.llmBuffer.trim());
+      this.llmBuffer = "";
+    }
+
+    // Wait for all TTS to finish dispatching (so onTurnComplete fires after audio is sent)
+    await Promise.allSettled(ttsInflight);
+    const tTurnDone = Date.now();
+    console.log(`[voice-pipeline][timing] call=${callId} TURN_COMPLETE t=${tTurnDone} totalFromSttFinal=${tTurnDone - tSttFinal}ms llmMs=${tTurnDone - tLlmStart}ms replyLen=${assistantText.length}`);
+
+    // Save assistant turn to history (strip any leaked tool-call markup)
+    const cleanedAssistant = sanitizeForTts(assistantText).trim();
+    if (myTurnId === this.currentTurnId && cleanedAssistant) {
+      this.history.push({ role: "assistant", content: cleanedAssistant });
+      this.config.onTranscript({
+        speaker: "ai",
+        text: cleanedAssistant,
+        isFinal: true,
+        ts: Date.now(),
+      });
+    }
+
+    // Signal turn-complete (used by call-manager's pendingHangup logic)
+    if (myTurnId === this.currentTurnId) {
+      try { this.config.onTurnComplete?.(); } catch { /* ignore */ }
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.closed) return;
+    this.closed = true;
+    this.ready = false;
+    if (this.stt) {
+      try { await this.stt.close(); } catch { /* ignore */ }
+      this.stt = null;
+    }
+    this.config.onStatusChange("ended");
+  }
+
+  get isReady(): boolean {
+    return this.ready && !this.closed;
+  }
+}
+
+/**
+ * Create + start a new pipeline session.
+ * Returns the session and (if greeting available) the greeting text/pcm.
+ */
+export async function startPipelineSession(
+  config: PipelineSessionConfig,
+): Promise<PipelineSessionImpl> {
+  const session = new PipelineSessionImpl(config);
+  await session.start();
+  return session;
+}

package/server/voice-pipeline/providers/index.ts

@@ -0,0 +1,47 @@
+// ─── Provider Registry ───────────────────────────────────────────────────────
+
+import type {
+  LLMProvider,
+  LLMProviderId,
+  STTProvider,
+  STTProviderId,
+  TTSProvider,
+  TTSProviderId,
+} from "../types.js";
+import { GoogleSTTProvider } from "./stt-google.js";
+import { GoogleTTSProvider } from "./tts-google.js";
+import { InternalLLMProvider } from "./llm-internal.js";
+
+const sttRegistry = new Map<STTProviderId, STTProvider>();
+const ttsRegistry = new Map<TTSProviderId, TTSProvider>();
+/** Keyed by LLMProviderId — each instance is pre-configured with its preferred provider */
+const llmRegistry = new Map<LLMProviderId, LLMProvider>();
+
+// Lazy-init providers (so missing creds don't break import)
+function ensureRegistered(): void {
+  if (!sttRegistry.has("google")) sttRegistry.set("google", new GoogleSTTProvider());
+  if (!ttsRegistry.has("google")) ttsRegistry.set("google", new GoogleTTSProvider());
+}
+
+export function getSTTProvider(id: STTProviderId): STTProvider {
+  ensureRegistered();
+  const p = sttRegistry.get(id);
+  if (!p) throw new Error(`STT provider not available: ${id}`);
+  return p;
+}
+
+export function getTTSProvider(id: TTSProviderId): TTSProvider {
+  ensureRegistered();
+  const p = ttsRegistry.get(id);
+  if (!p) throw new Error(`TTS provider not available: ${id}`);
+  return p;
+}
+
+export function getLLMProvider(id: LLMProviderId): LLMProvider {
+  let p = llmRegistry.get(id);
+  if (!p) {
+    p = new InternalLLMProvider(id);
+    llmRegistry.set(id, p);
+  }
+  return p;
+}