@voxevolv/client 0.3.11 → 0.3.14

package/dist/index.js

@@ -49,8 +49,10 @@ import {
   decodeContextUpdatedPayload,
   decodeRealtimeEvent
 } from "./generated/protocol-codecs.js";
-var SDK_VERSION = "0.3.11";
+var SDK_VERSION = "0.3.14";
 var CLIENT_HELLO_TIMEOUT_MS = 3e4;
+var RECOVERY_BUFFER_STALL_MS = 5e3;
+var RECOVERY_BUFFER_POLL_MS = 500;
 var DIAGNOSTIC_REPORT_TIMEOUT_MS = 5e3;
 var DEFAULT_STARTUP_ATTEMPTS = [
   { delayBeforeMs: 0, readyTimeoutMs: 15e3 },
@@ -58,6 +60,12 @@ var DEFAULT_STARTUP_ATTEMPTS = [
   { delayBeforeMs: 3e3, readyTimeoutMs: 5e4 }
 ];
 var DEFAULT_STARTUP_TIMEOUT_MS = 9e4;
+var RecoveryDataChannelStalledError = class extends Error {
+  constructor() {
+    super("Recovery data channel stopped draining before the agent handshake completed");
+    this.name = "RecoveryDataChannelStalledError";
+  }
+};
 var RealtimeSessionHttpError = class extends Error {
   status;
   code;
@@ -136,6 +144,9 @@ var RealtimeSession = class _RealtimeSession {
   endNotificationDelivered = false;
   disconnectMode = null;
   activeRecovery = null;
+  recoveryStartedAt = null;
+  livekitResumeController = null;
+  terminalReplayController = null;
   autoRejoinPromise = null;
   autoRejoinController = null;
   manualRejoinController = null;
@@ -156,6 +167,7 @@ var RealtimeSession = class _RealtimeSession {
   lifecycleCredentials;
   diagnostics = new ClientDiagnosticBuffer({ sdkVersion: SDK_VERSION });
   activeContextTransfers = 0;
+  contextTransferControllers = /* @__PURE__ */ new Set();
   activeContextBytes = 0;
   diagnosticLoopTimer;
   diagnosticLoopExpectedAt = 0;
@@ -614,7 +626,11 @@ var RealtimeSession = class _RealtimeSession {
     this.apiBase = apiBase;
     this.agentReady = false;
     try {
-      await this.connectRoom(signal, recovering);
+      await this.measureRecoveryStage(
+        "room_connect",
+        () => this.connectRoom(signal, recovering),
+        recovering
+      );
       throwIfAborted(signal);
       if (audioTrack) {
         await raceWithAbort(this.publishApplicationAudioTrack(audioTrack), signal);
@@ -626,10 +642,20 @@ var RealtimeSession = class _RealtimeSession {
       }
       throwIfAborted(signal);
       this.setState(recovering ? "resuming" : "connected_not_ready");
-      await raceWithAbort(this.sendHello(), signal);
+      await this.measureRecoveryStage("hello", () => recovering ? this.sendRecoveryHello(signal) : raceWithAbort(this.sendHello(), signal), recovering);
       const readyDeadline = Date.now() + readyTimeoutMs;
-      await this.waitForAgentReady(readyTimeoutMs, signal);
-      if (waitForRemoteAudio) await this.waitForRemoteAudioTrack(readyDeadline, signal);
+      await this.measureRecoveryStage(
+        "agent_ready",
+        () => this.waitForAgentReady(readyTimeoutMs, signal),
+        recovering
+      );
+      if (waitForRemoteAudio) {
+        await this.measureRecoveryStage(
+          "remote_audio",
+          () => this.waitForRemoteAudioTrack(readyDeadline, signal),
+          recovering
+        );
+      }
       throwIfAborted(signal);
       if (this.sessionEnded || generation !== this.contextGeneration) {
         throw new Error("Connection restoration interrupted");
@@ -731,11 +757,11 @@ var RealtimeSession = class _RealtimeSession {
     this.contextGeneration += 1;
     this.replacementContext.pause();
     this.rejectPendingCommands(new Error("Restoring the session"));
-    let response = await this.fetchRoomToken(apiBase, signal);
+    let response = await this.fetchRoomToken(apiBase, signal, recovering);
     if (response.status === 401 && this.refreshCredentialsCallback) {
       await this.refreshCredentials(signal);
       throwIfAborted(signal);
-      response = await this.fetchRoomToken(apiBase, signal);
+      response = await this.fetchRoomToken(apiBase, signal, recovering);
     }
     if (this.sessionEnded) {
       if (this.terminalSessionError) throw this.terminalSessionError;
@@ -751,7 +777,11 @@ var RealtimeSession = class _RealtimeSession {
     if (this.room.state !== LiveKitConnectionState.Disconnected) {
       this.disconnectMode = "rejoin";
       try {
-        await raceWithAbort(this.room.disconnect(), signal);
+        await this.measureRecoveryStage(
+          "room_disconnect",
+          () => raceWithAbort(this.room.disconnect(), signal),
+          recovering
+        );
       } finally {
         this.disconnectMode = null;
       }
@@ -800,6 +830,8 @@ var RealtimeSession = class _RealtimeSession {
   }
   async sendContextUpdate(update, timeoutMs) {
     const generation = this.contextGeneration;
+    const controller = new AbortController();
+    this.contextTransferControllers.add(controller);
     const payloadBytes = contextUpdateBytes(update);
     const transferStartedAt = Date.now();
     let transferTimedOut = false;
@@ -811,7 +843,8 @@ var RealtimeSession = class _RealtimeSession {
     });
     this.activeContextTransfers += 1;
     this.activeContextBytes += payloadBytes;
-    const uploading = ("image" in update ? this.uploadImageContext(update) : this.uploadTextContext(update)).finally(() => {
+    const uploading = ("image" in update ? this.uploadImageContext(update, controller.signal) : this.uploadTextContext(update, controller.signal)).finally(() => {
+      this.contextTransferControllers.delete(controller);
       this.activeContextTransfers -= 1;
       this.activeContextBytes -= payloadBytes;
     });
@@ -835,6 +868,7 @@ var RealtimeSession = class _RealtimeSession {
           timeout_ms: timeoutMs
         });
         this.flushDiagnostics("context_transfer_timeout");
+        controller.abort(error);
         reject(error);
       }, timeoutMs);
     });
@@ -891,7 +925,7 @@ var RealtimeSession = class _RealtimeSession {
     void this.replacementContext.resume(restore).catch(() => {
     });
   }
-  async uploadTextContext(update) {
+  async uploadTextContext(update, signal) {
     const data = new TextEncoder().encode(update.text);
     if (data.byteLength === 0) throw new TypeError("Context text cannot be empty");
     if (data.byteLength > 262144) {
@@ -906,17 +940,20 @@ var RealtimeSession = class _RealtimeSession {
     if (data.byteLength <= 32768) return { payload: { ...base, text: update.text } };
     const sha256 = await sha256Hex(data);
     const streamId = contextStreamId();
-    const send = async () => {
-      const writer = await this.room.localParticipant.streamText({
+    const send = async (signal2) => {
+      signal2.throwIfAborted();
+      const options = {
         streamId,
         topic: "voxevolv.context.text",
         totalSize: data.byteLength,
-        attributes: { sha256 }
-      });
+        attributes: { sha256 },
+        signal: signal2
+      };
+      const writer = await this.room.localParticipant.streamText(options);
       await writer.write(update.text);
       await writer.close();
     };
-    await send();
+    await send(signal);
     return {
       payload: {
         ...base,
@@ -925,7 +962,7 @@ var RealtimeSession = class _RealtimeSession {
       resend: send
     };
   }
-  async uploadImageContext(update) {
+  async uploadImageContext(update, signal) {
     const allowed = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/webp"]);
     if (!allowed.has(update.image.type)) {
       throw new TypeError("Image context must be JPEG, PNG, or WebP");
@@ -936,19 +973,22 @@ var RealtimeSession = class _RealtimeSession {
     }
     const sha256 = await sha256Hex(data);
     const streamId = contextStreamId();
-    const send = async () => {
-      const writer = await this.room.localParticipant.streamBytes({
+    const send = async (signal2) => {
+      signal2.throwIfAborted();
+      const options = {
         streamId,
         topic: "voxevolv.context.image",
         name: "context-image",
         mimeType: update.image.type,
         totalSize: data.byteLength,
-        attributes: { sha256 }
-      });
+        attributes: { sha256 },
+        signal: signal2
+      };
+      const writer = await this.room.localParticipant.streamBytes(options);
       await writer.write(data);
       await writer.close();
     };
-    await send();
+    await send(signal);
     return {
       payload: {
         key: update.key,
@@ -1051,16 +1091,26 @@ var RealtimeSession = class _RealtimeSession {
   bindRoomEvents() {
     this.room.on(RoomEvent.ParticipantDisconnected, (participant) => {
       if (participant.isAgent && !this.disconnectMode) {
-        this.agentDisconnected = true;
-        if (this.terminalSessionError) return;
-        if (this.sessionEnded) {
-          this.finishPendingEnd();
-          return;
-        }
-        this.startAutoRejoin(
-          new Error("Agent disconnected from the room"),
-          { trigger: "agent_disconnected" }
-        );
+        queueMicrotask(() => {
+          if (this.disconnectMode || this.terminalSessionError || this.terminalReplayController || ["disconnected", "failed"].includes(this.stateValue)) return;
+          if (this.sessionEnded) {
+            this.agentDisconnected = true;
+            this.finishPendingEnd();
+            return;
+          }
+          if (!this.hasConnectedValue || this.room.state === LiveKitConnectionState.Reconnecting || this.activeRecovery !== null || this.autoRejoinPromise !== null || this.manualRejoinController !== null) return;
+          if ([...this.room.remoteParticipants.values()].some((remote) => remote.isAgent)) return;
+          this.agentDisconnected = true;
+          if (!this.shouldAutoRejoin()) {
+            void this.recoverDisconnectedSession().catch(() => {
+            });
+            return;
+          }
+          this.startAutoRejoin(
+            new Error("Agent disconnected from the room"),
+            { trigger: "agent_disconnected" }
+          );
+        });
       }
     });
     this.room.on(RoomEvent.SignalReconnecting, () => this.handleLiveKitReconnecting());
@@ -1072,7 +1122,7 @@ var RealtimeSession = class _RealtimeSession {
       this.handleLiveKitDisconnected(reason);
     });
     this.room.on(RoomEvent.ConnectionStateChanged, (state) => {
-      if (this.sessionEnded || this.terminalSessionError) return;
+      if (this.sessionEnded || this.terminalSessionError || this.terminalReplayController || ["disconnected", "failed"].includes(this.stateValue)) return;
       if (state === LiveKitConnectionState.Connected) {
         const recovering = this.activeRecovery !== null || this.stateValue === "resuming";
         this.setState(
@@ -1149,13 +1199,15 @@ var RealtimeSession = class _RealtimeSession {
     });
   }
   handleLiveKitReconnecting() {
-    if (this.sessionEnded || this.disconnectMode === "intentional") return;
+    if (this.sessionEnded || this.disconnectMode === "intentional" || this.terminalReplayController || ["disconnected", "failed"].includes(this.stateValue)) return;
     this.agentReady = false;
     if (this.autoRejoinPromise !== null || this.activeRecovery?.strategy === "rejoin" || this.disconnectMode === "rejoin") {
       this.setState("resuming");
       return;
     }
     this.contextGeneration += 1;
+    this.livekitResumeController?.abort(new Error("LiveKit connection interrupted again"));
+    this.livekitResumeController = null;
     this.replacementContext.pause();
     this.reconnectStartedAt ??= Date.now();
     this.rejectPendingCommands(
@@ -1164,12 +1216,15 @@ var RealtimeSession = class _RealtimeSession {
     );
     if (this.activeRecovery === null) {
       this.beginRecovery("livekit", 1, { trigger: "livekit_reconnecting" });
+      this.recordDiagnostic({ operation: "connection_recovery", stage: "room_connect", status: "started" });
     }
     this.setState("reconnecting");
   }
   async handleLiveKitReconnected() {
-    if (this.sessionEnded || this.disconnectMode || this.autoRejoinPromise) return;
+    if (this.sessionEnded || this.disconnectMode || this.autoRejoinPromise || this.livekitResumeController || this.terminalReplayController || ["disconnected", "failed"].includes(this.stateValue)) return;
     const generation = this.contextGeneration;
+    const controller = new AbortController();
+    this.livekitResumeController = controller;
     const recoveredAt = Date.now();
     if (this.reconnectStartedAt !== null) {
       this.pendingReconnect = {
@@ -1182,21 +1237,35 @@ var RealtimeSession = class _RealtimeSession {
     if (this.hasConnectedValue && this.activeRecovery === null) {
       this.beginRecovery("livekit", 1, { trigger: "livekit_reconnecting" });
     }
+    this.recordDiagnostic({
+      operation: "connection_recovery",
+      stage: "room_connect",
+      status: "succeeded",
+      duration_ms: Math.max(Date.now() - (this.recoveryStartedAt ?? Date.now()), 0)
+    });
     this.connectionId = `conn_${Math.random().toString(36).slice(2)}_${Date.now().toString(36)}`;
     this.clientSeq = 0;
     this.setState(this.hasConnectedValue ? "resuming" : "connected_not_ready");
     try {
-      await this.sendHello();
+      await this.measureRecoveryStage("hello", () => this.sendRecoveryHello(controller.signal));
       const deadline = Date.now() + this.recoveryReadiness.readyTimeoutMs;
-      await this.waitForAgentReady(Math.max(deadline - Date.now(), 0));
-      if (this.recoveryReadiness.waitForRemoteAudio) await this.waitForRemoteAudioTrack(deadline);
+      await this.measureRecoveryStage(
+        "agent_ready",
+        () => this.waitForAgentReady(Math.max(deadline - Date.now(), 0), controller.signal)
+      );
+      if (this.recoveryReadiness.waitForRemoteAudio) {
+        await this.measureRecoveryStage(
+          "remote_audio",
+          () => this.waitForRemoteAudioTrack(deadline, controller.signal)
+        );
+      }
       if (this.sessionEnded || generation !== this.contextGeneration) return;
       this.resumeContextDelivery(true);
       if (this.sessionEnded || generation !== this.contextGeneration) return;
       this.setState("connected");
       this.completeRecovery();
     } catch (error) {
-      if (this.sessionEnded || generation !== this.contextGeneration) return;
+      if (controller.signal.aborted || this.sessionEnded || generation !== this.contextGeneration) return;
       const normalizedError = toError(error);
       if (this.shouldAutoRejoin()) {
         this.startAutoRejoin(normalizedError, { trigger: "livekit_resume_failed" });
@@ -1204,6 +1273,8 @@ var RealtimeSession = class _RealtimeSession {
         this.failRecovery(normalizedError);
         this.setState("failed");
       }
+    } finally {
+      if (this.livekitResumeController === controller) this.livekitResumeController = null;
     }
   }
   handleLiveKitDisconnected(reason) {
@@ -1223,7 +1294,7 @@ var RealtimeSession = class _RealtimeSession {
       this.setState("disconnected");
       return;
     }
-    if (this.terminalSessionError) return;
+    if (this.terminalSessionError || this.terminalReplayController) return;
     if (this.shouldAutoRejoin(reason)) {
       this.startAutoRejoin(
         new Error(`LiveKit disconnected (${disconnectReasonName(reason)})`),
@@ -1231,6 +1302,11 @@ var RealtimeSession = class _RealtimeSession {
       );
       return;
     }
+    if (this.hasConnectedValue && !this.sessionEnded && !["disconnected", "failed"].includes(this.stateValue) && (!isTerminalDisconnectReason(reason) || reason === DisconnectReason.ROOM_CLOSED || reason === DisconnectReason.ROOM_DELETED)) {
+      void this.recoverDisconnectedSession().catch(() => {
+      });
+      return;
+    }
     if (this.activeRecovery !== null) {
       this.failRecovery(
         new Error(`LiveKit disconnected (${disconnectReasonName(reason)})`)
@@ -1252,14 +1328,42 @@ var RealtimeSession = class _RealtimeSession {
     void this.disconnect().catch(() => {
     });
   }
-  async recoverSessionEnd(apiBase, signal) {
+  async recoverDisconnectedSession() {
+    if (this.terminalReplayController) return;
+    this.failRecovery(new Error("Transport closed during recovery"));
+    this.cancelRecovery();
+    this.contextGeneration += 1;
+    this.replacementContext.pause();
+    const controller = new AbortController();
+    this.terminalReplayController = controller;
+    this.setState("resuming");
+    try {
+      await this.recoverSessionEnd(this.apiBase, controller.signal, true);
+    } finally {
+      if (this.terminalReplayController === controller) {
+        this.terminalReplayController = null;
+        if (!controller.signal.aborted && !this.sessionEnded && !this.terminalSessionError) {
+          await this.disconnect();
+        }
+      }
+    }
+  }
+  async recoverSessionEnd(apiBase, signal, waitForCommit = false) {
     const controller = new AbortController();
     const cancel = () => controller.abort(signal?.reason);
     signal?.addEventListener("abort", cancel, { once: true });
     if (signal?.aborted) cancel();
     const timeout = globalThis.setTimeout(() => controller.abort(), 5e3);
     try {
-      await this.fetchReplay(apiBase, 0, { signal: controller.signal, terminalOnly: true });
+      do {
+        try {
+          await this.fetchReplay(apiBase, 0, { signal: controller.signal, terminalOnly: true });
+        } catch (error) {
+          if (!waitForCommit || controller.signal.aborted || isTerminalRejoinError(error)) throw error;
+        }
+        if (!waitForCommit || this.sessionEnded || this.terminalSessionError) break;
+        await abortableDelay(500, controller.signal);
+      } while (!controller.signal.aborted);
     } catch {
     } finally {
       globalThis.clearTimeout(timeout);
@@ -1275,6 +1379,7 @@ var RealtimeSession = class _RealtimeSession {
     this.notifyListeners(this.endedListeners, event);
   }
   beginRecovery(strategy, attempt, details) {
+    this.recoveryStartedAt ??= Date.now();
     this.activeRecovery = { strategy, attempt, details };
     this.recordDiagnostic({
       operation: "connection_recovery",
@@ -1282,7 +1387,8 @@ var RealtimeSession = class _RealtimeSession {
       reason: details.trigger,
       message_id: details.messageId,
       context_key: details.contextKey,
-      timeout_ms: details.timeoutMs
+      timeout_ms: details.timeoutMs,
+      retry_count: attempt - 1
     });
     this.flushDiagnostics("recovery_started");
     this.notifyListeners(this.recoveryListeners, {
@@ -1295,6 +1401,16 @@ var RealtimeSession = class _RealtimeSession {
   completeRecovery() {
     const recovery = this.activeRecovery;
     if (!recovery) return;
+    this.recordDiagnostic({
+      operation: "connection_recovery",
+      stage: "complete",
+      status: "succeeded",
+      duration_ms: Math.max(Date.now() - (this.recoveryStartedAt ?? Date.now()), 0),
+      retry_count: recovery.attempt - 1,
+      reason: recovery.details.trigger
+    });
+    this.flushDiagnostics("recovery_completed");
+    this.recoveryStartedAt = null;
     this.activeRecovery = null;
     this.notifyListeners(this.recoveryListeners, {
       status: "succeeded",
@@ -1306,6 +1422,15 @@ var RealtimeSession = class _RealtimeSession {
   failRecovery(error) {
     const recovery = this.activeRecovery;
     if (!recovery) return;
+    this.recordDiagnostic({
+      operation: "connection_recovery",
+      stage: "complete",
+      status: "failed",
+      duration_ms: Math.max(Date.now() - (this.recoveryStartedAt ?? Date.now()), 0),
+      retry_count: recovery.attempt - 1,
+      reason: recovery.details.trigger
+    });
+    this.flushDiagnostics("recovery_failed");
     this.activeRecovery = null;
     this.notifyListeners(this.recoveryListeners, {
       status: "failed",
@@ -1320,13 +1445,19 @@ var RealtimeSession = class _RealtimeSession {
   }
   startAutoRejoin(initialError, details) {
     if (this.autoRejoinPromise || !this.shouldAutoRejoin()) return;
+    this.recoveryStartedAt ??= Date.now();
     this.agentReady = false;
     this.contextGeneration += 1;
+    this.livekitResumeController?.abort(initialError);
     this.replacementContext.pause();
     this.rejectPendingCommands(initialError);
     this.reconnectStartedAt ??= Date.now();
     const controller = new AbortController();
     this.autoRejoinController = controller;
+    const remainingMs = Math.max(
+      this.autoRejoinOptions.timeoutMs - (Date.now() - this.recoveryStartedAt),
+      0
+    );
     const timeout = globalThis.setTimeout(() => {
       if (controller.signal.aborted) return;
       const error = new Error("Session recovery timed out");
@@ -1336,7 +1467,7 @@ var RealtimeSession = class _RealtimeSession {
       this.replacementContext.clear(error);
       this.failRecovery(error);
       this.setState("failed");
-    }, this.autoRejoinOptions.timeoutMs);
+    }, remainingMs);
     const promise = this.runAutoRejoin(initialError, controller.signal, details).finally(() => {
       globalThis.clearTimeout(timeout);
       if (this.autoRejoinController === controller) {
@@ -1382,6 +1513,11 @@ var RealtimeSession = class _RealtimeSession {
     this.setState("failed");
   }
   cancelRecovery() {
+    this.terminalReplayController?.abort();
+    this.terminalReplayController = null;
+    this.livekitResumeController?.abort();
+    this.livekitResumeController = null;
+    this.recoveryStartedAt = null;
     this.autoRejoinController?.abort();
     this.autoRejoinController = null;
     this.manualRejoinController?.abort();
@@ -1419,19 +1555,71 @@ var RealtimeSession = class _RealtimeSession {
       throw new SessionConfigurationError("audioTrack has already ended");
     }
   }
-  async fetchRoomToken(apiBase, signal) {
+  async measureRecoveryStage(stage, operation, recovering = true) {
+    if (!recovering) return operation();
+    const startedAt = Date.now();
+    this.recordDiagnostic({ operation: "connection_recovery", stage, status: "started" });
+    try {
+      const result = await operation();
+      this.recordDiagnostic({
+        operation: "connection_recovery",
+        stage,
+        status: "succeeded",
+        duration_ms: Date.now() - startedAt
+      });
+      return result;
+    } catch (error) {
+      this.recordDiagnostic({
+        operation: "connection_recovery",
+        stage,
+        status: "failed",
+        duration_ms: Date.now() - startedAt,
+        reason: error instanceof RecoveryDataChannelStalledError ? "data_channel_stalled" : "stage_failed"
+      });
+      this.flushDiagnostics("recovery_stage_failed");
+      throw error;
+    }
+  }
+  async fetchRoomToken(apiBase, signal, recovering = true) {
     const controller = new AbortController();
     const cancel = () => controller.abort(signal?.reason);
     signal?.addEventListener("abort", cancel, { once: true });
     const timeout = globalThis.setTimeout(() => controller.abort(), 1e4);
+    const startedAt = Date.now();
+    if (recovering) {
+      this.recordDiagnostic({ operation: "connection_recovery", stage: "token_request", status: "started" });
+    }
     try {
       throwIfAborted(signal);
-      return await raceWithAbort(this.fetcher(`${apiBase}/sessions/${this.id}/room-tokens`, {
+      const response = await raceWithAbort(this.fetcher(`${apiBase}/sessions/${this.id}/room-tokens`, {
         method: "POST",
         headers: { Authorization: `Bearer ${this.accessToken}` },
         credentials: this.lifecycleCredentials,
         signal: controller.signal
       }), controller.signal);
+      if (recovering) {
+        this.recordDiagnostic({
+          operation: "connection_recovery",
+          stage: "token_request",
+          status: response.ok ? "succeeded" : "failed",
+          http_status: response.status,
+          duration_ms: Date.now() - startedAt
+        });
+        if (!response.ok) this.flushDiagnostics("recovery_stage_failed");
+      }
+      return response;
+    } catch (error) {
+      if (recovering) {
+        this.recordDiagnostic({
+          operation: "connection_recovery",
+          stage: "token_request",
+          status: "failed",
+          duration_ms: Date.now() - startedAt,
+          reason: signal?.aborted ? "cancelled" : controller.signal.aborted ? "request_timeout" : "request_failed"
+        });
+        this.flushDiagnostics("recovery_stage_failed");
+      }
+      throw error;
     } finally {
       globalThis.clearTimeout(timeout);
       signal?.removeEventListener("abort", cancel);
@@ -1563,6 +1751,36 @@ var RealtimeSession = class _RealtimeSession {
     await this.sendTrackedCommand(message, CLIENT_HELLO_TIMEOUT_MS);
     if (this.pendingReconnect === reconnect) this.pendingReconnect = null;
   }
+  async sendRecoveryHello(signal) {
+    throwIfAborted(signal);
+    let previousBytes = this.reliableDataChannelBufferedBytes();
+    let lastProgressAt = Date.now();
+    let timer;
+    const stalled = new Promise((_resolve, reject) => {
+      const checkProgress = () => {
+        const bufferedBytes = this.reliableDataChannelBufferedBytes();
+        if (bufferedBytes === void 0 || bufferedBytes === 0 || previousBytes === void 0 || previousBytes === 0 || bufferedBytes < previousBytes) {
+          lastProgressAt = Date.now();
+        } else if (Date.now() - lastProgressAt >= RECOVERY_BUFFER_STALL_MS) {
+          reject(new RecoveryDataChannelStalledError());
+          return;
+        }
+        previousBytes = bufferedBytes;
+        timer = globalThis.setTimeout(checkProgress, RECOVERY_BUFFER_POLL_MS);
+      };
+      timer = globalThis.setTimeout(checkProgress, RECOVERY_BUFFER_POLL_MS);
+    });
+    try {
+      await raceWithAbort(Promise.race([this.sendHello(), stalled]), signal);
+    } catch (error) {
+      if (error instanceof RecoveryDataChannelStalledError) {
+        this.rejectPendingCommands(error);
+      }
+      throw error;
+    } finally {
+      if (timer !== void 0) globalThis.clearTimeout(timer);
+    }
+  }
   async sendTrackedCommand(message, timeoutMs, retryTransfer) {
     const contextKey = contextKeyFromMessage(message);
     const payloadBytes = contextPayloadBytes(message.payload);
@@ -1579,10 +1797,14 @@ var RealtimeSession = class _RealtimeSession {
       timeout_ms: timeoutMs,
       event_type: diagnosticEventType(message.type)
     });
+    const sendController = message.type === "context.update" ? new AbortController() : void 0;
     let markSettled = () => {
     };
     const settled = new Promise((resolve) => {
-      markSettled = resolve;
+      markSettled = () => {
+        sendController?.abort();
+        resolve();
+      };
     });
     const response = new Promise((resolve, reject) => {
       const timeout = globalThis.setTimeout(() => {
@@ -1625,6 +1847,7 @@ var RealtimeSession = class _RealtimeSession {
           settled,
           markSettled,
           retryTransfer,
+          sendController,
           transferRetrying: false,
           transferRetryRequested: false
         }
@@ -1648,10 +1871,10 @@ var RealtimeSession = class _RealtimeSession {
     if (!pending) return;
     if (message.type === "context.update" && (this.sessionEnded || ["reconnecting", "resuming", "disconnected", "failed"].includes(this.stateValue))) return;
     try {
-      if (pending.transferRetryRequested && pending.retryTransfer) {
+      if (pending.transferRetryRequested && pending.retryTransfer && pending.sendController) {
         pending.transferRetryRequested = false;
         pending.transferRetrying = true;
-        const transfer = pending.retryTransfer();
+        const transfer = pending.retryTransfer(pending.sendController.signal);
         pending.transferSettled = transfer.then(() => {
         }, () => {
         });
@@ -1698,12 +1921,13 @@ var RealtimeSession = class _RealtimeSession {
     const attemptStartedAt = Date.now();
     try {
       let publishFinished = false;
-      const publish = this.publishCommand(message).then(() => {
+      const publish = this.publishCommand(message, pending.sendController?.signal).then(() => {
         publishFinished = true;
       });
       await Promise.race([publish, pending.settled]);
       if (!publishFinished) return;
     } catch (error) {
+      if (pending.sendController?.signal.aborted) return;
       this.recordDiagnostic({
         operation: "command_send",
         status: "failed",
@@ -1735,10 +1959,11 @@ var RealtimeSession = class _RealtimeSession {
     });
     if (durationMs > 2e3) this.flushDiagnostics("slow_operation");
   }
-  async publishCommand(message) {
+  async publishCommand(message, signal) {
+    const options = { reliable: true, topic: "voxevolv.commands", signal };
     await this.room.localParticipant.publishData(
       new TextEncoder().encode(JSON.stringify(message)),
-      { reliable: true, topic: "voxevolv.commands" }
+      options
     );
   }
   startDiagnosticLoopMonitor() {
@@ -1757,7 +1982,7 @@ var RealtimeSession = class _RealtimeSession {
       connection_state: this.stateValue,
       buffered_bytes: this.reliableDataChannelBufferedBytes()
     };
-    if (entry.operation === "tool_rpc") {
+    if (entry.operation === "tool_rpc" || entry.operation === "connection_recovery") {
       snapshot.page_visibility = globalThis.document?.visibilityState;
       snapshot.active_context_transfers = this.activeContextTransfers;
       snapshot.active_context_bytes = this.activeContextBytes;
@@ -1933,6 +2158,9 @@ var RealtimeSession = class _RealtimeSession {
     }
   }
   rejectPendingCommands(error, preserveContext = false) {
+    if (!preserveContext) {
+      for (const controller of this.contextTransferControllers) controller.abort(error);
+    }
     for (const [messageId, pending] of this.pendingCommands) {
       if (preserveContext && pending.commandType === "context.update") continue;
       this.recordCommandResult(