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

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/package.json

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