@absolutejs/voice 0.0.22-beta.653 → 0.0.22-beta.655

package/dist/vue/index.js

@@ -10705,8 +10705,11 @@ var serverMessageToAction = (message) => {
     case "error":
       return {
         message: normalizeErrorMessage(message.message),
+        recoverable: message.recoverable,
         type: "error"
       };
+    case "call_control_ack":
+      return null;
     case "final":
       return {
         transcript: message.transcript,
@@ -10834,14 +10837,17 @@ var WS_FORBIDDEN = 4403;
 var DEFAULT_MAX_RECONNECT_ATTEMPTS = 15;
 var DEFAULT_PING_INTERVAL = 30000;
 var DEFAULT_RECONNECT_RESET_AFTER_MS = 30000;
+var DEFAULT_CALL_CONTROL_ACK_TIMEOUT_MS = 5000;
+var MAX_PENDING_CONTROL_MESSAGES = 100;
 var RECONNECT_BASE_DELAY_MS = 500;
 var DEFAULT_RECONNECT_MAX_DELAY_MS = 8000;
 var computeVoiceReconnectDelayMs = (attempt, baseMs, maxDelayMs) => Math.min(maxDelayMs, baseMs * 2 ** (Math.max(1, attempt) - 1));
 var DEFAULT_SCENARIO_QUERY_PARAM = "scenarioId";
 var noop = () => {};
+var noopAsync = () => Promise.resolve();
 var noopUnsubscribe = () => noop;
 var NOOP_CONNECTION = {
-  callControl: noop,
+  callControl: noopAsync,
   close: noop,
   disconnect: noop,
   endTurn: noop,
@@ -10879,6 +10885,7 @@ var isVoiceServerMessage = (value) => {
     case "audio":
     case "assistant":
     case "call_lifecycle":
+    case "call_control_ack":
     case "complete":
     case "connection":
     case "error":
@@ -10909,6 +10916,7 @@ var createVoiceConnection = (path, options = {}) => {
     return NOOP_CONNECTION;
   }
   const listeners = new Set;
+  const pendingCallControls = new Map;
   const shouldReconnect = options.reconnect !== false;
   const maxReconnectAttempts = options.maxReconnectAttempts ?? DEFAULT_MAX_RECONNECT_ATTEMPTS;
   const reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
@@ -10929,6 +10937,21 @@ var createVoiceConnection = (path, options = {}) => {
   const emitConnection = (reconnect) => {
     listeners.forEach((listener) => listener(reconnect));
   };
+  const emitTerminalFailure = (message) => {
+    listeners.forEach((listener) => listener({
+      message,
+      recoverable: false,
+      type: "error"
+    }));
+    emitConnection({
+      reconnect: {
+        attempts: state.reconnectAttempts,
+        maxAttempts: maxReconnectAttempts,
+        status: "exhausted"
+      },
+      type: "connection"
+    });
+  };
   const clearTimers = () => {
     if (state.pingInterval) {
       clearInterval(state.pingInterval);
@@ -10954,6 +10977,13 @@ var createVoiceConnection = (path, options = {}) => {
       }
     }
   };
+  const rejectPendingCallControls = (message) => {
+    for (const pending of pendingCallControls.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error(message));
+    }
+    pendingCallControls.clear();
+  };
   const scheduleReconnect = () => {
     state.reconnectAttempts += 1;
     const delayMs = computeReconnectDelayMs(state.reconnectAttempts);
@@ -10968,16 +10998,24 @@ var createVoiceConnection = (path, options = {}) => {
       },
       type: "connection"
     });
-    state.reconnectTimeout = setTimeout(() => {
+    state.reconnectTimeout = setTimeout(async () => {
       if (state.reconnectAttempts > maxReconnectAttempts) {
-        emitConnection({
-          reconnect: {
-            attempts: state.reconnectAttempts,
-            maxAttempts: maxReconnectAttempts,
-            status: "exhausted"
-          },
-          type: "connection"
+        emitTerminalFailure("Voice connection could not be restored.");
+        return;
+      }
+      try {
+        await options.prepareReconnect?.({
+          attempt: state.reconnectAttempts,
+          path,
+          scenarioId: state.scenarioId,
+          sessionId: state.sessionId
         });
+      } catch {
+        if (state.reconnectAttempts < maxReconnectAttempts) {
+          scheduleReconnect();
+        } else {
+          emitTerminalFailure("Voice authorization could not be renewed for reconnect.");
+        }
         return;
       }
       connect();
@@ -11034,6 +11072,18 @@ var createVoiceConnection = (path, options = {}) => {
         state.sessionId = parsed.sessionId;
         state.scenarioId = parsed.scenarioId ?? state.scenarioId;
       }
+      if (parsed.type === "call_control_ack") {
+        const pending = pendingCallControls.get(parsed.requestId);
+        if (pending) {
+          clearTimeout(pending.timeout);
+          pendingCallControls.delete(parsed.requestId);
+          if (parsed.ok) {
+            pending.resolve();
+          } else {
+            pending.reject(new Error(parsed.message ?? `${parsed.action} was not applied`));
+          }
+        }
+      }
       listeners.forEach((listener) => listener(parsed));
     };
     ws.onclose = (event) => {
@@ -11043,18 +11093,30 @@ var createVoiceConnection = (path, options = {}) => {
       state.isConnected = false;
       clearTimers();
       const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && event.code !== WS_UNAUTHORIZED && event.code !== WS_FORBIDDEN && state.reconnectAttempts < maxReconnectAttempts;
+      const authorizationFailure = event.code === WS_UNAUTHORIZED || event.code === WS_FORBIDDEN;
+      if (authorizationFailure) {
+        listeners.forEach((listener) => listener({
+          message: event.code === WS_UNAUTHORIZED ? "Voice authorization expired or was rejected." : "Voice authorization was forbidden.",
+          recoverable: false,
+          type: "error"
+        }));
+      }
       if (reconnectable) {
         scheduleReconnect();
       } else if (shouldReconnect && event.code !== WS_NORMAL_CLOSURE) {
-        emitConnection({
-          reconnect: {
-            attempts: state.reconnectAttempts,
-            lastDisconnectAt: Date.now(),
-            maxAttempts: maxReconnectAttempts,
-            status: "exhausted"
-          },
-          type: "connection"
-        });
+        if (authorizationFailure) {
+          emitConnection({
+            reconnect: {
+              attempts: state.reconnectAttempts,
+              lastDisconnectAt: Date.now(),
+              maxAttempts: maxReconnectAttempts,
+              status: "exhausted"
+            },
+            type: "connection"
+          });
+        } else {
+          emitTerminalFailure("Voice connection could not be restored.");
+        }
       }
     };
     state.ws = ws;
@@ -11064,6 +11126,12 @@ var createVoiceConnection = (path, options = {}) => {
       state.ws.send(value);
       return;
     }
+    if (typeof value !== "string") {
+      return;
+    }
+    if (state.pendingMessages.length >= MAX_PENDING_CONTROL_MESSAGES) {
+      state.pendingMessages.shift();
+    }
     state.pendingMessages.push(value);
   };
   const send = (message) => {
@@ -11089,13 +11157,23 @@ var createVoiceConnection = (path, options = {}) => {
     send({ type: "end_turn" });
   };
   const callControl = (message) => {
+    const requestId = crypto.randomUUID();
+    const { promise, reject, resolve } = Promise.withResolvers();
+    const timeout = setTimeout(() => {
+      pendingCallControls.delete(requestId);
+      reject(new Error(`${message.action} acknowledgement timed out`));
+    }, DEFAULT_CALL_CONTROL_ACK_TIMEOUT_MS);
+    pendingCallControls.set(requestId, { reject, resolve, timeout });
     send({
       ...message,
+      requestId,
       type: "call_control"
     });
+    return promise;
   };
   const close = (reason = "client-close") => {
     clearTimers();
+    rejectPendingCallControls("Voice connection closed");
     if (state.ws) {
       const ws = state.ws;
       state.ws = null;
@@ -11109,6 +11187,7 @@ var createVoiceConnection = (path, options = {}) => {
   };
   const disconnect = () => {
     clearTimers();
+    rejectPendingCallControls("Voice connection disconnected");
     if (state.ws) {
       const ws = state.ws;
       state.ws = null;
@@ -11271,7 +11350,8 @@ var createVoiceStreamStore = () => {
       case "error":
         state = {
           ...state,
-          error: action.message
+          error: action.message,
+          ...action.recoverable === false ? { isConnected: false, status: "failed" } : {}
         };
         break;
       case "final":
@@ -11411,7 +11491,7 @@ var createVoiceStream = (path, options = {}) => {
       return store.getSnapshot().call;
     },
     callControl(message) {
-      connection.callControl(message);
+      return connection.callControl(message);
     },
     close(reason) {
       unsubscribeConnection();

package/dist/vue/useVoiceStream.d.ts

@@ -22,7 +22,7 @@ export declare function useVoiceStream<TResult = unknown>(path: string, options?
     sessionMetadata: import("vue").ShallowRef<Record<string, unknown> | null, Record<string, unknown> | null>;
     status: import("vue").Ref<import("..").VoiceSessionStatus | "idle", import("..").VoiceSessionStatus | "idle">;
     turns: import("vue").ShallowRef<VoiceTurnRecord<TResult>[], VoiceTurnRecord<TResult>[]>;
-    callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "type">) => void>[0]) => void;
+    callControl: (message: Parameters<(message: Omit<import("..").VoiceClientCallControlMessage, "requestId" | "type">) => Promise<void>>[0]) => Promise<void>;
     close: () => void;
     endTurn: () => void;
     sendAudio: (audio: Uint8Array | ArrayBuffer) => void;

package/package.json

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