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

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

@@ -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);
     },
@@ -560,6 +596,7 @@ class VoiceStreamService {
     const stream = createVoiceStream(path, options);
     const assistantAudioSignal = signal([]);
     const assistantTextsSignal = signal([]);
+    const callSignal = signal(null);
     const errorSignal = signal(null);
     const isConnectedSignal = signal(false);
     const partialSignal = signal("");
@@ -569,6 +606,7 @@ class VoiceStreamService {
     const sync = () => {
       assistantAudioSignal.set([...stream.assistantAudio]);
       assistantTextsSignal.set([...stream.assistantTexts]);
+      callSignal.set(stream.call);
       errorSignal.set(stream.error);
       isConnectedSignal.set(stream.isConnected);
       partialSignal.set(stream.partial);
@@ -581,6 +619,8 @@ class VoiceStreamService {
     return {
       assistantAudio: computed(() => assistantAudioSignal()),
       assistantTexts: computed(() => assistantTextsSignal()),
+      call: computed(() => callSignal()),
+      callControl: (message) => stream.callControl(message),
       close: () => {
         unsubscribe();
         stream.close();
@@ -1065,6 +1105,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,
@@ -1094,6 +1135,7 @@ var createVoiceController = (path, options = {}) => {
       ...state,
       assistantAudio: [...stream.assistantAudio],
       assistantTexts: [...stream.assistantTexts],
+      call: stream.call,
       error: stream.error,
       isConnected: stream.isConnected,
       partial: stream.partial,
@@ -1171,6 +1213,7 @@ var createVoiceController = (path, options = {}) => {
     bindHTMX(bindingOptions) {
       return bindVoiceHTMX(stream, bindingOptions);
     },
+    callControl: (message) => stream.callControl(message),
     close,
     endTurn: () => stream.endTurn(),
     get error() {
@@ -1223,6 +1266,9 @@ var createVoiceController = (path, options = {}) => {
     },
     get assistantAudio() {
       return state.assistantAudio;
+    },
+    get call() {
+      return state.call;
     }
   };
 };
@@ -1288,7 +1334,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/angular/voice-stream.service.d.ts

@@ -8,6 +8,8 @@ export declare class VoiceStreamService {
             turnId?: string;
         }[]>;
         assistantTexts: import("@angular/core").Signal<string[]>;
+        call: import("@angular/core").Signal<import("..").VoiceCallLifecycleState | null>;
+        callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
         close: () => void;
         endTurn: () => void;
         error: import("@angular/core").Signal<string | null>;

package/dist/assistant.d.ts

@@ -1,5 +1,6 @@
 import { type VoiceAgent, type VoiceAgentModel, type VoiceAgentOptions, type VoiceAgentSquadOptions, type VoiceAgentTool } from './agent';
 import { type VoiceOutcomeRecipeName, type VoiceOutcomeRecipeOptions } from './outcomeRecipes';
+import { type VoiceAssistantMemoryHandle, type VoiceAssistantMemoryOptions } from './assistantMemory';
 import type { VoiceNormalizedRouteConfig, VoiceOnTurnObjectHandler, VoiceRouteConfig, VoiceRouteResult, VoiceRuntimeOpsConfig, VoiceSessionRecord } from './types';
 import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
 export type VoiceAssistantPreset = VoiceOutcomeRecipeName;
@@ -12,6 +13,7 @@ export type VoiceAssistantArtifactPlan<TContext = unknown, TSession extends Voic
 };
 export type VoiceAssistantGuardrailInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
     assistantId: string;
+    memory?: VoiceAssistantMemoryHandle;
 };
 export type VoiceAssistantOutputGuardrailInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceAssistantGuardrailInput<TContext, TSession, TResult> & {
     result: VoiceRouteResult<TResult>;
@@ -29,6 +31,16 @@ export type VoiceAssistantVariant<TContext = unknown, TSession extends VoiceSess
     tools?: Array<VoiceAgentTool<TContext, TSession, Record<string, unknown>, unknown, TResult>>;
     weight?: number;
 };
+export type VoiceAssistantMemoryLifecycleInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = Parameters<VoiceOnTurnObjectHandler<TContext, TSession, TResult>>[0] & {
+    assistantId: string;
+    memory: VoiceAssistantMemoryHandle;
+};
+export type VoiceAssistantMemoryLifecycle<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    afterTurn?: (input: VoiceAssistantMemoryLifecycleInput<TContext, TSession, TResult> & {
+        result: VoiceRouteResult<TResult>;
+    }) => Promise<void> | void;
+    beforeTurn?: (input: VoiceAssistantMemoryLifecycleInput<TContext, TSession, TResult>) => Promise<void> | void;
+};
 export type VoiceAssistantExperimentResolverInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
     assistantId: string;
     context: TContext;
@@ -83,6 +95,8 @@ export type VoiceAssistantOptions<TContext = unknown, TSession extends VoiceSess
     experiment?: VoiceAssistantExperiment<TContext, TSession, TResult>;
     guardrails?: VoiceAssistantGuardrails<TContext, TSession, TResult>;
     id: string;
+    memory?: VoiceAssistantMemoryOptions<TContext, TSession>;
+    memoryLifecycle?: VoiceAssistantMemoryLifecycle<TContext, TSession, TResult>;
     ops?: VoiceRuntimeOpsConfig<TContext, TSession, TResult>;
     trace?: VoiceAgentOptions<TContext, TSession, TResult>['trace'];
 };
@@ -109,6 +123,12 @@ export type VoiceAssistantRunSummary = {
     toolCalls: Record<string, number>;
     transferCount: number;
     variants: Record<string, number>;
+    memory: {
+        deletes: number;
+        gets: number;
+        lists: number;
+        sets: number;
+    };
 };
 export type VoiceAssistantRunsSummary = {
     assistants: VoiceAssistantRunSummary[];

package/dist/assistantHealth.d.ts

@@ -0,0 +1,81 @@
+import { Elysia } from 'elysia';
+import { type VoiceAssistantRunsSummary } from './assistant';
+import { type VoiceProviderHealthSummary } from './providerHealth';
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from './trace';
+export type VoiceAssistantHealthFailure = {
+    at: number;
+    assistantId?: string;
+    error?: string;
+    provider?: string;
+    rateLimited?: boolean;
+    replayHref?: string;
+    sessionId: string;
+    status?: string;
+    turnId?: string;
+    type: StoredVoiceTraceEvent['type'];
+};
+export type VoiceAssistantHealthSummary<TProvider extends string = string> = {
+    assistantRuns: VoiceAssistantRunsSummary;
+    providerHealth: VoiceProviderHealthSummary<TProvider>[];
+    recentFailures: VoiceAssistantHealthFailure[];
+};
+export type VoiceAssistantHealthSummaryOptions<TProvider extends string = string> = {
+    events?: StoredVoiceTraceEvent[];
+    maxFailures?: number;
+    providers?: readonly TProvider[];
+    replayHref?: false | string | ((failure: Omit<VoiceAssistantHealthFailure, 'replayHref'>) => string);
+    store?: VoiceTraceEventStore;
+};
+export type VoiceAssistantHealthHTMLHandlerOptions<TProvider extends string = string> = VoiceAssistantHealthSummaryOptions<TProvider> & {
+    headers?: HeadersInit;
+    render?: (summary: VoiceAssistantHealthSummary<TProvider>) => string | Promise<string>;
+};
+export type VoiceAssistantHealthRoutesOptions<TProvider extends string = string> = VoiceAssistantHealthHTMLHandlerOptions<TProvider> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const summarizeVoiceAssistantHealth: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => Promise<VoiceAssistantHealthSummary<TProvider>>;
+export declare const renderVoiceAssistantHealthHTML: <TProvider extends string = string>(summary: VoiceAssistantHealthSummary<TProvider>) => string;
+export declare const createVoiceAssistantHealthJSONHandler: <TProvider extends string = string>(options: VoiceAssistantHealthSummaryOptions<TProvider>) => () => Promise<VoiceAssistantHealthSummary<TProvider>>;
+export declare const createVoiceAssistantHealthHTMLHandler: <TProvider extends string = string>(options: VoiceAssistantHealthHTMLHandlerOptions<TProvider>) => () => Promise<Response>;
+export declare const createVoiceAssistantHealthRoutes: <TProvider extends string = string>(options: VoiceAssistantHealthRoutesOptions<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: VoiceAssistantHealthSummary<TProvider>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/assistantMemory.d.ts

@@ -0,0 +1,63 @@
+import type { VoiceSessionRecord } from './types';
+import type { VoiceTraceEventStore } from './trace';
+export type VoiceAssistantMemoryRecord<TValue = unknown, TMetadata extends Record<string, unknown> = Record<string, unknown>> = {
+    assistantId: string;
+    createdAt: number;
+    key: string;
+    metadata?: TMetadata;
+    namespace: string;
+    updatedAt: number;
+    value: TValue;
+};
+export type VoiceAssistantMemoryStore<TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    delete: (input: {
+        assistantId: string;
+        key: string;
+        namespace: string;
+    }) => Promise<void>;
+    get: (input: {
+        assistantId: string;
+        key: string;
+        namespace: string;
+    }) => Promise<TRecord | undefined>;
+    list: (input: {
+        assistantId: string;
+        namespace?: string;
+    }) => Promise<TRecord[]>;
+    set: (input: Omit<TRecord, 'createdAt' | 'updatedAt'> & {
+        createdAt?: number;
+        updatedAt?: number;
+    }) => Promise<TRecord>;
+};
+export type VoiceAssistantMemoryNamespaceInput<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    assistantId: string;
+    context: TContext;
+    session: TSession;
+};
+export type VoiceAssistantMemoryOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    namespace: string | ((input: VoiceAssistantMemoryNamespaceInput<TContext, TSession>) => Promise<string> | string);
+    store: VoiceAssistantMemoryStore<TRecord>;
+};
+export type VoiceAssistantMemoryBinding<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = VoiceAssistantMemoryOptions<TContext, TSession, TRecord>;
+export type VoiceAssistantMemoryHandle<TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord> = {
+    delete: (key: string) => Promise<void>;
+    get: <TValue = unknown>(key: string) => Promise<TValue | undefined>;
+    list: () => Promise<TRecord[]>;
+    namespace: string;
+    set: <TValue = unknown>(key: string, value: TValue, metadata?: Record<string, unknown>) => Promise<TRecord>;
+};
+export declare const createVoiceAssistantMemoryRecord: <TValue = unknown, TMetadata extends Record<string, unknown> = Record<string, unknown>>(input: Omit<VoiceAssistantMemoryRecord<TValue, TMetadata>, "createdAt" | "updatedAt"> & {
+    createdAt?: number;
+    updatedAt?: number;
+}) => VoiceAssistantMemoryRecord<TValue, TMetadata>;
+export declare const createVoiceMemoryAssistantMemoryStore: <TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>() => VoiceAssistantMemoryStore<TRecord>;
+export declare const resolveVoiceAssistantMemoryNamespace: <TContext, TSession extends VoiceSessionRecord>(input: VoiceAssistantMemoryNamespaceInput<TContext, TSession> & {
+    memory: VoiceAssistantMemoryOptions<TContext, TSession>;
+}) => Promise<string>;
+export declare const createVoiceAssistantMemoryHandle: <TContext, TSession extends VoiceSessionRecord, TRecord extends VoiceAssistantMemoryRecord = VoiceAssistantMemoryRecord>(input: {
+    assistantId: string;
+    context: TContext;
+    memory: VoiceAssistantMemoryOptions<TContext, TSession, TRecord>;
+    session: TSession;
+    trace?: VoiceTraceEventStore;
+}) => Promise<VoiceAssistantMemoryHandle<TRecord>>;

package/dist/client/actions.d.ts

@@ -7,6 +7,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     type: "audio";
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
@@ -20,6 +21,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
@@ -33,6 +35,21 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    event?: undefined;
+    message?: undefined;
+    transcript?: undefined;
+    scenarioId?: undefined;
+    status?: undefined;
+    turn?: undefined;
+} | {
+    event: import("..").VoiceCallLifecycleEvent;
+    sessionId: string;
+    type: "call_lifecycle";
+    chunk?: undefined;
+    format?: undefined;
+    receivedAt?: undefined;
+    turnId?: undefined;
+    text?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
@@ -47,6 +64,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;
     status?: undefined;
@@ -60,6 +78,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     scenarioId?: undefined;
     status?: undefined;
@@ -73,6 +92,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     scenarioId?: undefined;
     status?: undefined;
@@ -87,6 +107,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     receivedAt?: undefined;
     turnId?: undefined;
     text?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     turn?: undefined;
@@ -99,6 +120,7 @@ export declare const serverMessageToAction: <TResult = unknown>(message: VoiceSe
     turnId?: undefined;
     text?: undefined;
     sessionId?: undefined;
+    event?: undefined;
     message?: undefined;
     transcript?: undefined;
     scenarioId?: undefined;

package/dist/client/connection.d.ts

@@ -1,5 +1,8 @@
 import type { VoiceClientMessage, VoiceConnectionOptions, VoiceServerMessage } from '../types';
 type VoiceConnectionHandle = {
+    callControl: (message: Omit<VoiceClientMessage & {
+        type: 'call_control';
+    }, 'type'>) => void;
     start: (input?: {
         sessionId?: string;
         scenarioId?: string;