@absolutejs/voice 0.0.22-beta.2 → 0.0.22-beta.21

package/dist/modelAdapters.d.ts

@@ -0,0 +1,93 @@
+import type { VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput } from './agent';
+import type { VoiceSessionRecord } from './types';
+export type VoiceJSONAssistantModelHandler<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = (input: VoiceAgentModelInput<TContext, TSession>) => Promise<Record<string, unknown> | VoiceAgentModelOutput<TResult>> | Record<string, unknown> | VoiceAgentModelOutput<TResult>;
+export type VoiceJSONAssistantModelOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    generate: VoiceJSONAssistantModelHandler<TContext, TSession, TResult>;
+    mapOutput?: (output: Record<string, unknown>) => VoiceAgentModelOutput<TResult>;
+};
+export type OpenAIVoiceAssistantModelOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    maxOutputTokens?: number;
+    model?: string;
+    onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
+    temperature?: number;
+};
+export type AnthropicVoiceAssistantModelOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    maxOutputTokens?: number;
+    model?: string;
+    onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
+    temperature?: number;
+    version?: string;
+};
+export type GeminiVoiceAssistantModelOptions = {
+    apiKey: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    maxOutputTokens?: number;
+    maxRetries?: number;
+    model?: string;
+    onUsage?: (usage: Record<string, unknown>) => Promise<void> | void;
+    temperature?: number;
+};
+export type VoiceProviderRouterEvent<TProvider extends string = string> = {
+    at: number;
+    elapsedMs: number;
+    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';
+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>;
+};
+export declare const createJSONVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceJSONAssistantModelOptions<TContext, TSession, TResult>) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createVoiceProviderRouter: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TProvider extends string = string>(options: VoiceProviderRouterOptions<TContext, TSession, TResult, TProvider>) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createOpenAIVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: OpenAIVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createAnthropicVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: AnthropicVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;
+export declare const createGeminiVoiceAssistantModel: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: GeminiVoiceAssistantModelOptions) => VoiceAgentModel<TContext, TSession, TResult>;

package/dist/providerHealth.d.ts

@@ -0,0 +1,78 @@
+import { Elysia } from 'elysia';
+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 type VoiceProviderHealthHandlerOptions<TProvider extends string = string> = VoiceProviderHealthSummaryOptions<TProvider>;
+export type VoiceProviderHealthHTMLHandlerOptions<TProvider extends string = string> = VoiceProviderHealthHandlerOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (providers: VoiceProviderHealthSummary<TProvider>[]) => string | Promise<string>;
+};
+export type VoiceProviderHealthRoutesOptions<TProvider extends string = string> = VoiceProviderHealthHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceProviderHealth: <TProvider extends string = string>(input: StoredVoiceTraceEvent[] | VoiceProviderHealthSummaryOptions<TProvider>) => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+export declare const renderVoiceProviderHealthHTML: (providers: VoiceProviderHealthSummary[]) => string;
+export declare const createVoiceProviderHealthJSONHandler: <TProvider extends string = string>(options: VoiceProviderHealthHandlerOptions<TProvider>) => () => Promise<VoiceProviderHealthSummary<TProvider>[]>;
+export declare const createVoiceProviderHealthHTMLHandler: <TProvider extends string = string>(options: VoiceProviderHealthHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceProviderHealthRoutes: <TProvider extends string = string>(options: VoiceProviderHealthRoutesOptions<TProvider>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceProviderHealthSummary<TProvider>[];
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

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/sessionReplay.d.ts

@@ -0,0 +1,94 @@
+import { Elysia } from 'elysia';
+import { type StoredVoiceTraceEvent, type VoiceTraceEvaluationOptions, type VoiceTraceEventStore, type VoiceTraceRedactionConfig, type VoiceTraceSummary, type VoiceTraceEvaluation } from './trace';
+export type VoiceSessionReplayTurn = {
+    assistantReplies: string[];
+    committedText?: string;
+    errors: Array<Record<string, unknown>>;
+    id: string;
+    modelCalls: Array<Record<string, unknown>>;
+    tools: Array<Record<string, unknown>>;
+    transcripts: Array<{
+        isFinal: boolean;
+        text?: string;
+    }>;
+};
+export type VoiceSessionReplay = {
+    evaluation: VoiceTraceEvaluation;
+    events: StoredVoiceTraceEvent[];
+    html: string;
+    markdown: string;
+    sessionId: string;
+    summary: VoiceTraceSummary;
+    timeline: Array<{
+        at: number;
+        offsetMs?: number;
+        payload: Record<string, unknown>;
+        turnId?: string;
+        type: StoredVoiceTraceEvent['type'];
+    }>;
+    turns: VoiceSessionReplayTurn[];
+};
+export type VoiceSessionReplayOptions = {
+    evaluation?: VoiceTraceEvaluationOptions;
+    events?: StoredVoiceTraceEvent[];
+    redact?: VoiceTraceRedactionConfig;
+    sessionId: string;
+    store?: VoiceTraceEventStore;
+    title?: string;
+};
+export type VoiceSessionReplayHTMLHandlerOptions = Omit<VoiceSessionReplayOptions, 'sessionId'> & {
+    headers?: HeadersInit;
+    render?: (replay: VoiceSessionReplay) => string | Promise<string>;
+};
+export type VoiceSessionReplayRoutesOptions = VoiceSessionReplayHTMLHandlerOptions & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceSessionReplay: (options: VoiceSessionReplayOptions) => Promise<VoiceSessionReplay>;
+export declare const createVoiceSessionReplayJSONHandler: (options: Omit<VoiceSessionReplayOptions, "sessionId">) => ({ params }: {
+    params: Record<string, string | undefined>;
+}) => Promise<VoiceSessionReplay>;
+export declare const createVoiceSessionReplayHTMLHandler: (options: VoiceSessionReplayHTMLHandlerOptions) => ({ params }: {
+    params: Record<string, string | undefined>;
+}) => Promise<Response>;
+export declare const createVoiceSessionReplayRoutes: (options: VoiceSessionReplayRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceSessionReplay;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

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/testing/index.d.ts

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