@absolutejs/voice 0.0.22-beta.82 → 0.0.22-beta.84

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export { applyVoiceTelephonyOutcome, createMemoryVoiceTelephonyWebhookIdempotenc
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, resolveVoiceProviderRoutingPolicyPreset, createVoiceProviderRouter } from './modelAdapters';
+export { createOpenAIVoiceTTS } from './openaiTTS';
 export { createVoiceProviderHealthHTMLHandler, createVoiceProviderHealthJSONHandler, createVoiceProviderHealthRoutes, renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth } from './providerHealth';
 export { createVoiceProviderCapabilityHTMLHandler, createVoiceProviderCapabilityJSONHandler, createVoiceProviderCapabilityRoutes, renderVoiceProviderCapabilityHTML, summarizeVoiceProviderCapabilities } from './providerCapabilities';
 export { buildVoiceOpsConsoleReport, createVoiceOpsConsoleRoutes, renderVoiceOpsConsoleHTML } from './opsConsoleRoutes';
@@ -53,6 +54,7 @@ export type { VoiceEvalBaselineComparison, VoiceEvalBaselineComparisonOptions, V
 export type { VoiceWorkflowContract, VoiceWorkflowContractDefinition, VoiceWorkflowContractField, VoiceWorkflowContractFieldMatch, VoiceWorkflowContractPresetName, VoiceWorkflowContractPresetOptions, VoiceWorkflowContractTracePayload, VoiceWorkflowContractValidation, VoiceWorkflowContractValidationIssue, VoiceWorkflowOutcome } from './workflowContract';
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn } from './sessionReplay';
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterPolicyPreset, VoiceProviderRouterPolicyWeights, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceProviderRouterStrategy, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
+export type { OpenAIVoiceTTSOptions, OpenAIVoiceTTSVoice } from './openaiTTS';
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
 export type { VoiceProviderCapabilityDefinition, VoiceProviderCapabilityHandlerOptions, VoiceProviderCapabilityHTMLHandlerOptions, VoiceProviderCapabilityKind, VoiceProviderCapabilityOptions, VoiceProviderCapabilityReport, VoiceProviderCapabilityRoutesOptions, VoiceProviderCapabilitySummary } from './providerCapabilities';
 export type { VoiceTurnQualityHTMLHandlerOptions, VoiceTurnQualityItem, VoiceTurnQualityOptions, VoiceTurnQualityReport, VoiceTurnQualityRoutesOptions, VoiceTurnQualityStatus } from './turnQuality';

package/dist/index.js

@@ -12424,6 +12424,138 @@ var createGeminiVoiceAssistantModel = (options) => {
     }
   };
 };
+// src/openaiTTS.ts
+var OPENAI_PCM24_FORMAT = {
+  channels: 1,
+  container: "raw",
+  encoding: "pcm_s16le",
+  sampleRateHz: 24000
+};
+var resolveInstructions = async (instructions, input) => {
+  if (typeof instructions === "function") {
+    return instructions(input);
+  }
+  return instructions;
+};
+var createTTSHTTPError = (response) => new Error(`OpenAI voice TTS failed: HTTP ${response.status}`);
+var emit = async (listeners, event, payload) => {
+  for (const handler of listeners[event]) {
+    await Promise.resolve(handler(payload));
+  }
+};
+var createOpenAIVoiceTTS = (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const baseUrl = options.baseUrl ?? "https://api.openai.com/v1";
+  const model = options.model ?? "gpt-4o-mini-tts";
+  const voice2 = options.voice ?? "coral";
+  return {
+    kind: "tts",
+    open: (openOptions) => {
+      const listeners = {
+        audio: new Set,
+        close: new Set,
+        error: new Set
+      };
+      const abortController = new AbortController;
+      const signalAbort = () => abortController.abort();
+      openOptions.signal?.addEventListener("abort", signalAbort, { once: true });
+      let closed = false;
+      return {
+        close: async (reason) => {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          abortController.abort();
+          openOptions.signal?.removeEventListener("abort", signalAbort);
+          await emit(listeners, "close", {
+            reason,
+            type: "close"
+          });
+        },
+        on: (event, handler) => {
+          listeners[event].add(handler);
+          return () => {
+            listeners[event].delete(handler);
+          };
+        },
+        send: async (text) => {
+          if (closed || !text.trim()) {
+            return;
+          }
+          try {
+            const instructions = await resolveInstructions(options.instructions, {
+              lexicon: openOptions.lexicon,
+              sessionId: openOptions.sessionId,
+              text
+            });
+            const response = await fetchImpl(`${baseUrl.replace(/\/$/, "")}/audio/speech`, {
+              body: JSON.stringify({
+                input: text,
+                instructions,
+                model,
+                response_format: "pcm",
+                speed: options.speed,
+                voice: voice2
+              }),
+              headers: {
+                authorization: `Bearer ${options.apiKey}`,
+                "content-type": "application/json"
+              },
+              method: "POST",
+              signal: abortController.signal
+            });
+            if (!response.ok) {
+              throw createTTSHTTPError(response);
+            }
+            if (!response.body) {
+              const chunk = new Uint8Array(await response.arrayBuffer());
+              if (!closed && chunk.byteLength > 0) {
+                await emit(listeners, "audio", {
+                  chunk,
+                  format: OPENAI_PCM24_FORMAT,
+                  receivedAt: Date.now(),
+                  type: "audio"
+                });
+              }
+              return;
+            }
+            const reader = response.body.getReader();
+            try {
+              while (!closed) {
+                const { done, value } = await reader.read();
+                if (done) {
+                  break;
+                }
+                if (value.byteLength > 0) {
+                  await emit(listeners, "audio", {
+                    chunk: new Uint8Array(value),
+                    format: OPENAI_PCM24_FORMAT,
+                    receivedAt: Date.now(),
+                    type: "audio"
+                  });
+                }
+              }
+            } finally {
+              reader.releaseLock();
+            }
+          } catch (error) {
+            if (closed || abortController.signal.aborted) {
+              return;
+            }
+            const normalizedError = error instanceof Error ? error : new Error(String(error));
+            await emit(listeners, "error", {
+              error: normalizedError,
+              recoverable: true,
+              type: "error"
+            });
+            throw normalizedError;
+          }
+        }
+      };
+    }
+  };
+};
 // src/providerAdapters.ts
 class VoiceIOProviderTimeoutError extends Error {
   provider;
@@ -12611,11 +12743,11 @@ var createResolver = (options) => {
       selectedProvider: preferred
     };
   };
-  const emit = async (event, input) => {
+  const emit2 = async (event, input) => {
     await options.onProviderEvent?.(event, input);
   };
   return {
-    emit,
+    emit: emit2,
     getSuppressionRemainingMs,
     providerIds,
     recordError,
@@ -17300,6 +17432,7 @@ export {
   createPlivoVoiceResponse,
   createPlivoMediaStreamBridge,
   createPhraseHintCorrectionHandler,
+  createOpenAIVoiceTTS,
   createOpenAIVoiceAssistantModel,
   createMemoryVoiceTelephonyWebhookIdempotencyStore,
   createJSONVoiceAssistantModel,

package/dist/openaiTTS.d.ts

@@ -0,0 +1,18 @@
+import type { TTSAdapter, TTSAdapterOpenOptions, VoiceLexiconEntry } from './types';
+export type OpenAIVoiceTTSVoice = 'alloy' | 'ash' | 'ballad' | 'cedar' | 'coral' | 'echo' | 'fable' | 'marin' | 'nova' | 'onyx' | 'sage' | 'shimmer' | 'verse' | (string & {});
+export type OpenAIVoiceTTSOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    instructions?: string | ((input: {
+        lexicon?: VoiceLexiconEntry[];
+        sessionId: string;
+        text: string;
+    }) => Promise<string | undefined> | string | undefined);
+    model?: 'gpt-4o-mini-tts' | 'tts-1' | 'tts-1-hd' | (string & {});
+    speed?: number;
+    voice?: OpenAIVoiceTTSVoice | {
+        id: string;
+    };
+};
+export declare const createOpenAIVoiceTTS: (options: OpenAIVoiceTTSOptions) => TTSAdapter<TTSAdapterOpenOptions>;

package/package.json

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