@absolutejs/voice 0.0.22-beta.32 → 0.0.22-beta.34

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, createVoiceProviderRouter } from './modelAdapters';
 export { createVoiceProviderHealthHTMLHandler, createVoiceProviderHealthJSONHandler, createVoiceProviderHealthRoutes, renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth } from './providerHealth';
+export { createVoiceSTTProviderRouter, createVoiceTTSProviderRouter } from './providerAdapters';
 export { buildVoiceTraceReplay, createVoiceMemoryTraceSinkDeliveryStore, createVoiceTraceHTTPSink, createVoiceMemoryTraceEventStore, createVoiceTraceSinkDeliveryId, createVoiceTraceSinkDeliveryRecord, createVoiceTraceSinkStore, createVoiceTraceEvent, createVoiceTraceEventId, deliverVoiceTraceEventsToSinks, evaluateVoiceTrace, exportVoiceTrace, filterVoiceTraceEvents, pruneVoiceTraceEvents, redactVoiceTraceEvent, redactVoiceTraceEvents, redactVoiceTraceText, renderVoiceTraceHTML, renderVoiceTraceMarkdown, resolveVoiceTraceRedactionOptions, selectVoiceTraceEventsForPrune, summarizeVoiceTrace } from './trace';
 export { createVoiceSQLiteExternalObjectMapStore, createVoiceSQLiteIntegrationEventStore, createVoiceSQLiteReviewStore, createVoiceSQLiteRuntimeStorage, createVoiceSQLiteSessionStore, createVoiceSQLiteTaskStore, createVoiceSQLiteTraceSinkDeliveryStore, createVoiceSQLiteTraceEventStore } from './sqliteStore';
 export { createVoicePostgresExternalObjectMapStore, createVoicePostgresIntegrationEventStore, createVoicePostgresReviewStore, createVoicePostgresRuntimeStorage, createVoicePostgresSessionStore, createVoicePostgresTaskStore, createVoicePostgresTraceSinkDeliveryStore, createVoicePostgresTraceEventStore } from './postgresStore';
@@ -36,6 +37,7 @@ export type { VoiceAssistantMemoryBinding, VoiceAssistantMemoryHandle, VoiceAssi
 export type { VoiceSessionListHTMLHandlerOptions, VoiceSessionListItem, VoiceSessionListOptions, VoiceSessionListRoutesOptions, VoiceSessionListStatus, VoiceSessionReplay, VoiceSessionReplayHTMLHandlerOptions, VoiceSessionReplayOptions, VoiceSessionReplayRoutesOptions, VoiceSessionReplayTurn } from './sessionReplay';
 export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
+export type { VoiceIOProviderRouterEvent, VoiceSTTProviderRouterOptions, VoiceTTSProviderRouterOptions } from './providerAdapters';
 export type { VoiceAgent, VoiceAgentMessage, VoiceAgentMessageRole, VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput, VoiceAgentOptions, VoiceAgentRunResult, VoiceAgentSquadOptions, VoiceAgentTool, VoiceAgentToolCall, VoiceAgentToolResult } from './agent';
 export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, VoiceOpsRuntimeSinkWorkerConfig, VoiceOpsRuntimeTaskWorkerConfig, VoiceOpsRuntimeTickResult, VoiceOpsRuntimeWebhookWorkerConfig } from './opsRuntime';
 export type { VoiceOpsPresetName, VoiceOpsPresetOverrides, VoiceResolvedOpsPreset } from './opsPresets';

package/dist/index.js

@@ -8858,6 +8858,368 @@ var createGeminiVoiceAssistantModel = (options) => {
     }
   };
 };
+// src/providerAdapters.ts
+class VoiceIOProviderTimeoutError extends Error {
+  provider;
+  timeoutMs;
+  constructor(kind, provider, timeoutMs) {
+    super(`Voice ${kind} provider ${provider} exceeded ${timeoutMs}ms latency budget.`);
+    this.name = "VoiceIOProviderTimeoutError";
+    this.provider = provider;
+    this.timeoutMs = timeoutMs;
+  }
+}
+var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
+var createEmitter = () => {
+  const listeners = new Map;
+  return {
+    emit: async (event, payload) => {
+      await Promise.all([...listeners.get(event) ?? []].map((handler) => Promise.resolve(handler(payload))));
+    },
+    on: (event, handler) => {
+      const set = listeners.get(event) ?? new Set;
+      set.add(handler);
+      listeners.set(event, set);
+      return () => {
+        set.delete(handler);
+      };
+    }
+  };
+};
+var getTimeoutMs = (options, provider) => {
+  const timeoutMs = options.providerProfiles?.[provider]?.timeoutMs ?? options.timeoutMs;
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+};
+var withTimeout = async (input) => {
+  if (!input.timeoutMs) {
+    return input.run();
+  }
+  let timeout;
+  try {
+    return await Promise.race([
+      Promise.resolve(input.run()),
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new VoiceIOProviderTimeoutError(input.kind, input.provider, input.timeoutMs)), input.timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+};
+var createResolver = (options) => {
+  const providerIds = Object.keys(options.adapters);
+  const firstProvider = providerIds[0];
+  const healthOptions = typeof options.providerHealth === "object" ? options.providerHealth : options.providerHealth ? {} : undefined;
+  const healthState = new Map;
+  const now = () => healthOptions?.now?.() ?? Date.now();
+  const failureThreshold = Math.max(1, healthOptions?.failureThreshold ?? 1);
+  const cooldownMs = Math.max(0, healthOptions?.cooldownMs ?? 30000);
+  const getHealth = (provider) => {
+    const existing = healthState.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const next = {
+      consecutiveFailures: 0,
+      provider,
+      status: "healthy"
+    };
+    healthState.set(provider, next);
+    return next;
+  };
+  const cloneHealth = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    return {
+      ...getHealth(provider)
+    };
+  };
+  const getSuppressionRemainingMs = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" ? Math.max(0, suppressedUntil - now()) : undefined;
+  };
+  const isSuppressed = (provider) => {
+    if (!healthOptions) {
+      return false;
+    }
+    const suppressedUntil = getHealth(provider).suppressedUntil;
+    return typeof suppressedUntil === "number" && suppressedUntil > now();
+  };
+  const recordSuccess = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures = 0;
+    health.status = "healthy";
+    health.suppressedUntil = undefined;
+    return cloneHealth(provider);
+  };
+  const recordError = (provider, isProviderError) => {
+    if (!healthOptions || !isProviderError) {
+      return cloneHealth(provider);
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures += 1;
+    health.lastFailureAt = now();
+    if (health.consecutiveFailures >= failureThreshold) {
+      health.status = "suppressed";
+      health.suppressedUntil = now() + cooldownMs;
+    }
+    return cloneHealth(provider);
+  };
+  const resolveOrder = async (input) => {
+    const selectedProvider = await options.selectProvider?.(input) ?? firstProvider;
+    const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
+    const candidates = [selectedProvider, ...fallbackOrder ?? providerIds];
+    const seen = new Set;
+    const rankedOrder = candidates.filter((provider) => {
+      if (!provider || seen.has(provider) || !options.adapters[provider]) {
+        return false;
+      }
+      seen.add(provider);
+      return true;
+    });
+    const healthyOrder = healthOptions ? rankedOrder.filter((provider) => !isSuppressed(provider)) : rankedOrder;
+    const order = healthyOrder.length ? healthyOrder : rankedOrder;
+    return {
+      order,
+      selectedProvider: selectedProvider && !isSuppressed(selectedProvider) ? selectedProvider : order[0]
+    };
+  };
+  const emit = async (event, input) => {
+    await options.onProviderEvent?.(event, input);
+  };
+  return {
+    emit,
+    getSuppressionRemainingMs,
+    providerIds,
+    recordError,
+    recordSuccess,
+    resolveOrder
+  };
+};
+var createVoiceSTTProviderRouter = (options) => {
+  const resolver = createResolver(options);
+  return {
+    kind: "stt",
+    open: async (input) => {
+      const { order, selectedProvider } = await resolver.resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice STT provider router has no available providers.");
+      }
+      let lastError;
+      for (const [index, provider] of order.entries()) {
+        const adapter = options.adapters[provider];
+        if (!adapter) {
+          continue;
+        }
+        const startedAt = Date.now();
+        try {
+          const session = await withTimeout({
+            kind: "stt",
+            operation: "open",
+            provider,
+            run: () => adapter.open(input),
+            timeoutMs: getTimeoutMs(options, provider)
+          });
+          const providerHealth = resolver.recordSuccess(provider);
+          await resolver.emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            fallbackProvider: provider === selectedProvider ? undefined : provider,
+            kind: "stt",
+            latencyBudgetMs: getTimeoutMs(options, provider),
+            operation: "open",
+            provider,
+            providerHealth,
+            selectedProvider,
+            status: provider === selectedProvider ? "success" : "fallback"
+          }, input);
+          return session;
+        } catch (error) {
+          lastError = error;
+          const hasNextProvider = index < order.length - 1;
+          const shouldFallback = options.isProviderError?.(error, provider) ?? true;
+          const providerHealth = resolver.recordError(provider, shouldFallback);
+          await resolver.emit({
+            at: Date.now(),
+            attempt: index + 1,
+            elapsedMs: Date.now() - startedAt,
+            error: errorMessage2(error),
+            fallbackProvider: shouldFallback ? order[index + 1] : undefined,
+            kind: "stt",
+            latencyBudgetMs: getTimeoutMs(options, provider),
+            operation: "open",
+            provider,
+            providerHealth,
+            selectedProvider,
+            status: "error",
+            suppressionRemainingMs: resolver.getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
+            timedOut: error instanceof VoiceIOProviderTimeoutError
+          }, input);
+          if (!hasNextProvider || !shouldFallback) {
+            throw error;
+          }
+        }
+      }
+      throw lastError ?? new Error("Voice STT provider router did not open a provider.");
+    }
+  };
+};
+var createVoiceTTSProviderRouter = (options) => {
+  const resolver = createResolver(options);
+  return {
+    kind: "tts",
+    open: async (input) => {
+      const { order, selectedProvider } = await resolver.resolveOrder(input);
+      if (!selectedProvider || order.length === 0) {
+        throw new Error("Voice TTS provider router has no available providers.");
+      }
+      const emitter = createEmitter();
+      let activeSession;
+      let activeProvider;
+      let nextProviderIndex = 0;
+      const attach = (session) => {
+        session.on("audio", (event) => emitter.emit("audio", event));
+        session.on("error", (event) => emitter.emit("error", event));
+        session.on("close", (event) => emitter.emit("close", event));
+      };
+      const openProvider = async (provider, attempt) => {
+        const adapter = options.adapters[provider];
+        if (!adapter) {
+          throw new Error(`Voice TTS provider ${provider} is not configured.`);
+        }
+        const startedAt = Date.now();
+        const session = await withTimeout({
+          kind: "tts",
+          operation: "open",
+          provider,
+          run: () => adapter.open(input),
+          timeoutMs: getTimeoutMs(options, provider)
+        });
+        attach(session);
+        activeSession = session;
+        activeProvider = provider;
+        const providerHealth = resolver.recordSuccess(provider);
+        await resolver.emit({
+          at: Date.now(),
+          attempt,
+          elapsedMs: Date.now() - startedAt,
+          fallbackProvider: provider === selectedProvider ? undefined : provider,
+          kind: "tts",
+          latencyBudgetMs: getTimeoutMs(options, provider),
+          operation: "open",
+          provider,
+          providerHealth,
+          selectedProvider,
+          status: provider === selectedProvider ? "success" : "fallback"
+        }, input);
+        return session;
+      };
+      const failProvider = async (inputEvent) => {
+        const shouldFallback = options.isProviderError?.(inputEvent.error, inputEvent.provider) ?? true;
+        const providerHealth = resolver.recordError(inputEvent.provider, shouldFallback);
+        await resolver.emit({
+          at: Date.now(),
+          attempt: inputEvent.attempt,
+          elapsedMs: Date.now() - inputEvent.startedAt,
+          error: errorMessage2(inputEvent.error),
+          fallbackProvider: shouldFallback ? order[nextProviderIndex] : undefined,
+          kind: "tts",
+          latencyBudgetMs: getTimeoutMs(options, inputEvent.provider),
+          operation: inputEvent.operation,
+          provider: inputEvent.provider,
+          providerHealth,
+          selectedProvider,
+          status: "error",
+          suppressionRemainingMs: resolver.getSuppressionRemainingMs(inputEvent.provider),
+          suppressedUntil: providerHealth?.suppressedUntil,
+          timedOut: inputEvent.error instanceof VoiceIOProviderTimeoutError
+        }, input);
+        return shouldFallback;
+      };
+      for (const [index, provider] of order.entries()) {
+        nextProviderIndex = index + 1;
+        const startedAt = Date.now();
+        try {
+          await openProvider(provider, index + 1);
+          break;
+        } catch (error) {
+          const shouldFallback = await failProvider({
+            attempt: index + 1,
+            error,
+            operation: "open",
+            provider,
+            startedAt
+          });
+          if (!shouldFallback || index >= order.length - 1) {
+            throw error;
+          }
+        }
+      }
+      if (!activeSession || !activeProvider) {
+        throw new Error("Voice TTS provider router did not open a provider.");
+      }
+      const sendWithFallback = async (text) => {
+        for (;; ) {
+          const session = activeSession;
+          const provider = activeProvider;
+          if (!session || !provider) {
+            throw new Error("Voice TTS provider router has no active provider.");
+          }
+          const startedAt = Date.now();
+          try {
+            await withTimeout({
+              kind: "tts",
+              operation: "send",
+              provider,
+              run: () => session.send(text),
+              timeoutMs: getTimeoutMs(options, provider)
+            });
+            return;
+          } catch (error) {
+            const shouldFallback = await failProvider({
+              attempt: nextProviderIndex,
+              error,
+              operation: "send",
+              provider,
+              startedAt
+            });
+            const nextProvider = order[nextProviderIndex];
+            if (!shouldFallback || !nextProvider) {
+              throw error;
+            }
+            nextProviderIndex += 1;
+            await session.close("tts-provider-fallback").catch(() => {});
+            await openProvider(nextProvider, nextProviderIndex);
+          }
+        }
+      };
+      return {
+        close: async (reason) => {
+          await activeSession?.close(reason);
+          activeSession = undefined;
+          activeProvider = undefined;
+          await emitter.emit("close", {
+            reason,
+            type: "close"
+          });
+        },
+        on: emitter.on,
+        send: sendWithFallback
+      };
+    }
+  };
+};
 // src/sqliteStore.ts
 import { Database } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
@@ -10556,10 +10918,10 @@ var createVoiceOpsTaskProcessorWorker = (options) => ({
         result.completed += 1;
       } catch (error) {
         await options.onError?.(error, task);
-        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        const errorMessage3 = error instanceof Error ? error.message : String(error);
         const failedTask = failVoiceOpsTask(task, {
           actor: task.claimedBy ?? "ops-worker",
-          error: errorMessage2
+          error: errorMessage3
         });
         if (shouldDeadLetterTask(failedTask, options.maxFailures)) {
           const deadLetterTask = deadLetterVoiceOpsTask(failedTask, {
@@ -11886,6 +12248,7 @@ export {
   createVoiceTaskUpdatedEvent,
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
+  createVoiceTTSProviderRouter,
   createVoiceSessionsJSONHandler,
   createVoiceSessionsHTMLHandler,
   createVoiceSessionReplayRoutes,
@@ -11895,6 +12258,7 @@ export {
   createVoiceSessionListRoutes,
   createVoiceSession,
   createVoiceSTTRoutingCorrectionHandler,
+  createVoiceSTTProviderRouter,
   createVoiceSQLiteTraceSinkDeliveryStore,
   createVoiceSQLiteTraceEventStore,
   createVoiceSQLiteTaskStore,

package/dist/providerAdapters.d.ts

@@ -0,0 +1,37 @@
+import type { STTAdapter, STTAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from './types';
+import type { VoiceProviderRouterHealthOptions, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile } from './modelAdapters';
+type MaybePromise<T> = T | Promise<T>;
+type VoiceIOProviderKind = 'stt' | 'tts';
+type VoiceIOProviderStatus = 'error' | 'fallback' | 'success';
+export type VoiceIOProviderRouterEvent<TProvider extends string = string> = {
+    at: number;
+    attempt: number;
+    elapsedMs: number;
+    error?: string;
+    fallbackProvider?: TProvider;
+    kind: VoiceIOProviderKind;
+    latencyBudgetMs?: number;
+    operation: 'open' | 'send';
+    provider: TProvider;
+    providerHealth?: VoiceProviderRouterProviderHealth<TProvider>;
+    selectedProvider: TProvider;
+    status: VoiceIOProviderStatus;
+    suppressionRemainingMs?: number;
+    suppressedUntil?: number;
+    timedOut?: boolean;
+};
+export type VoiceIOProviderRouterOptions<TProvider extends string, TAdapter, TOpenOptions> = {
+    adapters: Partial<Record<TProvider, TAdapter>>;
+    fallback?: readonly TProvider[] | ((input: TOpenOptions) => MaybePromise<readonly TProvider[]>);
+    isProviderError?: (error: unknown, provider: TProvider) => boolean;
+    onProviderEvent?: (event: VoiceIOProviderRouterEvent<TProvider>, input: TOpenOptions) => Promise<void> | void;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
+    selectProvider?: (input: TOpenOptions) => MaybePromise<TProvider | undefined>;
+    timeoutMs?: number;
+};
+export type VoiceSTTProviderRouterOptions<TProvider extends string = string, TOptions extends STTAdapterOpenOptions = STTAdapterOpenOptions> = VoiceIOProviderRouterOptions<TProvider, STTAdapter<TOptions>, TOptions>;
+export type VoiceTTSProviderRouterOptions<TProvider extends string = string, TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions> = VoiceIOProviderRouterOptions<TProvider, TTSAdapter<TOptions>, TOptions>;
+export declare const createVoiceSTTProviderRouter: <TProvider extends string = string, TOptions extends STTAdapterOpenOptions = STTAdapterOpenOptions>(options: VoiceSTTProviderRouterOptions<TProvider, TOptions>) => STTAdapter<TOptions>;
+export declare const createVoiceTTSProviderRouter: <TProvider extends string = string, TOptions extends TTSAdapterOpenOptions = TTSAdapterOpenOptions>(options: VoiceTTSProviderRouterOptions<TProvider, TOptions>) => TTSAdapter<TOptions>;
+export {};

package/package.json

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