@absolutejs/voice 0.0.22-beta.33 → 0.0.22-beta.35

package/dist/index.js

@@ -8911,21 +8911,86 @@ var withTimeout = async (input) => {
 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 order = candidates.filter((provider) => {
+    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: selectedProvider && !isSuppressed(selectedProvider) ? selectedProvider : order[0]
     };
   };
   const emit = async (event, input) => {
@@ -8933,7 +8998,10 @@ var createResolver = (options) => {
   };
   return {
     emit,
+    getSuppressionRemainingMs,
     providerIds,
+    recordError,
+    recordSuccess,
     resolveOrder
   };
 };
@@ -8961,6 +9029,7 @@ var createVoiceSTTProviderRouter = (options) => {
             run: () => adapter.open(input),
             timeoutMs: getTimeoutMs(options, provider)
           });
+          const providerHealth = resolver.recordSuccess(provider);
           await resolver.emit({
             at: Date.now(),
             attempt: index + 1,
@@ -8970,6 +9039,7 @@ var createVoiceSTTProviderRouter = (options) => {
             latencyBudgetMs: getTimeoutMs(options, provider),
             operation: "open",
             provider,
+            providerHealth,
             selectedProvider,
             status: provider === selectedProvider ? "success" : "fallback"
           }, input);
@@ -8978,6 +9048,7 @@ var createVoiceSTTProviderRouter = (options) => {
           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,
@@ -8988,8 +9059,11 @@ var createVoiceSTTProviderRouter = (options) => {
             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) {
@@ -9035,6 +9109,7 @@ var createVoiceTTSProviderRouter = (options) => {
         attach(session);
         activeSession = session;
         activeProvider = provider;
+        const providerHealth = resolver.recordSuccess(provider);
         await resolver.emit({
           at: Date.now(),
           attempt,
@@ -9044,6 +9119,7 @@ var createVoiceTTSProviderRouter = (options) => {
           latencyBudgetMs: getTimeoutMs(options, provider),
           operation: "open",
           provider,
+          providerHealth,
           selectedProvider,
           status: provider === selectedProvider ? "success" : "fallback"
         }, input);
@@ -9051,6 +9127,7 @@ var createVoiceTTSProviderRouter = (options) => {
       };
       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,
@@ -9061,8 +9138,11 @@ var createVoiceTTSProviderRouter = (options) => {
           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;

package/dist/providerAdapters.d.ts

@@ -1,5 +1,5 @@
 import type { STTAdapter, STTAdapterOpenOptions, TTSAdapter, TTSAdapterOpenOptions } from './types';
-import type { VoiceProviderRouterProviderProfile } from './modelAdapters';
+import type { VoiceProviderRouterHealthOptions, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile } from './modelAdapters';
 type MaybePromise<T> = T | Promise<T>;
 type VoiceIOProviderKind = 'stt' | 'tts';
 type VoiceIOProviderStatus = 'error' | 'fallback' | 'success';
@@ -13,8 +13,11 @@ export type VoiceIOProviderRouterEvent<TProvider extends string = string> = {
     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> = {
@@ -22,6 +25,7 @@ export type VoiceIOProviderRouterOptions<TProvider extends string, TAdapter, TOp
     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;

package/dist/testing/index.d.ts

@@ -3,6 +3,7 @@ export * from './benchmark';
 export * from './corrected';
 export * from './duplex';
 export * from './fixtures';
+export * from './ioProviderSimulator';
 export * from './providerSimulator';
 export * from './resilience';
 export * from './review';

package/dist/testing/index.js

@@ -3510,6 +3510,123 @@ var loadVoiceTestFixtures = async (fixtureDirectory) => {
   }
   return fixtures;
 };
+// src/testing/ioProviderSimulator.ts
+var defaultFailureMessage = (input) => `Simulated ${input.provider} ${input.kind.toUpperCase()} ${input.operation} failure.`;
+var resolveRecoveryElapsedMs = (value, provider) => {
+  if (typeof value === "number") {
+    return value;
+  }
+  return value?.[provider] ?? 25;
+};
+var createHealth = (input) => ({
+  consecutiveFailures: input.status === "healthy" ? 0 : 1,
+  lastFailureAt: input.status === "healthy" ? undefined : input.now,
+  provider: input.provider,
+  status: input.status,
+  suppressedUntil: input.suppressedUntil
+});
+var resolveFallback = async (options, provider) => {
+  const configured = typeof options.fallback === "function" ? await options.fallback(provider) : options.fallback;
+  return (configured ?? options.providers).find((candidate) => candidate !== provider);
+};
+var createVoiceIOProviderFailureSimulator = (options) => {
+  if (options.providers.length === 0) {
+    throw new Error("At least one provider is required.");
+  }
+  const now = options.now ?? Date.now;
+  const operation = options.operation ?? "open";
+  const cooldownMs = Math.max(0, options.cooldownMs ?? 30000);
+  const emit = async (event) => {
+    await options.onProviderEvent?.(event);
+  };
+  const run = async (provider, mode) => {
+    if (!options.providers.includes(provider)) {
+      throw new Error(`${provider} is not configured for simulation.`);
+    }
+    const startedAt = now();
+    const sessionId = options.sessionId?.({ mode, now: startedAt, provider }) ?? `${options.kind}-provider-sim-${startedAt}`;
+    if (mode === "recovery") {
+      await emit({
+        at: startedAt,
+        attempt: 0,
+        elapsedMs: resolveRecoveryElapsedMs(options.recoveryElapsedMs, provider),
+        kind: options.kind,
+        latencyBudgetMs: options.latencyBudgets?.[provider],
+        operation,
+        provider,
+        providerHealth: createHealth({
+          now: startedAt,
+          provider,
+          status: "healthy"
+        }),
+        selectedProvider: provider,
+        status: "success"
+      });
+      return {
+        mode,
+        provider,
+        sessionId,
+        status: "simulated"
+      };
+    }
+    const fallbackProvider = await resolveFallback(options, provider);
+    const suppressedUntil = startedAt + cooldownMs;
+    await emit({
+      at: startedAt,
+      attempt: 0,
+      elapsedMs: options.failureElapsedMs ?? 10,
+      error: (options.failureMessage ?? defaultFailureMessage)({
+        kind: options.kind,
+        operation,
+        provider
+      }),
+      fallbackProvider,
+      kind: options.kind,
+      latencyBudgetMs: options.latencyBudgets?.[provider],
+      operation,
+      provider,
+      providerHealth: createHealth({
+        now: startedAt,
+        provider,
+        status: "suppressed",
+        suppressedUntil
+      }),
+      selectedProvider: provider,
+      status: "error",
+      suppressedUntil
+    });
+    if (fallbackProvider) {
+      await emit({
+        at: startedAt + 1,
+        attempt: 1,
+        elapsedMs: resolveRecoveryElapsedMs(options.recoveryElapsedMs, fallbackProvider),
+        fallbackProvider,
+        kind: options.kind,
+        latencyBudgetMs: options.latencyBudgets?.[fallbackProvider],
+        operation,
+        provider: fallbackProvider,
+        providerHealth: createHealth({
+          now: startedAt + 1,
+          provider: fallbackProvider,
+          status: "healthy"
+        }),
+        selectedProvider: provider,
+        status: "fallback"
+      });
+    }
+    return {
+      fallbackProvider,
+      mode,
+      provider,
+      sessionId,
+      status: "simulated",
+      suppressedUntil
+    };
+  };
+  return {
+    run
+  };
+};
 // src/modelAdapters.ts
 var OUTPUT_SCHEMA = {
   additionalProperties: false,
@@ -8551,6 +8668,7 @@ export {
   getDefaultTTSBenchmarkFixtures,
   evaluateSTTBenchmarkAcceptance,
   createVoiceProviderFailureSimulator,
+  createVoiceIOProviderFailureSimulator,
   createVoiceCallReviewRecorder,
   createVoiceCallReviewFromLiveTelephonyReport,
   createTelephonyVoiceTestFixtures,

package/dist/testing/ioProviderSimulator.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceIOProviderRouterEvent } from '../providerAdapters';
+export type VoiceIOProviderFailureSimulationMode = 'failure' | 'recovery';
+export type VoiceIOProviderFailureSimulationKind = 'stt' | 'tts';
+export type VoiceIOProviderFailureSimulationOperation = 'open' | 'send';
+export type VoiceIOProviderFailureSimulationResult<TProvider extends string = string> = {
+    fallbackProvider?: TProvider;
+    mode: VoiceIOProviderFailureSimulationMode;
+    provider: TProvider;
+    sessionId: string;
+    status: 'simulated';
+    suppressedUntil?: number;
+};
+export type VoiceIOProviderFailureSimulatorOptions<TProvider extends string = string> = {
+    cooldownMs?: number;
+    fallback?: readonly TProvider[] | ((provider: TProvider) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    failureElapsedMs?: number;
+    failureMessage?: (input: {
+        kind: VoiceIOProviderFailureSimulationKind;
+        operation: VoiceIOProviderFailureSimulationOperation;
+        provider: TProvider;
+    }) => string;
+    kind: VoiceIOProviderFailureSimulationKind;
+    latencyBudgets?: Partial<Record<TProvider, number>>;
+    now?: () => number;
+    onProviderEvent?: (event: VoiceIOProviderRouterEvent<TProvider>) => Promise<void> | void;
+    operation?: VoiceIOProviderFailureSimulationOperation;
+    providers: readonly TProvider[];
+    recoveryElapsedMs?: number | Partial<Record<TProvider, number>>;
+    sessionId?: (input: {
+        mode: VoiceIOProviderFailureSimulationMode;
+        now: number;
+        provider: TProvider;
+    }) => string;
+};
+export declare const createVoiceIOProviderFailureSimulator: <TProvider extends string>(options: VoiceIOProviderFailureSimulatorOptions<TProvider>) => {
+    run: (provider: TProvider, mode: VoiceIOProviderFailureSimulationMode) => Promise<VoiceIOProviderFailureSimulationResult<TProvider>>;
+};

package/package.json

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