@absolutejs/voice 0.0.22-beta.11 → 0.0.22-beta.13

package/dist/index.d.ts

@@ -26,7 +26,7 @@ export { resolveTurnDetectionConfig, TURN_PROFILE_DEFAULTS } from './turnProfile
 export { createVoiceCallReviewFromLiveTelephonyReport, createVoiceCallReviewRecorder, renderVoiceCallReviewHTML, renderVoiceCallReviewMarkdown } from './testing/review';
 export type { VoiceAssistant, VoiceAssistantArtifactPlan, VoiceAssistantExperiment, VoiceAssistantExperimentOptions, VoiceAssistantGuardrailInput, VoiceAssistantGuardrails, VoiceAssistantMemoryLifecycle, VoiceAssistantMemoryLifecycleInput, VoiceAssistantOptions, VoiceAssistantOutputGuardrailInput, VoiceAssistantPreset, VoiceAssistantRunsSummary, VoiceAssistantRunSummary, VoiceAssistantVariant } from './assistant';
 export type { VoiceAssistantMemoryBinding, VoiceAssistantMemoryHandle, VoiceAssistantMemoryOptions, VoiceAssistantMemoryRecord, VoiceAssistantMemoryStore } from './assistantMemory';
-export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterOptions, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
+export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOptions, OpenAIVoiceAssistantModelOptions, VoiceProviderRouterEvent, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
 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

@@ -7241,18 +7241,98 @@ var createJSONVoiceAssistantModel = (options) => ({
 var createVoiceProviderRouter = (options) => {
   const providerIds = Object.keys(options.providers);
   const firstProvider = providerIds[0];
+  const policy = typeof options.policy === "string" ? {
+    strategy: options.policy
+  } : options.policy;
+  const strategy = policy?.strategy ?? "prefer-selected";
+  const fallbackMode = policy?.fallbackMode ?? options.fallbackMode ?? "provider-error";
+  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 rateLimitCooldownMs = Math.max(0, healthOptions?.rateLimitCooldownMs ?? 60000);
+  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 isSuppressed = (provider) => {
+    if (!healthOptions) {
+      return false;
+    }
+    const health = getHealth(provider);
+    return typeof health.suppressedUntil === "number" && health.suppressedUntil > now();
+  };
+  const recordProviderSuccess = (provider) => {
+    if (!healthOptions) {
+      return;
+    }
+    const health = getHealth(provider);
+    health.consecutiveFailures = 0;
+    health.status = "healthy";
+    health.suppressedUntil = undefined;
+  };
+  const recordProviderError = (provider, isProviderError, rateLimited) => {
+    if (!healthOptions || !isProviderError) {
+      return;
+    }
+    const currentTime = now();
+    const health = getHealth(provider);
+    health.consecutiveFailures += 1;
+    health.lastFailureAt = currentTime;
+    if (rateLimited) {
+      health.lastRateLimitedAt = currentTime;
+    }
+    if (rateLimited || health.consecutiveFailures >= failureThreshold) {
+      health.status = "suppressed";
+      health.suppressedUntil = currentTime + (rateLimited ? rateLimitCooldownMs : cooldownMs);
+    }
+  };
+  const resolveAllowedProviders = async (input) => {
+    const allowProviders = policy?.allowProviders ?? options.allowProviders;
+    const allowed = typeof allowProviders === "function" ? await allowProviders(input) : allowProviders;
+    return new Set(allowed ?? providerIds);
+  };
+  const sortProviders = (providers) => {
+    if (strategy !== "prefer-cheapest" && strategy !== "prefer-fastest") {
+      return providers;
+    }
+    return [...providers].sort((left, right) => {
+      const leftProfile = options.providerProfiles?.[left];
+      const rightProfile = options.providerProfiles?.[right];
+      const leftValue = strategy === "prefer-cheapest" ? leftProfile?.cost ?? Number.MAX_SAFE_INTEGER : leftProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      const rightValue = strategy === "prefer-cheapest" ? rightProfile?.cost ?? Number.MAX_SAFE_INTEGER : rightProfile?.latencyMs ?? Number.MAX_SAFE_INTEGER;
+      return leftValue - rightValue || (leftProfile?.priority ?? Number.MAX_SAFE_INTEGER) - (rightProfile?.priority ?? Number.MAX_SAFE_INTEGER);
+    });
+  };
   const resolveOrder = async (input) => {
     const selectedProvider = await options.selectProvider?.(input);
+    const allowedProviders = await resolveAllowedProviders(input);
     const fallbackOrder = typeof options.fallback === "function" ? await options.fallback(input) : options.fallback;
-    const preferred = selectedProvider ?? fallbackOrder?.[0] ?? firstProvider;
+    const rankedProviders = sortProviders([
+      ...fallbackOrder ?? providerIds
+    ]).filter((provider) => allowedProviders.has(provider));
+    const healthyRankedProviders = healthOptions ? rankedProviders.filter((provider) => !isSuppressed(provider)) : rankedProviders;
+    const candidateRankedProviders = healthyRankedProviders.length ? healthyRankedProviders : rankedProviders;
+    const preferred = selectedProvider && allowedProviders.has(selectedProvider) && (!healthOptions || !isSuppressed(selectedProvider)) ? selectedProvider : candidateRankedProviders[0] ?? firstProvider;
     const seen = new Set;
     const order = [];
-    for (const provider of [
+    const candidates = strategy === "ordered" ? candidateRankedProviders : [
       preferred,
-      ...fallbackOrder ?? [],
-      ...providerIds
-    ]) {
-      if (!provider || seen.has(provider) || !options.providers[provider]) {
+      ...candidateRankedProviders,
+      ...providerIds.filter((provider) => !healthOptions || !isSuppressed(provider))
+    ];
+    for (const provider of candidates) {
+      if (!provider || seen.has(provider) || !allowedProviders.has(provider) || !options.providers[provider]) {
         continue;
       }
       seen.add(provider);
@@ -7281,6 +7361,7 @@ var createVoiceProviderRouter = (options) => {
         const startedAt = Date.now();
         try {
           const output = await model.generate(input);
+          recordProviderSuccess(provider);
           await emit({
             at: Date.now(),
             elapsedMs: Date.now() - startedAt,
@@ -7295,18 +7376,21 @@ var createVoiceProviderRouter = (options) => {
           lastError = error;
           const hasNextProvider = index < order.length - 1;
           const isProviderError = options.isProviderError?.(error, provider) ?? true;
+          const rateLimited = options.isRateLimitError?.(error, provider) ?? defaultIsRateLimitError(error);
+          const shouldFallback = fallbackMode === "provider-error" ? isProviderError : fallbackMode === "rate-limit" ? isProviderError && rateLimited : false;
+          recordProviderError(provider, isProviderError, rateLimited);
           const nextProvider = hasNextProvider ? order[index + 1] : undefined;
           await emit({
             at: Date.now(),
             elapsedMs: Date.now() - startedAt,
             error: errorMessage(error),
-            fallbackProvider: isProviderError ? nextProvider : undefined,
+            fallbackProvider: shouldFallback ? nextProvider : undefined,
             provider,
-            rateLimited: options.isRateLimitError?.(error, provider) ?? defaultIsRateLimitError(error),
+            rateLimited,
             selectedProvider,
             status: "error"
           }, input);
-          if (!hasNextProvider || !isProviderError) {
+          if (!hasNextProvider || !shouldFallback) {
             throw error;
           }
         }

package/dist/modelAdapters.d.ts

@@ -45,11 +45,41 @@ export type VoiceProviderRouterEvent<TProvider extends string = string> = {
     selectedProvider: TProvider;
     status: 'error' | 'fallback' | 'success';
 };
+export type VoiceProviderRouterFallbackMode = 'never' | 'provider-error' | 'rate-limit';
+export type VoiceProviderRouterPolicy<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TProvider extends string = string> = 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected' | {
+    allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    fallbackMode?: VoiceProviderRouterFallbackMode;
+    strategy?: 'ordered' | 'prefer-cheapest' | 'prefer-fastest' | 'prefer-selected';
+};
+export type VoiceProviderRouterProviderProfile = {
+    cost?: number;
+    latencyMs?: number;
+    priority?: number;
+};
+export type VoiceProviderRouterHealthOptions = {
+    cooldownMs?: number;
+    failureThreshold?: number;
+    now?: () => number;
+    rateLimitCooldownMs?: number;
+};
+export type VoiceProviderRouterProviderHealth<TProvider extends string = string> = {
+    consecutiveFailures: number;
+    lastFailureAt?: number;
+    lastRateLimitedAt?: number;
+    provider: TProvider;
+    status: 'healthy' | 'suppressed';
+    suppressedUntil?: number;
+};
 export type VoiceProviderRouterOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TProvider extends string = string> = {
+    allowProviders?: readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
     fallback?: TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    fallbackMode?: VoiceProviderRouterFallbackMode;
     isProviderError?: (error: unknown, provider: TProvider) => boolean;
     isRateLimitError?: (error: unknown, provider: TProvider) => boolean;
     onProviderEvent?: (event: VoiceProviderRouterEvent<TProvider>, input: VoiceAgentModelInput<TContext, TSession>) => Promise<void> | void;
+    policy?: VoiceProviderRouterPolicy<TContext, TSession, TProvider>;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerProfiles?: Partial<Record<TProvider, VoiceProviderRouterProviderProfile>>;
     providers: Partial<Record<TProvider, VoiceAgentModel<TContext, TSession, TResult>>>;
     selectProvider?: (input: VoiceAgentModelInput<TContext, TSession>) => TProvider | undefined | Promise<TProvider | undefined>;
 };

package/package.json

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