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

package/dist/index.d.ts

@@ -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

@@ -24157,512 +24157,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 +24171,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 +24201,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 +24244,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 +24261,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 +24277,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 +31989,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,
@@ -34960,7 +34456,6 @@ export {
   createPhraseHintCorrectionHandler,
   createOpenAIVoiceTTS,
   createOpenAIVoiceAssistantModel,
-  createOpenAIRealtimeAdapter,
   createMemoryVoiceTelnyxWebhookEventStore,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,
   createMemoryVoicePlivoWebhookNonceStore,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.305",
+	"version": "0.0.22-beta.306",
 	"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;