@absolutejs/voice 0.0.22-beta.305 → 0.0.22-beta.307

package/README.md

@@ -3471,15 +3471,16 @@ app.use(
 
 Client state now exposes `assistantAudio` on the stream/controller helpers, so apps can buffer or play synthesized chunks without inventing a second transport.
 
-## OpenAI Realtime
+## Realtime Adapter Packages
 
-Use `createOpenAIRealtimeAdapter(...)` when you want a direct OpenAI Realtime speech-to-speech output path for live smoke tests, duplex benchmarks, or custom realtime orchestration. It implements the same `RealtimeAdapter` contract used by the benchmark harness, so the provider can stream `response.output_audio.delta` audio chunks into AbsoluteJS voice events while still emitting normalized transcript, error, and close events.
+Use realtime adapter packages when you want direct speech-to-speech output paths for live smoke tests, duplex benchmarks, or custom realtime orchestration. Core owns the `RealtimeAdapter` contract and `voice({ realtime })` orchestration path; provider protocol code lives in adapter packages such as `@absolutejs/voice-openai` and `@absolutejs/voice-gemini`.
 
 ```ts
-import { createOpenAIRealtimeAdapter } from '@absolutejs/voice';
+import { voice } from '@absolutejs/voice';
+import { openai } from '@absolutejs/voice-openai';
 import { runTTSAdapterFixture } from '@absolutejs/voice/testing';
 
-const realtime = createOpenAIRealtimeAdapter({
+const realtime = openai({
 	apiKey: process.env.OPENAI_API_KEY!,
 	instructions: 'Answer in one concise sentence.',
 	model: 'gpt-realtime',
@@ -3522,7 +3523,33 @@ const report = await runTTSAdapterFixture(
 );
 ```
 
-For server-to-server use, the adapter opens a WebSocket to OpenAI, sends `session.update`, streams text or base64 PCM input, and emits raw 24kHz mono `pcm_s16le` assistant audio. It requires raw 24kHz mono PCM input because that is the OpenAI Realtime PCM format. The main `voice(...)` route can now run in cascaded mode with `stt` plus optional `tts`, or direct realtime mode with `realtime`. Browser demos should make sure the captured PCM format matches `realtimeInputFormat` or resample before sending audio.
+For server-to-server use, realtime adapters open provider-specific streaming connections, send session configuration, stream text or PCM input, and emit normalized transcript/audio/error/close events. OpenAI Realtime uses raw 24kHz mono `pcm_s16le` audio. The main `voice(...)` route can run in cascaded mode with `stt` plus optional `tts`, or direct realtime mode with `realtime`. Browser demos should make sure the captured PCM format matches `realtimeInputFormat` or resample before sending audio.
+
+Use `createVoiceRealtimeProviderContractMatrixPreset(...)` to prove which realtime providers are production-ready. Pipecat is represented as an explicit bridge seam by default, not core-owned media infrastructure:
+
+```ts
+import {
+	createVoiceRealtimeProviderContractMatrixPreset,
+	createVoiceRealtimeProviderContractRoutes
+} from '@absolutejs/voice';
+
+app.use(
+	createVoiceRealtimeProviderContractRoutes({
+		matrix: createVoiceRealtimeProviderContractMatrixPreset({
+			env: process.env,
+			fallbackProviders: {
+				'gemini-live': ['openai-realtime'],
+				'openai-realtime': ['gemini-live']
+			},
+			latencyBudgets: {
+				'gemini-live': 900,
+				'openai-realtime': 800
+			},
+			selected: 'openai-realtime'
+		})
+	})
+);
+```
 
 If you want a minimal browser playback path, use the client audio player:
 

package/dist/index.d.ts

@@ -12,8 +12,8 @@ export { createVoiceBargeInRoutes, renderVoiceBargeInHTML, summarizeVoiceBargeIn
 export { createVoiceReconnectContractRoutes, renderVoiceReconnectContractHTML, summarizeVoiceReconnectContractSnapshots, runVoiceReconnectContract } from './reconnectContract';
 export { assertVoiceRealtimeChannelEvidence, buildVoiceRealtimeChannelRuntimeSamplesFromTrace, buildVoiceRealtimeChannelReport, createVoiceRealtimeChannelRoutes, evaluateVoiceRealtimeChannelEvidence, renderVoiceRealtimeChannelHTML, renderVoiceRealtimeChannelMarkdown } from './realtimeChannel';
 export type { VoiceRealtimeChannelAssertionInput, VoiceRealtimeChannelAssertionReport, VoiceRealtimeChannelBrowserCapture, VoiceRealtimeChannelIssue, VoiceRealtimeChannelReport, VoiceRealtimeChannelReportOptions, VoiceRealtimeChannelRoutesOptions, VoiceRealtimeChannelRuntimeSample, VoiceRealtimeChannelStatus } from './realtimeChannel';
-export { assertVoiceRealtimeProviderContractEvidence, buildVoiceRealtimeProviderContractMatrix, createVoiceRealtimeProviderContractRoutes, evaluateVoiceRealtimeProviderContractEvidence, renderVoiceRealtimeProviderContractHTML } from './realtimeProviderContracts';
-export type { VoiceRealtimeProviderContractAssertionInput, VoiceRealtimeProviderContractAssertionReport, VoiceRealtimeProviderContractCapability, VoiceRealtimeProviderContractCheck, VoiceRealtimeProviderContractDefinition, VoiceRealtimeProviderContractMatrixInput, VoiceRealtimeProviderContractMatrixReport, VoiceRealtimeProviderContractRoutesOptions, VoiceRealtimeProviderContractRow, VoiceRealtimeProviderContractStatus } from './realtimeProviderContracts';
+export { assertVoiceRealtimeProviderContractEvidence, buildVoiceRealtimeProviderContractMatrix, createVoiceRealtimeProviderContractMatrixPreset, createVoiceRealtimeProviderContractRoutes, evaluateVoiceRealtimeProviderContractEvidence, renderVoiceRealtimeProviderContractHTML } from './realtimeProviderContracts';
+export type { VoiceRealtimeProviderContractAssertionInput, VoiceRealtimeProviderContractAssertionReport, VoiceRealtimeProviderContractCapability, VoiceRealtimeProviderContractCheck, VoiceRealtimeProviderContractDefinition, VoiceRealtimeProviderContractMatrixPresetOptions, VoiceRealtimeProviderContractMatrixInput, VoiceRealtimeProviderContractMatrixReport, VoiceRealtimeProviderContractRoutesOptions, VoiceRealtimeProviderContractRow, VoiceRealtimeProviderPresetProvider, VoiceRealtimeProviderContractStatus } from './realtimeProviderContracts';
 export { buildVoiceDiagnosticsMarkdown, createVoiceDiagnosticsRoutes, resolveVoiceDiagnosticsTraceFilter } from './diagnosticsRoutes';
 export { buildVoiceDemoReadyReport, createVoiceDemoReadyRoutes, renderVoiceDemoReadyHTML } from './demoReadyRoutes';
 export { buildVoiceDeliverySinkReport, createVoiceDeliverySinkDescriptor, createVoiceDeliverySinkPair, createVoiceDeliverySinkRoutes, createVoiceFileDeliverySink, createVoicePostgresDeliverySink, createVoiceS3DeliverySink, createVoiceSQLiteDeliverySink, createVoiceWebhookDeliverySink, renderVoiceDeliverySinkHTML } from './deliverySinkRoutes';
@@ -55,7 +55,6 @@ export { assertVoicePhoneCallControlEvidence, assertVoicePhoneAssistantEvidence,
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileIncidentBundleStore, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileAuditEventStore, createVoiceFileAuditSinkDeliveryStore, createVoiceFileCampaignStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, createVoiceProviderOrchestrationProfile, resolveVoiceProviderRoutingPolicyPreset, createVoiceProviderRouter } from './modelAdapters';
-export { createOpenAIRealtimeAdapter } from './openaiRealtime';
 export { createOpenAIVoiceTTS } from './openaiTTS';
 export { createVoiceProviderHealthHTMLHandler, createVoiceProviderHealthJSONHandler, createVoiceProviderHealthRoutes, renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth } from './providerHealth';
 export { createVoiceProviderCapabilityHTMLHandler, createVoiceProviderCapabilityJSONHandler, createVoiceProviderCapabilityRoutes, renderVoiceProviderCapabilityHTML, summarizeVoiceProviderCapabilities } from './providerCapabilities';
@@ -117,7 +116,6 @@ export type { VoiceWorkflowContract, VoiceWorkflowContractDefinition, VoiceWorkf
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceProviderFallbackRecoverySummary, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn } from './sessionReplay';
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderOrchestrationProfile, VoiceProviderOrchestrationProfileOptions, VoiceProviderOrchestrationResolvedSurface, VoiceProviderOrchestrationSurface, VoiceProviderRouterPolicy, VoiceProviderRouterPolicyPreset, VoiceProviderRouterPolicyWeights, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceProviderRouterStrategy, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
 export type { OpenAIVoiceTTSOptions, OpenAIVoiceTTSVoice } from './openaiTTS';
-export type { OpenAIRealtimeAdapterOptions, OpenAIRealtimeModel, OpenAIRealtimeNoiseReduction, OpenAIRealtimeResponseMode, OpenAIRealtimeTranscriptionModel, OpenAIRealtimeVoice } from './openaiRealtime';
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
 export type { VoiceProviderCapabilityDefinition, VoiceProviderCapabilityHandlerOptions, VoiceProviderCapabilityHTMLHandlerOptions, VoiceProviderCapabilityKind, VoiceProviderCapabilityOptions, VoiceProviderCapabilityReport, VoiceProviderCapabilityRoutesOptions, VoiceProviderCapabilitySummary } from './providerCapabilities';
 export type { VoiceProviderOrchestrationIssue, VoiceProviderOrchestrationReport, VoiceProviderOrchestrationReportOptions, VoiceProviderOrchestrationRequirement, VoiceProviderOrchestrationRoutesOptions, VoiceProviderOrchestrationStatus, VoiceProviderOrchestrationSurfaceReport } from './providerOrchestration';

package/dist/index.js

@@ -11256,6 +11256,11 @@ var defaultProviderEnv = {
   "openai-realtime": ["OPENAI_API_KEY"],
   "pipecat-bridge": []
 };
+var defaultRealtimeProviders = [
+  "openai-realtime",
+  "gemini-live",
+  "pipecat-bridge"
+];
 var statusRank = {
   pass: 0,
   warn: 1,
@@ -11264,6 +11269,34 @@ var statusRank = {
 var statusExceeds = (actual, max) => statusRank[actual] > statusRank[max];
 var rollupStatus = (checks) => checks.some((check) => check.status === "fail") ? "fail" : checks.some((check) => check.status === "warn") ? "warn" : "pass";
 var escapeHtml13 = (value) => String(value).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var resolveProviderHref = (value, provider) => typeof value === "string" ? value : value?.[provider];
+var createVoiceRealtimeProviderContractMatrixPreset = (options = {}) => {
+  const providers = options.providers ?? defaultRealtimeProviders;
+  const selected = options.selected ?? providers[0];
+  return {
+    contracts: providers.map((provider) => {
+      const providerKey = String(provider);
+      const requiredEnv = options.requiredEnv?.[providerKey] ?? defaultProviderEnv[providerKey] ?? [];
+      const implementationStatus = options.implementationStatus?.[providerKey] ?? (providerKey === "pipecat-bridge" ? "planned" : "available");
+      const configured = options.configured?.[providerKey] ?? (implementationStatus === "planned" ? false : requiredEnv.every((name) => Boolean(options.env?.[name])));
+      return {
+        capabilities: options.capabilities?.[providerKey] ?? defaultRequiredCapabilities,
+        configured,
+        env: options.env,
+        fallbackProviders: options.fallbackProviders?.[providerKey],
+        implementationStatus,
+        latencyBudgetMs: options.latencyBudgets?.[providerKey],
+        provider,
+        readinessHref: resolveProviderHref(options.readinessHref, provider),
+        realtimeChannel: options.realtimeChannels?.[providerKey],
+        requiredCapabilities: options.requiredCapabilities?.[providerKey] ?? defaultRequiredCapabilities,
+        requiredEnv,
+        selected: provider === selected,
+        traceHref: resolveProviderHref(options.traceHref, provider)
+      };
+    })
+  };
+};
 var buildVoiceRealtimeProviderContractMatrix = (input) => {
   const rows = input.contracts.map((contract) => {
     const configured = contract.configured !== false;
@@ -24157,512 +24190,8 @@ var createGeminiVoiceAssistantModel = (options) => {
     }
   };
 };
-// src/openaiRealtime.ts
-var DEFAULT_AUTO_COMMIT_SILENCE_MS = 450;
-var DEFAULT_BASE_URL = "wss://api.openai.com/v1/realtime";
-var DEFAULT_MODEL = "gpt-realtime";
-var DEFAULT_TRANSCRIPTION_MODEL = "gpt-4o-mini-transcribe";
-var DEFAULT_VOICE = "marin";
-var OPENAI_PCM24_FORMAT = {
-  channels: 1,
-  container: "raw",
-  encoding: "pcm_s16le",
-  sampleRateHz: 24000
-};
-var createListenerMap = () => ({
-  audio: new Set,
-  close: new Set,
-  endOfTurn: new Set,
-  error: new Set,
-  final: new Set,
-  partial: new Set
-});
-var emit = async (listeners, event, payload) => {
-  for (const listener of listeners[event]) {
-    await listener(payload);
-  }
-};
-var compact = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-var resolveErrorMessage = (error) => {
-  if (typeof error === "string" && error.trim()) {
-    return error;
-  }
-  if (error instanceof Error && error.message.trim()) {
-    return error.message;
-  }
-  if (error && typeof error === "object") {
-    const record = error;
-    for (const key of ["message", "reason", "description", "detail"]) {
-      const candidate = record[key];
-      if (typeof candidate === "string" && candidate.trim()) {
-        return candidate;
-      }
-    }
-    if ("error" in record) {
-      return resolveErrorMessage(record.error);
-    }
-    try {
-      return JSON.stringify(error);
-    } catch {}
-  }
-  return "OpenAI realtime error";
-};
-var toUint8Array2 = (value) => value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-var toBase643 = (value) => Buffer.from(toUint8Array2(value)).toString("base64");
-var textTranscript = (text) => ({
-  id: `openai-realtime-text-${crypto.randomUUID()}`,
-  isFinal: true,
-  text,
-  vendor: "openai"
-});
-var audioTranscript = (itemId, text, isFinal) => ({
-  id: itemId,
-  isFinal,
-  text,
-  vendor: "openai"
-});
-var assertPCM24Mono = (format) => {
-  if (format.container !== "raw" || format.encoding !== "pcm_s16le" || format.sampleRateHz !== 24000 || format.channels !== 1) {
-    throw new Error("OpenAI Realtime requires raw pcm_s16le audio at 24kHz mono.");
-  }
-};
-var resolveTranscriptionLanguage = (options, openOptions) => {
-  if (options.inputTranscriptionLanguage?.trim()) {
-    return options.inputTranscriptionLanguage.trim();
-  }
-  if (openOptions.languageStrategy?.mode !== "fixed") {
-    return;
-  }
-  const language = openOptions.languageStrategy.primaryLanguage.trim();
-  return language.length > 0 ? language : undefined;
-};
-var phraseHintPrompt = (options) => {
-  const terms = (options.phraseHints ?? []).flatMap((hint) => [
-    hint.text,
-    ...hint.aliases ?? []
-  ]);
-  const unique2 = terms.filter((value, index) => terms.indexOf(value) === index);
-  return unique2.length ? `Prioritize accurate recovery of these phrases when heard: ${unique2.join(", ")}.` : undefined;
-};
-var lexiconPrompt = (options) => {
-  const entries = (options.lexicon ?? []).flatMap((entry) => {
-    const details = [
-      entry.text,
-      entry.pronunciation ? `pronounced ${entry.pronunciation}` : undefined,
-      entry.aliases?.length ? `may also sound like ${entry.aliases.join(", ")}` : undefined,
-      entry.language ? `language ${entry.language}` : undefined
-    ].filter((value) => !!value);
-    return details.length ? [details.join(" - ")] : [];
-  });
-  return entries.length ? `Use this pronunciation lexicon when transcribing: ${entries.join("; ")}.` : undefined;
-};
-var withOpenPrompts = (options, openOptions) => {
-  const phraseHints = phraseHintPrompt(openOptions);
-  const lexicon = lexiconPrompt(openOptions);
-  if (!phraseHints && !lexicon) {
-    return options;
-  }
-  return {
-    ...options,
-    inputTranscriptionPrompt: [
-      options.inputTranscriptionPrompt,
-      phraseHints,
-      lexicon
-    ].filter((value) => !!value?.trim()).join(`
-
-`)
-  };
-};
-var sessionUpdateEvent = (options, openOptions) => {
-  const responseMode = options.responseMode ?? "audio";
-  const language = resolveTranscriptionLanguage(options, openOptions);
-  const transcription = options.inputTranscriptionModel === null ? null : compact({
-    language,
-    model: options.inputTranscriptionModel ?? DEFAULT_TRANSCRIPTION_MODEL,
-    prompt: options.inputTranscriptionPrompt
-  });
-  return {
-    event_id: `session-update-${crypto.randomUUID()}`,
-    session: compact({
-      audio: {
-        input: compact({
-          format: {
-            rate: 24000,
-            type: "audio/pcm"
-          },
-          noise_reduction: options.noiseReduction ? { type: options.noiseReduction } : undefined,
-          transcription,
-          turn_detection: null
-        }),
-        output: responseMode === "audio" ? compact({
-          format: {
-            rate: 24000,
-            type: "audio/pcm"
-          },
-          speed: options.speed,
-          voice: options.voice ?? DEFAULT_VOICE
-        }) : undefined
-      },
-      instructions: options.instructions,
-      max_output_tokens: options.maxOutputTokens,
-      output_modalities: [responseMode],
-      temperature: options.temperature,
-      type: "realtime"
-    }),
-    type: "session.update"
-  };
-};
-var responseCreateEvent = (options) => {
-  const responseMode = options.responseMode ?? "audio";
-  return {
-    response: compact({
-      audio: responseMode === "audio" ? {
-        output: compact({
-          format: {
-            rate: 24000,
-            type: "audio/pcm"
-          },
-          voice: options.voice ?? DEFAULT_VOICE
-        })
-      } : undefined,
-      conversation: "auto",
-      max_output_tokens: options.maxOutputTokens,
-      output_modalities: [responseMode]
-    }),
-    type: "response.create"
-  };
-};
-var createOpenAIRealtimeAdapter = (options) => {
-  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
-  const Socket = options.webSocket ?? globalThis.WebSocket;
-  return {
-    kind: "realtime",
-    open: (openOptions) => {
-      assertPCM24Mono(openOptions.format);
-      const runtimeOptions = openOptions;
-      const runtimeConfig = withOpenPrompts(options, runtimeOptions);
-      const model = runtimeConfig.model ?? DEFAULT_MODEL;
-      const listeners = createListenerMap();
-      const socket = new Socket(`${baseUrl.replace(/\/$/, "")}?model=${encodeURIComponent(model)}`, {
-        headers: {
-          Authorization: `Bearer ${runtimeConfig.apiKey}`
-        }
-      });
-      const primaryUpdate = sessionUpdateEvent(runtimeConfig, runtimeOptions);
-      const pendingMessages = [];
-      const partials = new Map;
-      const finals = new Set;
-      const autoCommitSilenceMs = runtimeConfig.autoCommitSilenceMs ?? DEFAULT_AUTO_COMMIT_SILENCE_MS;
-      let audioCommitTimer;
-      let closeEmitted = false;
-      let closed = false;
-      let pendingAudio = false;
-      let ready = false;
-      let readyTimeout;
-      let socketOpen = false;
-      let resolveReady;
-      let rejectReady;
-      const readyPromise = new Promise((resolve2, reject) => {
-        resolveReady = resolve2;
-        rejectReady = reject;
-      });
-      const clearReadyTimeout = () => {
-        if (readyTimeout) {
-          clearTimeout(readyTimeout);
-          readyTimeout = undefined;
-        }
-      };
-      const markReady = () => {
-        if (ready || closed) {
-          return;
-        }
-        ready = true;
-        clearReadyTimeout();
-        resolveReady();
-      };
-      const failReady = (error) => {
-        if (ready || closed) {
-          return;
-        }
-        clearReadyTimeout();
-        rejectReady(error);
-      };
-      const sendRaw = (payload) => {
-        const serialized = JSON.stringify(payload);
-        if (!socketOpen) {
-          pendingMessages.push(serialized);
-          return;
-        }
-        socket.send(serialized);
-      };
-      const flush = () => {
-        for (const message of pendingMessages.splice(0)) {
-          socket.send(message);
-        }
-      };
-      const emitClose = async (code, reason, recoverable = false) => {
-        if (closeEmitted) {
-          return;
-        }
-        closeEmitted = true;
-        await emit(listeners, "close", {
-          code,
-          reason,
-          recoverable,
-          type: "close"
-        });
-      };
-      const commitAudio = async () => {
-        if (closed || !pendingAudio) {
-          return;
-        }
-        pendingAudio = false;
-        sendRaw({ type: "input_audio_buffer.commit" });
-        sendRaw(responseCreateEvent(runtimeConfig));
-      };
-      const resetAudioTimer = () => {
-        if (audioCommitTimer) {
-          clearTimeout(audioCommitTimer);
-        }
-        audioCommitTimer = setTimeout(() => {
-          commitAudio();
-        }, autoCommitSilenceMs);
-      };
-      socket.addEventListener("open", () => {
-        socketOpen = true;
-        sendRaw(primaryUpdate);
-        flush();
-        readyTimeout = setTimeout(() => {
-          failReady(new Error("OpenAI realtime session did not become ready."));
-        }, 8000);
-      }, { once: true });
-      socket.addEventListener("message", (event) => {
-        try {
-          const payload = JSON.parse(String(event.data));
-          const shouldEmitResponseTranscripts = runtimeConfig.emitResponseTranscripts === true;
-          switch (payload.type) {
-            case "session.created":
-            case "session.updated":
-              markReady();
-              return;
-            case "conversation.item.input_audio_transcription.delta": {
-              const itemId = typeof payload.item_id === "string" ? payload.item_id : undefined;
-              const delta = typeof payload.delta === "string" ? payload.delta : undefined;
-              if (!itemId || !delta) {
-                return;
-              }
-              const text = `${partials.get(itemId) ?? ""}${delta}`;
-              partials.set(itemId, text);
-              emit(listeners, "partial", {
-                receivedAt: Date.now(),
-                transcript: audioTranscript(itemId, text, false),
-                type: "partial"
-              });
-              return;
-            }
-            case "conversation.item.input_audio_transcription.completed": {
-              const itemId = typeof payload.item_id === "string" ? payload.item_id : undefined;
-              const transcript = typeof payload.transcript === "string" ? payload.transcript : undefined;
-              if (!itemId || !transcript || finals.has(itemId)) {
-                return;
-              }
-              finals.add(itemId);
-              partials.set(itemId, transcript);
-              emit(listeners, "final", {
-                receivedAt: Date.now(),
-                transcript: audioTranscript(itemId, transcript, true),
-                type: "final"
-              });
-              emit(listeners, "endOfTurn", {
-                receivedAt: Date.now(),
-                reason: "vendor",
-                type: "endOfTurn"
-              });
-              return;
-            }
-            case "conversation.item.input_audio_transcription.failed": {
-              const error = payload.error && typeof payload.error === "object" ? payload.error : undefined;
-              emit(listeners, "error", {
-                code: error?.code,
-                error: new Error(resolveErrorMessage(error ?? payload)),
-                recoverable: true,
-                type: "error"
-              });
-              return;
-            }
-            case "response.audio.delta":
-            case "response.output_audio.delta": {
-              const delta = typeof payload.delta === "string" ? payload.delta : undefined;
-              if (!delta) {
-                return;
-              }
-              emit(listeners, "audio", {
-                chunk: Buffer.from(delta, "base64"),
-                format: OPENAI_PCM24_FORMAT,
-                receivedAt: Date.now(),
-                type: "audio"
-              });
-              return;
-            }
-            case "response.audio_transcript.delta":
-            case "response.output_audio_transcript.delta":
-            case "response.output_text.delta": {
-              if (!shouldEmitResponseTranscripts) {
-                return;
-              }
-              const delta = typeof payload.delta === "string" ? payload.delta : undefined;
-              if (!delta) {
-                return;
-              }
-              emit(listeners, "partial", {
-                receivedAt: Date.now(),
-                transcript: textTranscript(delta),
-                type: "partial"
-              });
-              return;
-            }
-            case "response.audio_transcript.done":
-            case "response.output_audio_transcript.done":
-            case "response.output_text.done": {
-              if (!shouldEmitResponseTranscripts) {
-                return;
-              }
-              const transcript = typeof payload.transcript === "string" ? payload.transcript : undefined;
-              if (!transcript) {
-                return;
-              }
-              emit(listeners, "final", {
-                receivedAt: Date.now(),
-                transcript: textTranscript(transcript),
-                type: "final"
-              });
-              emit(listeners, "endOfTurn", {
-                receivedAt: Date.now(),
-                reason: "vendor",
-                type: "endOfTurn"
-              });
-              return;
-            }
-            case "error": {
-              const error = payload.error && typeof payload.error === "object" ? payload.error : {};
-              const message = resolveErrorMessage(error);
-              emit(listeners, "error", {
-                code: error.code,
-                error: new Error(message),
-                recoverable: true,
-                type: "error"
-              });
-              if (!ready && error.event_id === primaryUpdate.event_id) {
-                failReady(new Error(message));
-              }
-              return;
-            }
-            default:
-              return;
-          }
-        } catch (error) {
-          emit(listeners, "error", {
-            error: new Error(resolveErrorMessage(error)),
-            recoverable: true,
-            type: "error"
-          });
-        }
-      });
-      socket.addEventListener("error", (event) => {
-        const error = new Error(resolveErrorMessage(event));
-        failReady(error);
-        emit(listeners, "error", {
-          error,
-          recoverable: false,
-          type: "error"
-        });
-      });
-      socket.addEventListener("close", (event) => {
-        socketOpen = false;
-        clearReadyTimeout();
-        if (!ready) {
-          failReady(new Error("OpenAI realtime session closed before ready."));
-        }
-        emitClose(event.code, event.reason || undefined, event.code !== 1000);
-      });
-      if (openOptions.signal) {
-        if (openOptions.signal.aborted) {
-          closed = true;
-          socket.close(1000, "aborted");
-        } else {
-          openOptions.signal.addEventListener("abort", () => {
-            if (!closed) {
-              closed = true;
-              socket.close(1000, "aborted");
-            }
-          }, { once: true });
-        }
-      }
-      return {
-        close: async (reason) => {
-          if (closed) {
-            return;
-          }
-          closed = true;
-          clearReadyTimeout();
-          if (audioCommitTimer) {
-            clearTimeout(audioCommitTimer);
-            audioCommitTimer = undefined;
-          }
-          await commitAudio().catch(() => {});
-          socket.close(1000, reason);
-          await emitClose(1000, reason, false);
-        },
-        on: (event, handler) => {
-          listeners[event].add(handler);
-          return () => {
-            listeners[event].delete(handler);
-          };
-        },
-        send: async (input) => {
-          await readyPromise;
-          if (closed) {
-            return;
-          }
-          if (typeof input === "string") {
-            const text = input.trim();
-            if (!text) {
-              return;
-            }
-            await emit(listeners, "final", {
-              receivedAt: Date.now(),
-              transcript: textTranscript(text),
-              type: "final"
-            });
-            await emit(listeners, "endOfTurn", {
-              receivedAt: Date.now(),
-              reason: "manual",
-              type: "endOfTurn"
-            });
-            sendRaw({
-              item: {
-                content: [{ text, type: "input_text" }],
-                role: "user",
-                type: "message"
-              },
-              type: "conversation.item.create"
-            });
-            sendRaw(responseCreateEvent(runtimeConfig));
-            return;
-          }
-          sendRaw({
-            audio: toBase643(input),
-            type: "input_audio_buffer.append"
-          });
-          pendingAudio = true;
-          resetAudioTimer();
-        }
-      };
-    }
-  };
-};
 // src/openaiTTS.ts
-var OPENAI_PCM24_FORMAT2 = {
+var OPENAI_PCM24_FORMAT = {
   channels: 1,
   container: "raw",
   encoding: "pcm_s16le",
@@ -24675,7 +24204,7 @@ var resolveInstructions = async (instructions, input) => {
   return instructions;
 };
 var createTTSHTTPError = (response) => new Error(`OpenAI voice TTS failed: HTTP ${response.status}`);
-var emit2 = async (listeners, event, payload) => {
+var emit = async (listeners, event, payload) => {
   for (const handler of listeners[event]) {
     await Promise.resolve(handler(payload));
   }
@@ -24705,7 +24234,7 @@ var createOpenAIVoiceTTS = (options) => {
           closed = true;
           abortController.abort();
           openOptions.signal?.removeEventListener("abort", signalAbort);
-          await emit2(listeners, "close", {
+          await emit(listeners, "close", {
             reason,
             type: "close"
           });
@@ -24748,9 +24277,9 @@ var createOpenAIVoiceTTS = (options) => {
             if (!response.body) {
               const chunk = new Uint8Array(await response.arrayBuffer());
               if (!closed && chunk.byteLength > 0) {
-                await emit2(listeners, "audio", {
+                await emit(listeners, "audio", {
                   chunk,
-                  format: OPENAI_PCM24_FORMAT2,
+                  format: OPENAI_PCM24_FORMAT,
                   receivedAt: Date.now(),
                   type: "audio"
                 });
@@ -24765,9 +24294,9 @@ var createOpenAIVoiceTTS = (options) => {
                   break;
                 }
                 if (value.byteLength > 0) {
-                  await emit2(listeners, "audio", {
+                  await emit(listeners, "audio", {
                     chunk: new Uint8Array(value),
-                    format: OPENAI_PCM24_FORMAT2,
+                    format: OPENAI_PCM24_FORMAT,
                     receivedAt: Date.now(),
                     type: "audio"
                   });
@@ -24781,7 +24310,7 @@ var createOpenAIVoiceTTS = (options) => {
               return;
             }
             const normalizedError = error instanceof Error ? error : new Error(String(error));
-            await emit2(listeners, "error", {
+            await emit(listeners, "error", {
               error: normalizedError,
               recoverable: true,
               type: "error"
@@ -32493,11 +32022,11 @@ var createResolver = (options) => {
       selectedProvider: preferred
     };
   };
-  const emit3 = async (event, input) => {
+  const emit2 = async (event, input) => {
     await options.onProviderEvent?.(event, input);
   };
   return {
-    emit: emit3,
+    emit: emit2,
     getSuppressionRemainingMs,
     providerIds,
     recordError,
@@ -34775,6 +34304,7 @@ export {
   createVoiceRedisIdempotencyStore,
   createVoiceReconnectContractRoutes,
   createVoiceRealtimeProviderContractRoutes,
+  createVoiceRealtimeProviderContractMatrixPreset,
   createVoiceRealtimeChannelRoutes,
   createVoiceReadinessProfile,
   createVoiceQualityRoutes,
@@ -34960,7 +34490,6 @@ export {
   createPhraseHintCorrectionHandler,
   createOpenAIVoiceTTS,
   createOpenAIVoiceAssistantModel,
-  createOpenAIRealtimeAdapter,
   createMemoryVoiceTelnyxWebhookEventStore,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,
   createMemoryVoicePlivoWebhookNonceStore,

package/dist/realtimeProviderContracts.d.ts

@@ -17,6 +17,22 @@ export type VoiceRealtimeProviderContractDefinition<TProvider extends string = s
     selected?: boolean;
     traceHref?: string;
 };
+export type VoiceRealtimeProviderPresetProvider = 'gemini-live' | 'openai-realtime' | 'pipecat-bridge' | (string & {});
+export type VoiceRealtimeProviderContractMatrixPresetOptions<TProvider extends string = VoiceRealtimeProviderPresetProvider> = {
+    capabilities?: Record<string, readonly VoiceRealtimeProviderContractCapability[]>;
+    configured?: Record<string, boolean>;
+    env?: Record<string, string | undefined>;
+    fallbackProviders?: Record<string, readonly TProvider[]>;
+    implementationStatus?: Record<string, 'available' | 'planned'>;
+    latencyBudgets?: Record<string, number>;
+    providers?: readonly TProvider[];
+    readinessHref?: string | Record<string, string | undefined>;
+    realtimeChannels?: Record<string, VoiceRealtimeChannelReport | undefined>;
+    requiredCapabilities?: Record<string, readonly VoiceRealtimeProviderContractCapability[]>;
+    requiredEnv?: Record<string, readonly string[]>;
+    selected?: TProvider;
+    traceHref?: string | Record<string, string | undefined>;
+};
 export type VoiceRealtimeProviderContractCheck = {
     detail?: string;
     key: string;
@@ -70,6 +86,7 @@ export type VoiceRealtimeProviderContractRoutesOptions<TProvider extends string
     render?: (report: VoiceRealtimeProviderContractMatrixReport<TProvider>) => Promise<string> | string;
     title?: string;
 };
+export declare const createVoiceRealtimeProviderContractMatrixPreset: <TProvider extends string = VoiceRealtimeProviderPresetProvider>(options?: VoiceRealtimeProviderContractMatrixPresetOptions<TProvider>) => VoiceRealtimeProviderContractMatrixInput<TProvider>;
 export declare const buildVoiceRealtimeProviderContractMatrix: <TProvider extends string = string>(input: VoiceRealtimeProviderContractMatrixInput<TProvider>) => VoiceRealtimeProviderContractMatrixReport<TProvider>;
 export declare const evaluateVoiceRealtimeProviderContractEvidence: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, input?: VoiceRealtimeProviderContractAssertionInput<TProvider>) => VoiceRealtimeProviderContractAssertionReport<TProvider>;
 export declare const assertVoiceRealtimeProviderContractEvidence: <TProvider extends string = string>(report: VoiceRealtimeProviderContractMatrixReport<TProvider>, input?: VoiceRealtimeProviderContractAssertionInput<TProvider>) => VoiceRealtimeProviderContractAssertionReport<TProvider>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.305",
+	"version": "0.0.22-beta.307",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",

package/dist/openaiRealtime.d.ts

@@ -1,27 +0,0 @@
-import type { RealtimeAdapter } from './types';
-export type OpenAIRealtimeModel = 'gpt-realtime' | 'gpt-realtime-mini' | 'gpt-4o-realtime-preview' | 'gpt-4o-mini-realtime-preview' | (string & {});
-export type OpenAIRealtimeVoice = 'alloy' | 'ash' | 'ballad' | 'cedar' | 'coral' | 'echo' | 'marin' | 'sage' | 'shimmer' | 'verse' | {
-    id: string;
-} | (string & {});
-export type OpenAIRealtimeTranscriptionModel = 'gpt-4o-mini-transcribe' | 'gpt-4o-transcribe' | 'whisper-1' | (string & {});
-export type OpenAIRealtimeNoiseReduction = 'near_field' | 'far_field';
-export type OpenAIRealtimeResponseMode = 'audio' | 'text';
-export type OpenAIRealtimeAdapterOptions = {
-    apiKey: string;
-    autoCommitSilenceMs?: number;
-    baseUrl?: string;
-    emitResponseTranscripts?: boolean;
-    inputTranscriptionLanguage?: string;
-    inputTranscriptionModel?: OpenAIRealtimeTranscriptionModel | null;
-    inputTranscriptionPrompt?: string;
-    instructions?: string;
-    maxOutputTokens?: number | 'inf';
-    model?: OpenAIRealtimeModel;
-    noiseReduction?: OpenAIRealtimeNoiseReduction;
-    responseMode?: OpenAIRealtimeResponseMode;
-    speed?: number;
-    temperature?: number;
-    voice?: OpenAIRealtimeVoice;
-    webSocket?: typeof WebSocket;
-};
-export declare const createOpenAIRealtimeAdapter: (options: OpenAIRealtimeAdapterOptions) => RealtimeAdapter;