@absolutejs/voice 0.0.22-beta.3 → 0.0.22-beta.30

package/dist/testing/providerSimulator.d.ts

@@ -0,0 +1,44 @@
+import type { VoiceAgentModelInput, VoiceAgentModelOutput } from '../agent';
+import type { VoiceSessionRecord } from '../types';
+import type { VoiceProviderRouterEvent, VoiceProviderRouterHealthOptions } from '../modelAdapters';
+export type VoiceProviderFailureSimulationMode = 'failure' | 'recovery';
+export type VoiceProviderFailureSimulationContext<TProvider extends string = string> = {
+    query: {
+        provider: TProvider;
+        recoverProvider?: TProvider;
+        simulateFailureProvider?: TProvider;
+    };
+};
+export type VoiceProviderFailureSimulationResult<TProvider extends string = string, TResult = unknown> = {
+    mode: VoiceProviderFailureSimulationMode;
+    provider: TProvider;
+    replayHref?: string;
+    result: VoiceAgentModelOutput<TResult>;
+    sessionId: string;
+    status: 'simulated';
+    turnId: string;
+};
+type ProviderListResolver<TContext, TSession extends VoiceSessionRecord, TProvider extends string> = readonly TProvider[] | ((input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+export type VoiceProviderFailureSimulatorOptions<TContext extends VoiceProviderFailureSimulationContext<TProvider>, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown, TProvider extends string = string> = {
+    allowProviders?: ProviderListResolver<TContext, TSession, TProvider>;
+    fallback?: readonly TProvider[] | ((provider: TProvider, input: VoiceAgentModelInput<TContext, TSession>) => readonly TProvider[] | Promise<readonly TProvider[]>);
+    isProviderError?: (error: unknown, provider: TProvider) => boolean;
+    isRateLimitError?: (error: unknown, provider: TProvider) => boolean;
+    onProviderEvent?: (event: VoiceProviderRouterEvent<TProvider>, input: VoiceAgentModelInput<TContext, TSession>) => Promise<void> | void;
+    providerHealth?: boolean | VoiceProviderRouterHealthOptions;
+    providerLabel?: (provider: TProvider) => string;
+    providers: readonly TProvider[];
+    replayHref?: false | string | ((input: {
+        provider: TProvider;
+        sessionId: string;
+        turnId: string;
+    }) => string);
+    response?: (input: {
+        mode: VoiceProviderFailureSimulationMode;
+        provider: TProvider;
+    } & VoiceAgentModelInput<TContext, TSession>) => VoiceAgentModelOutput<TResult> | Promise<VoiceAgentModelOutput<TResult>>;
+};
+export declare const createVoiceProviderFailureSimulator: <TProvider extends string, TResult = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TContext extends VoiceProviderFailureSimulationContext<TProvider> = VoiceProviderFailureSimulationContext<TProvider>>(options: VoiceProviderFailureSimulatorOptions<TContext, TSession, TResult, TProvider>) => {
+    run: (provider: TProvider, mode: VoiceProviderFailureSimulationMode) => Promise<VoiceProviderFailureSimulationResult<TProvider, TResult>>;
+};
+export {};

package/dist/trace.d.ts

@@ -1,4 +1,4 @@
-export type VoiceTraceEventType = 'assistant.guardrail' | 'assistant.run' | 'agent.handoff' | 'agent.model' | 'agent.result' | 'agent.tool' | 'call.lifecycle' | 'session.error' | 'turn.assistant' | 'turn.committed' | 'turn.cost' | 'turn.transcript';
+export type VoiceTraceEventType = 'assistant.guardrail' | 'assistant.memory' | 'assistant.run' | 'agent.handoff' | 'agent.model' | 'agent.result' | 'agent.tool' | 'call.handoff' | 'call.lifecycle' | 'session.error' | 'turn.assistant' | 'turn.committed' | 'turn.cost' | 'turn.transcript';
 export type VoiceTraceEvent<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
     at: number;
     id?: string;

package/dist/types.d.ts

@@ -269,6 +269,35 @@ export type VoiceCallLifecycleState = {
     lastEventAt: number;
     startedAt: number;
 };
+export type VoiceHandoffAction = 'escalate' | 'no-answer' | 'transfer' | 'voicemail';
+export type VoiceHandoffStatus = 'delivered' | 'failed' | 'skipped';
+export type VoiceHandoffResult = {
+    deliveredAt?: number;
+    deliveredTo?: string;
+    error?: string;
+    metadata?: Record<string, unknown>;
+    status: VoiceHandoffStatus;
+};
+export type VoiceHandoffInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    action: VoiceHandoffAction;
+    api: VoiceSessionHandle<TContext, TSession, TResult>;
+    context: TContext;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    result?: TResult;
+    session: TSession;
+    target?: string;
+};
+export type VoiceHandoffAdapter<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    actions?: VoiceHandoffAction[];
+    handoff: (input: VoiceHandoffInput<TContext, TSession, TResult>) => Promise<VoiceHandoffResult> | VoiceHandoffResult;
+    id: string;
+    kind?: string;
+};
+export type VoiceHandoffConfig<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    adapters: VoiceHandoffAdapter<TContext, TSession, TResult>[];
+    failMode?: 'record' | 'throw';
+};
 export type VoiceSessionStore<TSession extends VoiceSessionRecord = VoiceSessionRecord> = SessionStore<TSession, VoiceSessionSummary>;
 export type VoiceLogger = {
     debug?: (message: string, meta?: Record<string, unknown>) => void;
@@ -567,6 +596,7 @@ export type VoicePluginConfig<TContext = unknown, TSession extends VoiceSessionR
     audioConditioning?: VoiceAudioConditioningConfig;
     logger?: VoiceLogger;
     htmx?: boolean | VoiceHTMXConfig<TSession, NoInfer<TResult>>;
+    handoff?: VoiceHandoffConfig<TContext, TSession, TResult>;
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
     trace?: VoiceTraceEventStore;
 } & VoiceRouteConfig<TContext, TSession, TResult>;
@@ -588,6 +618,7 @@ export type CreateVoiceSessionOptions<TContext = unknown, TSession extends Voice
     sttLifecycle: VoiceSTTLifecycle;
     turnDetection: VoiceResolvedTurnDetectionConfig;
     audioConditioning?: VoiceResolvedAudioConditioningConfig;
+    handoff?: VoiceHandoffConfig<TContext, TSession, TResult>;
     route: VoiceNormalizedRouteConfig<TContext, TSession, TResult>;
     logger?: VoiceLogger;
 };
@@ -604,10 +635,17 @@ export type VoiceClientCloseMessage = {
     type: 'close';
     reason?: string;
 };
+export type VoiceClientCallControlMessage = {
+    type: 'call_control';
+    action: 'complete' | 'escalate' | 'no-answer' | 'transfer' | 'voicemail';
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    target?: string;
+};
 export type VoiceClientPingMessage = {
     type: 'ping';
 };
-export type VoiceClientMessage = VoiceClientStartMessage | VoiceClientEndTurnMessage | VoiceClientCloseMessage | VoiceClientPingMessage;
+export type VoiceClientMessage = VoiceClientStartMessage | VoiceClientEndTurnMessage | VoiceClientCloseMessage | VoiceClientCallControlMessage | VoiceClientPingMessage;
 export type VoiceServerSessionMessage = {
     type: 'session';
     sessionId: string;
@@ -642,6 +680,11 @@ export type VoiceServerCompleteMessage = {
     type: 'complete';
     sessionId: string;
 };
+export type VoiceServerCallLifecycleMessage = {
+    type: 'call_lifecycle';
+    event: VoiceCallLifecycleEvent;
+    sessionId: string;
+};
 export type VoiceServerErrorMessage = {
     type: 'error';
     message: string;
@@ -650,7 +693,7 @@ export type VoiceServerErrorMessage = {
 export type VoiceServerPongMessage = {
     type: 'pong';
 };
-export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerAudioMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage;
+export type VoiceServerMessage<TResult = unknown> = VoiceServerSessionMessage | VoiceServerPartialMessage | VoiceServerFinalMessage | VoiceServerTurnMessage<TResult> | VoiceServerAssistantMessage | VoiceServerAudioMessage | VoiceServerCallLifecycleMessage | VoiceServerCompleteMessage | VoiceServerErrorMessage | VoiceServerPongMessage;
 export type VoiceConnectionOptions = {
     protocols?: string[];
     scenarioId?: string;
@@ -728,6 +771,7 @@ export type VoiceHTMXOptions<TSession extends VoiceSessionRecord = VoiceSessionR
 };
 export type VoiceHTMXConfig<TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceHTMXRenderer<TSession, TResult> | VoiceHTMXOptions<TSession, TResult>;
 export type VoiceStreamState<TResult = unknown> = {
+    call: VoiceCallLifecycleState | null;
     sessionId: string | null;
     scenarioId: string | null;
     status: VoiceSessionStatus | 'idle';
@@ -744,6 +788,8 @@ export type VoiceStreamState<TResult = unknown> = {
     isConnected: boolean;
 };
 export type VoiceStream<TResult = unknown> = {
+    call: VoiceCallLifecycleState | null;
+    callControl: (message: Omit<VoiceClientCallControlMessage, 'type'>) => void;
     close: () => void;
     start: (input?: {
         scenarioId?: string;
@@ -810,6 +856,8 @@ export type VoiceBargeInBinding = {
 };
 export type VoiceController<TResult = unknown> = {
     bindHTMX: (options: VoiceHTMXBindingOptions) => () => void;
+    call: VoiceCallLifecycleState | null;
+    callControl: (message: Omit<VoiceClientCallControlMessage, 'type'>) => void;
     close: () => void;
     endTurn: () => void;
     start: (input?: {
@@ -855,6 +903,10 @@ export type VoiceStoreAction<TResult = unknown> = {
     sessionId: string;
     scenarioId?: string;
     status: VoiceSessionStatus;
+} | {
+    type: 'call_lifecycle';
+    event: VoiceCallLifecycleEvent;
+    sessionId: string;
 } | {
     type: 'partial';
     transcript: Transcript;

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

@@ -120,6 +120,12 @@ var serverMessageToAction = (message) => {
         sessionId: message.sessionId,
         type: "complete"
       };
+    case "call_lifecycle":
+      return {
+        event: message.event,
+        sessionId: message.sessionId,
+        type: "call_lifecycle"
+      };
     case "error":
       return {
         message: normalizeErrorMessage(message.message),
@@ -163,7 +169,7 @@ var DEFAULT_SCENARIO_QUERY_PARAM = "scenarioId";
 var noop = () => {};
 var noopUnsubscribe = () => noop;
 var NOOP_CONNECTION = {
-  start: () => {},
+  callControl: noop,
   close: noop,
   endTurn: noop,
   getReadyState: () => WS_CLOSED,
@@ -171,6 +177,7 @@ var NOOP_CONNECTION = {
   getSessionId: () => "",
   send: noop,
   sendAudio: noop,
+  start: () => {},
   subscribe: noopUnsubscribe
 };
 var createSessionId = () => crypto.randomUUID();
@@ -192,6 +199,7 @@ var isVoiceServerMessage = (value) => {
   switch (value.type) {
     case "audio":
     case "assistant":
+    case "call_lifecycle":
     case "complete":
     case "error":
     case "final":
@@ -332,6 +340,12 @@ var createVoiceConnection = (path, options = {}) => {
   const endTurn = () => {
     send({ type: "end_turn" });
   };
+  const callControl = (message) => {
+    send({
+      ...message,
+      type: "call_control"
+    });
+  };
   const close = () => {
     clearTimers();
     if (state.ws) {
@@ -349,7 +363,7 @@ var createVoiceConnection = (path, options = {}) => {
   };
   connect();
   return {
-    start,
+    callControl,
     close,
     endTurn,
     getReadyState: () => state.ws?.readyState ?? WS_CLOSED,
@@ -357,6 +371,7 @@ var createVoiceConnection = (path, options = {}) => {
     getSessionId: () => state.sessionId,
     send,
     sendAudio,
+    start,
     subscribe
   };
 };
@@ -365,6 +380,7 @@ var createVoiceConnection = (path, options = {}) => {
 var createInitialState = () => ({
   assistantAudio: [],
   assistantTexts: [],
+  call: null,
   error: null,
   isConnected: false,
   scenarioId: null,
@@ -408,6 +424,20 @@ var createVoiceStreamStore = () => {
           status: "completed"
         };
         break;
+      case "call_lifecycle":
+        state = {
+          ...state,
+          call: {
+            ...state.call,
+            disposition: action.event.type === "end" ? action.event.disposition : state.call?.disposition,
+            endedAt: action.event.type === "end" ? action.event.at : state.call?.endedAt,
+            events: [...state.call?.events ?? [], action.event],
+            lastEventAt: action.event.at,
+            startedAt: state.call?.startedAt ?? action.event.at
+          },
+          sessionId: action.sessionId
+        };
+        break;
       case "connected":
         state = {
           ...state,
@@ -494,6 +524,9 @@ var createVoiceStream = (path, options = {}) => {
     }
   });
   return {
+    callControl(message) {
+      connection.callControl(message);
+    },
     close() {
       unsubscribeConnection();
       connection.close();
@@ -537,6 +570,9 @@ var createVoiceStream = (path, options = {}) => {
     get assistantAudio() {
       return store.getSnapshot().assistantAudio;
     },
+    get call() {
+      return store.getSnapshot().call;
+    },
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
@@ -554,6 +590,7 @@ var useVoiceStream = (path, options = {}) => {
   const stream = createVoiceStream(path, options);
   const assistantAudio = shallowRef([]);
   const assistantTexts = shallowRef([]);
+  const call = shallowRef(null);
   const error = ref(null);
   const isConnected = ref(false);
   const partial = ref("");
@@ -563,6 +600,7 @@ var useVoiceStream = (path, options = {}) => {
   const sync = () => {
     assistantAudio.value = [...stream.assistantAudio];
     assistantTexts.value = [...stream.assistantTexts];
+    call.value = stream.call;
     error.value = stream.error;
     isConnected.value = stream.isConnected;
     partial.value = stream.partial;
@@ -580,6 +618,8 @@ var useVoiceStream = (path, options = {}) => {
   return {
     assistantAudio,
     assistantTexts,
+    call,
+    callControl: (message) => stream.callControl(message),
     close: () => destroy(),
     endTurn: () => stream.endTurn(),
     error,
@@ -1056,6 +1096,7 @@ var resolveVoiceRuntimePreset = (name = "default") => {
 var createInitialState2 = (stream) => ({
   assistantAudio: [...stream.assistantAudio],
   assistantTexts: [...stream.assistantTexts],
+  call: stream.call,
   error: stream.error,
   isConnected: stream.isConnected,
   isRecording: false,
@@ -1085,6 +1126,7 @@ var createVoiceController = (path, options = {}) => {
       ...state,
       assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
+      call: stream.call,
       error: stream.error,
       isConnected: stream.isConnected,
       partial: stream.partial,
@@ -1162,6 +1204,7 @@ var createVoiceController = (path, options = {}) => {
     bindHTMX(bindingOptions) {
       return bindVoiceHTMX(stream, bindingOptions);
     },
+    callControl: (message) => stream.callControl(message),
     close,
     endTurn: () => stream.endTurn(),
     get error() {
@@ -1214,6 +1257,9 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantAudio() {
       return state.assistantAudio;
+    },
+    get call() {
+      return state.call;
     }
   };
 };
@@ -1270,7 +1316,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/dist/vue/useVoiceStream.d.ts

@@ -12,6 +12,8 @@ export declare const useVoiceStream: <TResult = unknown>(path: string, options?:
         turnId?: string;
     }[]>;
     assistantTexts: import("vue").ShallowRef<string[], string[]>;
+    call: import("vue").ShallowRef<import("..").VoiceCallLifecycleState | null, import("..").VoiceCallLifecycleState | null>;
+    callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
     close: () => void;
     endTurn: () => void;
     error: import("vue").Ref<string | null, string | null>;

package/package.json

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