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

package/dist/angular/index.d.ts

@@ -1,2 +1,3 @@
 export { VoiceStreamService } from './voice-stream.service';
 export { VoiceControllerService } from './voice-controller.service';
+export { VoiceProviderStatusService } from './voice-provider-status.service';

package/dist/angular/index.js

@@ -1288,7 +1288,131 @@ VoiceControllerService = __decorateElement(_init, 0, "VoiceControllerService", _
 __runInitializers(_init, 1, VoiceControllerService);
 __decoratorMetadata(_init, VoiceControllerService);
 let _VoiceControllerService = VoiceControllerService;
+// src/angular/voice-provider-status.service.ts
+import { computed as computed3, Injectable as Injectable3, signal as signal3 } from "@angular/core";
+
+// src/client/providerStatus.ts
+var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    providers: []
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.providers;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const providers = await fetchVoiceProviderStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        providers,
+        updatedAt: Date.now()
+      };
+      emit();
+      return providers;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/angular/voice-provider-status.service.ts
+var _dec = [
+  Injectable3({ providedIn: "root" })
+];
+var _init = __decoratorStart(undefined);
+
+class VoiceProviderStatusService {
+  connect(path = "/api/provider-status", options = {}) {
+    const store = createVoiceProviderStatusStore(path, options);
+    const errorSignal = signal3(null);
+    const isLoadingSignal = signal3(false);
+    const providersSignal = signal3([]);
+    const updatedAtSignal = signal3(undefined);
+    const sync = () => {
+      const snapshot = store.getSnapshot();
+      errorSignal.set(snapshot.error);
+      isLoadingSignal.set(snapshot.isLoading);
+      providersSignal.set([...snapshot.providers]);
+      updatedAtSignal.set(snapshot.updatedAt);
+    };
+    const unsubscribe = store.subscribe(sync);
+    sync();
+    store.refresh().catch(() => {});
+    return {
+      close: () => {
+        unsubscribe();
+        store.close();
+      },
+      error: computed3(() => errorSignal()),
+      isLoading: computed3(() => isLoadingSignal()),
+      providers: computed3(() => providersSignal()),
+      refresh: store.refresh,
+      updatedAt: computed3(() => updatedAtSignal())
+    };
+  }
+}
+VoiceProviderStatusService = __decorateElement(_init, 0, "VoiceProviderStatusService", _dec, VoiceProviderStatusService);
+__runInitializers(_init, 1, VoiceProviderStatusService);
+__decoratorMetadata(_init, VoiceProviderStatusService);
+let _VoiceProviderStatusService = VoiceProviderStatusService;
 export {
   VoiceStreamService,
+  VoiceProviderStatusService,
   VoiceControllerService
 };

package/dist/angular/voice-provider-status.service.d.ts

@@ -0,0 +1,12 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export declare class VoiceProviderStatusService {
+    connect<TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions): {
+        close: () => void;
+        error: import("@angular/core").Signal<string | null>;
+        isLoading: import("@angular/core").Signal<boolean>;
+        providers: import("@angular/core").Signal<VoiceProviderHealthSummary<TProvider>[]>;
+        refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+        updatedAt: import("@angular/core").Signal<number | undefined>;
+    };
+}

package/dist/client/index.d.ts

@@ -5,3 +5,5 @@ export { createVoiceController } from './controller';
 export { bindVoiceBargeIn, createVoiceDuplexController } from './duplex';
 export { bindVoiceHTMX } from './htmx';
 export { createMicrophoneCapture } from './microphone';
+export { createVoiceProviderStatusStore, fetchVoiceProviderStatus } from './providerStatus';
+export type { VoiceProviderStatusClientOptions, VoiceProviderStatusSnapshot } from './providerStatus';

package/dist/client/index.js

@@ -1581,9 +1581,90 @@ var createVoiceDuplexController = (path, options = {}) => {
     }
   };
 };
+// src/client/providerStatus.ts
+var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    providers: []
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.providers;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const providers = await fetchVoiceProviderStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        providers,
+        updatedAt: Date.now()
+      };
+      emit();
+      return providers;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
 export {
+  fetchVoiceProviderStatus,
   decodeVoiceAudioChunk,
   createVoiceStream,
+  createVoiceProviderStatusStore,
   createVoiceDuplexController,
   createVoiceController,
   createVoiceConnection,

package/dist/client/providerStatus.d.ts

@@ -0,0 +1,19 @@
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export type VoiceProviderStatusClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+};
+export type VoiceProviderStatusSnapshot<TProvider extends string = string> = {
+    error: string | null;
+    isLoading: boolean;
+    providers: VoiceProviderHealthSummary<TProvider>[];
+    updatedAt?: number;
+};
+export declare const fetchVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: Pick<VoiceProviderStatusClientOptions, "fetch">) => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+export declare const createVoiceProviderStatusStore: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceProviderStatusSnapshot<TProvider>;
+    getSnapshot: () => VoiceProviderStatusSnapshot<TProvider>;
+    refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool } from '.
 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, createVoiceProviderRouter } from './modelAdapters';
+export { renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth } from './providerHealth';
 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';
@@ -27,6 +28,7 @@ export { createVoiceCallReviewFromLiveTelephonyReport, createVoiceCallReviewReco
 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, VoiceProviderRouterFallbackMode, VoiceProviderRouterHealthOptions, VoiceProviderRouterOptions, VoiceProviderRouterPolicy, VoiceProviderRouterProviderHealth, VoiceProviderRouterProviderProfile, VoiceJSONAssistantModelHandler, VoiceJSONAssistantModelOptions } from './modelAdapters';
+export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
 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

@@ -7265,6 +7265,21 @@ var createVoiceProviderRouter = (options) => {
     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;
@@ -7280,10 +7295,11 @@ var createVoiceProviderRouter = (options) => {
     health.consecutiveFailures = 0;
     health.status = "healthy";
     health.suppressedUntil = undefined;
+    return cloneHealth(provider);
   };
   const recordProviderError = (provider, isProviderError, rateLimited) => {
     if (!healthOptions || !isProviderError) {
-      return;
+      return cloneHealth(provider);
     }
     const currentTime = now();
     const health = getHealth(provider);
@@ -7296,6 +7312,7 @@ var createVoiceProviderRouter = (options) => {
       health.status = "suppressed";
       health.suppressedUntil = currentTime + (rateLimited ? rateLimitCooldownMs : cooldownMs);
     }
+    return cloneHealth(provider);
   };
   const resolveAllowedProviders = async (input) => {
     const allowProviders = policy?.allowProviders ?? options.allowProviders;
@@ -7361,12 +7378,13 @@ var createVoiceProviderRouter = (options) => {
         const startedAt = Date.now();
         try {
           const output = await model.generate(input);
-          recordProviderSuccess(provider);
+          const providerHealth = recordProviderSuccess(provider);
           await emit({
             at: Date.now(),
             elapsedMs: Date.now() - startedAt,
             fallbackProvider: provider === selectedProvider ? undefined : provider,
             provider,
+            providerHealth,
             recovered: provider !== selectedProvider,
             selectedProvider,
             status: provider === selectedProvider ? "success" : "fallback"
@@ -7378,7 +7396,7 @@ var createVoiceProviderRouter = (options) => {
           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 providerHealth = recordProviderError(provider, isProviderError, rateLimited);
           const nextProvider = hasNextProvider ? order[index + 1] : undefined;
           await emit({
             at: Date.now(),
@@ -7386,8 +7404,11 @@ var createVoiceProviderRouter = (options) => {
             error: errorMessage(error),
             fallbackProvider: shouldFallback ? nextProvider : undefined,
             provider,
+            providerHealth,
             rateLimited,
             selectedProvider,
+            suppressionRemainingMs: getSuppressionRemainingMs(provider),
+            suppressedUntil: providerHealth?.suppressedUntil,
             status: "error"
           }, input);
           if (!hasNextProvider || !shouldFallback) {
@@ -7834,6 +7855,166 @@ var createGeminiVoiceAssistantModel = (options) => {
     }
   };
 };
+// src/providerHealth.ts
+var getString = (value) => typeof value === "string" ? value : undefined;
+var getNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var isProviderStatus = (value) => value === "success" || value === "fallback" || value === "error";
+var summarizeVoiceProviderHealth = async (input) => {
+  const options = Array.isArray(input) ? { events: input } : input;
+  const events = options.events ?? await options.store?.list() ?? [];
+  const providers = options.providers ?? [];
+  const providerSet = new Set(providers);
+  const now = options.now ?? Date.now();
+  const entries = new Map;
+  const isAllowedProvider = (value) => typeof value === "string" && (providerSet.size === 0 || providerSet.has(value));
+  const getEntry = (provider) => {
+    const existing = entries.get(provider);
+    if (existing) {
+      return existing;
+    }
+    const entry = {
+      elapsedCount: 0,
+      elapsedTotal: 0,
+      errorCount: 0,
+      fallbackCount: 0,
+      provider,
+      rateLimited: false,
+      recommended: false,
+      runCount: 0,
+      status: "idle"
+    };
+    entries.set(provider, entry);
+    return entry;
+  };
+  for (const provider of providers) {
+    getEntry(provider);
+  }
+  const hasProviderRouterEvents = events.some((event) => event.type === "session.error" && isAllowedProvider(event.payload.provider) && isProviderStatus(event.payload.providerStatus));
+  for (const event of events) {
+    if (event.type === "assistant.run") {
+      if (hasProviderRouterEvents) {
+        continue;
+      }
+      const provider2 = event.payload.variantId;
+      if (!isAllowedProvider(provider2)) {
+        continue;
+      }
+      const entry2 = getEntry(provider2);
+      entry2.runCount += 1;
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      continue;
+    }
+    if (event.type !== "session.error") {
+      continue;
+    }
+    const provider = event.payload.provider;
+    if (!isAllowedProvider(provider)) {
+      continue;
+    }
+    const providerStatus = isProviderStatus(event.payload.providerStatus) ? event.payload.providerStatus : undefined;
+    const applyProviderHealth = () => {
+      const entry2 = getEntry(provider);
+      const providerHealth = event.payload.providerHealth;
+      if (providerHealth && typeof providerHealth === "object") {
+        const suppressedUntil2 = getNumber(providerHealth.suppressedUntil);
+        if (suppressedUntil2 !== undefined) {
+          entry2.suppressedUntil = suppressedUntil2;
+        }
+      }
+      const suppressedUntil = getNumber(event.payload.suppressedUntil);
+      if (suppressedUntil !== undefined) {
+        entry2.suppressedUntil = suppressedUntil;
+      }
+      const suppressionRemainingMs = getNumber(event.payload.suppressionRemainingMs);
+      if (suppressionRemainingMs !== undefined) {
+        entry2.suppressionRemainingMs = suppressionRemainingMs;
+      }
+      return entry2;
+    };
+    if (providerStatus === "success" || providerStatus === "fallback") {
+      const entry2 = applyProviderHealth();
+      entry2.runCount += 1;
+      entry2.lastSuccessAt = event.at;
+      if (providerStatus === "success") {
+        entry2.lastError = undefined;
+        entry2.rateLimited = false;
+        entry2.suppressedUntil = undefined;
+        entry2.suppressionRemainingMs = undefined;
+      }
+      const elapsedMs = getNumber(event.payload.elapsedMs);
+      if (elapsedMs !== undefined) {
+        entry2.elapsedCount += 1;
+        entry2.elapsedTotal += elapsedMs;
+      }
+      const selectedProvider = event.payload.selectedProvider;
+      if (providerStatus === "fallback" && isAllowedProvider(selectedProvider) && selectedProvider !== provider) {
+        getEntry(selectedProvider).fallbackCount += 1;
+      }
+      continue;
+    }
+    const entry = applyProviderHealth();
+    entry.errorCount += 1;
+    entry.lastError = getString(event.payload.error);
+    entry.lastErrorAt = event.at;
+    entry.rateLimited ||= event.payload.rateLimited === true;
+  }
+  const summaries = [...entries.values()].map((entry) => {
+    const hadSuppression = typeof entry.suppressedUntil === "number" || typeof entry.suppressionRemainingMs === "number";
+    const suppressionRemainingMs = typeof entry.suppressedUntil === "number" ? Math.max(0, entry.suppressedUntil - now) : entry.suppressionRemainingMs;
+    const activeSuppression = typeof suppressionRemainingMs === "number" && suppressionRemainingMs > 0;
+    const recoverable = hadSuppression && !activeSuppression;
+    const averageElapsedMs = entry.elapsedCount > 0 ? Math.round(entry.elapsedTotal / entry.elapsedCount) : undefined;
+    const status = activeSuppression ? "suppressed" : recoverable ? "recoverable" : entry.rateLimited ? "rate-limited" : entry.errorCount > 0 && (!entry.lastSuccessAt || !entry.lastErrorAt || entry.lastErrorAt > entry.lastSuccessAt) ? "degraded" : entry.runCount > 0 ? "healthy" : "idle";
+    return {
+      averageElapsedMs,
+      errorCount: entry.errorCount,
+      fallbackCount: entry.fallbackCount,
+      lastError: entry.lastError,
+      lastErrorAt: entry.lastErrorAt,
+      lastSuccessAt: entry.lastSuccessAt,
+      provider: entry.provider,
+      rateLimited: entry.rateLimited,
+      recommended: false,
+      runCount: entry.runCount,
+      status,
+      suppressionRemainingMs: activeSuppression ? suppressionRemainingMs : undefined,
+      suppressedUntil: entry.suppressedUntil
+    };
+  });
+  const recommended = summaries.filter((entry) => entry.status === "healthy").sort((left, right) => (left.averageElapsedMs ?? Number.MAX_SAFE_INTEGER) - (right.averageElapsedMs ?? Number.MAX_SAFE_INTEGER))[0];
+  if (recommended) {
+    recommended.recommended = true;
+  }
+  return summaries;
+};
+var escapeHtml4 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var renderVoiceProviderHealthHTML = (providers) => providers.length === 0 ? '<p class="voice-provider-empty">No provider status yet.</p>' : [
+  '<div class="voice-provider-health">',
+  ...providers.map((provider) => {
+    const suppressionSeconds = typeof provider.suppressionRemainingMs === "number" ? Math.ceil(provider.suppressionRemainingMs / 1000) : undefined;
+    return [
+      `<article class="voice-provider-card ${escapeHtml4(provider.status)}">`,
+      '<div class="voice-provider-card-header">',
+      `<strong>${escapeHtml4(provider.provider)}</strong>`,
+      `<span>${escapeHtml4(provider.status)}${provider.recommended ? " \xB7 recommended" : ""}</span>`,
+      "</div>",
+      "<dl>",
+      `<div><dt>Runs</dt><dd>${String(provider.runCount)}</dd></div>`,
+      `<div><dt>Avg latency</dt><dd>${String(provider.averageElapsedMs ?? 0)}ms</dd></div>`,
+      `<div><dt>Errors</dt><dd>${String(provider.errorCount)}</dd></div>`,
+      `<div><dt>Fallbacks</dt><dd>${String(provider.fallbackCount)}</dd></div>`,
+      "</dl>",
+      suppressionSeconds ? `<p>Temporarily suppressed for ${String(suppressionSeconds)}s.</p>` : "",
+      provider.lastError ? `<p>${escapeHtml4(provider.lastError)}</p>` : "",
+      "</article>"
+    ].join("");
+  }),
+  "</div>"
+].join("");
 // src/sqliteStore.ts
 import { Database } from "bun:sqlite";
 var normalizeTableNameSegment = (value) => value.trim().replace(/[^a-zA-Z0-9_]+/g, "_").replace(/^_+|_+$/g, "") || "voice";
@@ -10284,6 +10465,7 @@ export {
   transcodePCMToTwilioOutboundPayload,
   summarizeVoiceTraceSinkDeliveries,
   summarizeVoiceTrace,
+  summarizeVoiceProviderHealth,
   summarizeVoiceOpsTasks,
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
@@ -10307,6 +10489,7 @@ export {
   reopenVoiceOpsTask,
   renderVoiceTraceMarkdown,
   renderVoiceTraceHTML,
+  renderVoiceProviderHealthHTML,
   renderVoiceCallReviewMarkdown,
   renderVoiceCallReviewHTML,
   redactVoiceTraceText,

package/dist/modelAdapters.d.ts

@@ -40,9 +40,12 @@ export type VoiceProviderRouterEvent<TProvider extends string = string> = {
     error?: string;
     fallbackProvider?: TProvider;
     provider: TProvider;
+    providerHealth?: VoiceProviderRouterProviderHealth<TProvider>;
     rateLimited?: boolean;
     recovered?: boolean;
     selectedProvider: TProvider;
+    suppressionRemainingMs?: number;
+    suppressedUntil?: number;
     status: 'error' | 'fallback' | 'success';
 };
 export type VoiceProviderRouterFallbackMode = 'never' | 'provider-error' | 'rate-limit';

package/dist/providerHealth.d.ts

@@ -0,0 +1,25 @@
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceProviderHealthStatus = 'healthy' | 'idle' | 'rate-limited' | 'degraded' | 'recoverable' | 'suppressed';
+export type VoiceProviderHealthSummary<TProvider extends string = string> = {
+    averageElapsedMs?: number;
+    errorCount: number;
+    fallbackCount: number;
+    lastError?: string;
+    lastErrorAt?: number;
+    lastSuccessAt?: number;
+    provider: TProvider;
+    rateLimited: boolean;
+    recommended: boolean;
+    runCount: number;
+    status: VoiceProviderHealthStatus;
+    suppressionRemainingMs?: number;
+    suppressedUntil?: number;
+};
+export type VoiceProviderHealthSummaryOptions<TProvider extends string = string> = {
+    events?: StoredVoiceTraceEvent[];
+    now?: number;
+    providers?: readonly TProvider[];
+    store?: VoiceTraceEventStore;
+};
+export declare const summarizeVoiceProviderHealth: <TProvider extends string = string>(input: StoredVoiceTraceEvent[] | VoiceProviderHealthSummaryOptions<TProvider>) => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+export declare const renderVoiceProviderHealthHTML: (providers: VoiceProviderHealthSummary[]) => string;

package/dist/react/index.d.ts

@@ -1,2 +1,3 @@
 export { useVoiceStream } from './useVoiceStream';
 export { useVoiceController } from './useVoiceController';
+export { useVoiceProviderStatus } from './useVoiceProviderStatus';

package/dist/react/index.js

@@ -1234,7 +1234,107 @@ var useVoiceController = (path, options = {}) => {
     toggleRecording: () => controller.toggleRecording()
   };
 };
+// src/react/useVoiceProviderStatus.tsx
+import { useEffect as useEffect3, useRef as useRef3, useSyncExternalStore as useSyncExternalStore3 } from "react";
+
+// src/client/providerStatus.ts
+var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    providers: []
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.providers;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const providers = await fetchVoiceProviderStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        providers,
+        updatedAt: Date.now()
+      };
+      emit();
+      return providers;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/react/useVoiceProviderStatus.tsx
+var useVoiceProviderStatus = (path = "/api/provider-status", options = {}) => {
+  const storeRef = useRef3(null);
+  if (!storeRef.current) {
+    storeRef.current = createVoiceProviderStatusStore(path, options);
+  }
+  const store = storeRef.current;
+  useEffect3(() => {
+    store.refresh().catch(() => {});
+    return () => store.close();
+  }, [store]);
+  return {
+    ...useSyncExternalStore3(store.subscribe, store.getSnapshot, store.getServerSnapshot),
+    refresh: store.refresh
+  };
+};
 export {
   useVoiceStream,
+  useVoiceProviderStatus,
   useVoiceController
 };

package/dist/react/useVoiceProviderStatus.d.ts

@@ -0,0 +1,8 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+export declare const useVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+    refresh: () => Promise<import("..").VoiceProviderHealthSummary<TProvider>[]>;
+    error: string | null;
+    isLoading: boolean;
+    providers: import("..").VoiceProviderHealthSummary<TProvider>[];
+    updatedAt?: number;
+};

package/dist/svelte/createVoiceProviderStatus.d.ts

@@ -0,0 +1,8 @@
+import type { VoiceProviderStatusClientOptions } from '../client/providerStatus';
+export declare const createVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => import("../client").VoiceProviderStatusSnapshot<TProvider>;
+    getSnapshot: () => import("../client").VoiceProviderStatusSnapshot<TProvider>;
+    refresh: () => Promise<import("..").VoiceProviderHealthSummary<TProvider>[]>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/svelte/index.d.ts

@@ -1,2 +1,3 @@
 export { createVoiceStream } from './createVoiceStream';
+export { createVoiceProviderStatus } from './createVoiceProviderStatus';
 export { createVoiceController } from '../client/controller';

package/dist/svelte/index.js

@@ -548,6 +548,88 @@ var createVoiceStream = (path, options = {}) => {
 
 // src/svelte/createVoiceStream.ts
 var createVoiceStream2 = (path, options = {}) => createVoiceStream(path, options);
+// src/client/providerStatus.ts
+var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    providers: []
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.providers;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const providers = await fetchVoiceProviderStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        providers,
+        updatedAt: Date.now()
+      };
+      emit();
+      return providers;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/svelte/createVoiceProviderStatus.ts
+var createVoiceProviderStatus = (path = "/api/provider-status", options = {}) => createVoiceProviderStatusStore(path, options);
 // src/client/htmx.ts
 var DEFAULT_EVENT_NAME = "voice-refresh";
 var DEFAULT_QUERY_PARAM = "sessionId";
@@ -1173,5 +1255,6 @@ var createVoiceController = (path, options = {}) => {
 };
 export {
   createVoiceStream2 as createVoiceStream,
+  createVoiceProviderStatus,
   createVoiceController
 };

package/dist/vue/index.d.ts

@@ -1,2 +1,3 @@
 export { useVoiceStream } from './useVoiceStream';
 export { useVoiceController } from './useVoiceController';
+export { useVoiceProviderStatus } from './useVoiceProviderStatus';

package/dist/vue/index.js

@@ -1270,7 +1270,120 @@ var useVoiceController = (path, options = {}) => {
     turns
   };
 };
+// src/vue/useVoiceProviderStatus.ts
+import { onUnmounted as onUnmounted3, ref as ref3, shallowRef as shallowRef3 } from "vue";
+
+// src/client/providerStatus.ts
+var fetchVoiceProviderStatus = async (path = "/api/provider-status", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice provider status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceProviderStatusStore = (path = "/api/provider-status", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false,
+    providers: []
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.providers;
+    }
+    snapshot = {
+      ...snapshot,
+      error: null,
+      isLoading: true
+    };
+    emit();
+    try {
+      const providers = await fetchVoiceProviderStatus(path, options);
+      snapshot = {
+        error: null,
+        isLoading: false,
+        providers,
+        updatedAt: Date.now()
+      };
+      emit();
+      return providers;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+
+// src/vue/useVoiceProviderStatus.ts
+var useVoiceProviderStatus = (path = "/api/provider-status", options = {}) => {
+  const store = createVoiceProviderStatusStore(path, options);
+  const error = ref3(null);
+  const isLoading = ref3(false);
+  const providers = shallowRef3([]);
+  const updatedAt = ref3(undefined);
+  const sync = () => {
+    const snapshot = store.getSnapshot();
+    error.value = snapshot.error;
+    isLoading.value = snapshot.isLoading;
+    providers.value = [...snapshot.providers];
+    updatedAt.value = snapshot.updatedAt;
+  };
+  const unsubscribe = store.subscribe(sync);
+  sync();
+  store.refresh().catch(() => {});
+  onUnmounted3(() => {
+    unsubscribe();
+    store.close();
+  });
+  return {
+    error,
+    isLoading,
+    providers,
+    refresh: store.refresh,
+    updatedAt
+  };
+};
 export {
   useVoiceStream,
+  useVoiceProviderStatus,
   useVoiceController
 };

package/dist/vue/useVoiceProviderStatus.d.ts

@@ -0,0 +1,9 @@
+import { type VoiceProviderStatusClientOptions } from '../client/providerStatus';
+import type { VoiceProviderHealthSummary } from '../providerHealth';
+export declare const useVoiceProviderStatus: <TProvider extends string = string>(path?: string, options?: VoiceProviderStatusClientOptions) => {
+    error: import("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    providers: import("vue").ShallowRef<VoiceProviderHealthSummary<TProvider>[], VoiceProviderHealthSummary<TProvider>[]>;
+    refresh: () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+    updatedAt: import("vue").Ref<number | undefined, number | undefined>;
+};

package/package.json

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