@voxevolv/client 0.3.9 → 0.3.11

package/dist/index.js

@@ -1,2293 +1,2303 @@
-import { ConnectionState as LiveKitConnectionState, DataPacket_Kind, DisconnectReason, LocalAudioTrack, Room, RoomEvent, RpcError, Track, } from "livekit-client";
-import { createClientMessage, CommandError, EventCursor, isCommandAckPayload, isCommandErrorPayload, isContextRejectedPayload, isContextUpdatePayload, isContextUpdatedPayload, isRealtimeEvent, } from "./protocol.js";
+// src/index.ts
+import {
+  ConnectionState as LiveKitConnectionState,
+  DataPacket_Kind,
+  DisconnectReason,
+  LocalAudioTrack,
+  Room,
+  RoomEvent,
+  RpcError,
+  Track
+} from "./vendor/livekit-client.esm.mjs";
+import {
+  createClientMessage,
+  CommandError,
+  EventCursor,
+  isCommandAckPayload,
+  isCommandErrorPayload,
+  isContextRejectedPayload,
+  isContextUpdatePayload,
+  isContextUpdatedPayload,
+  isRealtimeEvent
+} from "./protocol.js";
 import { ContextDeliveryError, contextRetryDelay, ReplacementContextQueue } from "./context-queue.js";
-import { ClientDiagnosticBuffer, DiagnosticDeliveryError, } from "./diagnostics.js";
+import {
+  ClientDiagnosticBuffer,
+  DiagnosticDeliveryError
+} from "./diagnostics.js";
 import { TranscriptStore } from "./transcripts.js";
-export { TranscriptStore } from "./transcripts.js";
-export { CommandError, EventCursor, createClientMessage, isCommandAckPayload, isCommandErrorPayload, isContextRejectedPayload, isContextUpdatePayload, isContextUpdatedPayload, isRealtimeEvent, } from "./protocol.js";
-export { decodeAgentSnapshotPayload, decodeClientHelloPayload, decodeClientMessage, decodeCommandAckPayload, decodeCommandErrorPayload, decodeContextRejectedPayload, decodeContextUpdatePayload, decodeContextUpdatedPayload, decodeRealtimeEvent, } from "./generated/protocol-codecs.js";
-export const SDK_VERSION = "0.3.9";
-const CLIENT_HELLO_TIMEOUT_MS = 30_000;
-const DIAGNOSTIC_REPORT_TIMEOUT_MS = 5_000;
-const DEFAULT_STARTUP_ATTEMPTS = [
-    { delayBeforeMs: 0, readyTimeoutMs: 15_000 },
-    { delayBeforeMs: 1_000, readyTimeoutMs: 20_000 },
-    { delayBeforeMs: 3_000, readyTimeoutMs: 50_000 },
+import { TranscriptStore as TranscriptStore2 } from "./transcripts.js";
+import {
+  CommandError as CommandError2,
+  EventCursor as EventCursor2,
+  createClientMessage as createClientMessage2,
+  isCommandAckPayload as isCommandAckPayload2,
+  isCommandErrorPayload as isCommandErrorPayload2,
+  isContextRejectedPayload as isContextRejectedPayload2,
+  isContextUpdatePayload as isContextUpdatePayload2,
+  isContextUpdatedPayload as isContextUpdatedPayload2,
+  isRealtimeEvent as isRealtimeEvent2
+} from "./protocol.js";
+import {
+  decodeAgentSnapshotPayload,
+  decodeClientHelloPayload,
+  decodeClientMessage,
+  decodeCommandAckPayload,
+  decodeCommandErrorPayload,
+  decodeContextRejectedPayload,
+  decodeContextUpdatePayload,
+  decodeContextUpdatedPayload,
+  decodeRealtimeEvent
+} from "./generated/protocol-codecs.js";
+var SDK_VERSION = "0.3.11";
+var CLIENT_HELLO_TIMEOUT_MS = 3e4;
+var DIAGNOSTIC_REPORT_TIMEOUT_MS = 5e3;
+var DEFAULT_STARTUP_ATTEMPTS = [
+  { delayBeforeMs: 0, readyTimeoutMs: 15e3 },
+  { delayBeforeMs: 1e3, readyTimeoutMs: 2e4 },
+  { delayBeforeMs: 3e3, readyTimeoutMs: 5e4 }
 ];
-const DEFAULT_STARTUP_TIMEOUT_MS = 90_000;
-export class RealtimeSessionHttpError extends Error {
-    status;
-    code;
-    requestId;
-    details;
-    constructor(message, options) {
-        super(message);
-        this.name = "RealtimeSessionHttpError";
-        this.status = options.status;
-        this.code = options.code ?? null;
-        this.requestId = options.requestId ?? null;
-        this.details = options.details ?? [];
-    }
-}
-class SessionConfigurationError extends TypeError {
-}
-class SessionErrorEventError extends Error {
-    retryable;
-    constructor(event) {
-        const payload = event.payload;
-        const message = typeof payload.message === "string"
-            ? payload.message
-            : "VoxEvolv reported a session error";
-        super(message);
-        this.name = "SessionErrorEventError";
-        this.retryable = payload.retryable === true;
-    }
-}
-export class RealtimeSession {
-    id;
-    room;
-    accessToken;
-    credentials;
-    stateValue = "idle";
-    listeners = new Set();
-    stateListeners = new Set();
-    gapListeners = new Set();
-    connectionQualityListeners = new Set();
-    recoveryListeners = new Set();
-    startupAttemptListeners = new Set();
-    remoteAudioTrackListeners = new Set();
-    remoteAudioTrackUnsubscribedListeners = new Set();
-    readyListeners = new Set();
-    userTranscriptListeners = new Set();
-    agentTranscriptListeners = new Set();
-    transcriptListeners = new Set();
-    transcriptStore = new TranscriptStore();
-    errorListeners = new Set();
-    endedListeners = new Set();
-    toolCallListeners = new Set();
-    audioPlaybackBlockedListeners = new Set();
-    remoteAudioStreams = new WeakMap();
-    outputMediaStream = null;
-    remoteAudioTrackResolve = null;
-    cursor = new EventCursor();
-    connectionId = `conn_${Math.random().toString(36).slice(2)}_${Date.now().toString(36)}`;
-    clientSeq = 0;
-    lastHelloMessageId = null;
-    reconnectStartedAt = null;
-    pendingReconnect = null;
-    agentReady = false;
-    agentStreamId = null;
-    contextGeneration = 0;
-    replacementContext = new ReplacementContextQueue((update, timeoutMs) => this.sendContextUpdate(update, timeoutMs));
-    readyResolve = null;
-    replayPromise = null;
-    pendingCommands = new Map();
-    commandPublishTail = Promise.resolve();
-    toolHandlers = new Map();
-    apiBase = "/v1";
-    hasConnectedValue = false;
-    sessionEnded = false;
-    pendingEndEvent = null;
-    agentDisconnected = false;
-    terminalSessionError = null;
-    endNotificationDelivered = false;
-    disconnectMode = null;
-    activeRecovery = null;
-    autoRejoinPromise = null;
-    autoRejoinController = null;
-    manualRejoinController = null;
-    startupConnectController = null;
-    startupAttemptController = null;
-    useManagedMicrophone = true;
-    microphoneEnabled = true;
-    applicationAudioTrack = null;
-    localApplicationAudioTrack = null;
-    connectDefaults;
-    recoveryReadiness;
-    credentialRefreshGeneration = 0;
-    fetcher;
-    endEndpoint;
-    refreshCredentialsCallback;
-    autoRejoinOptions;
-    startupRetryOptions;
-    lifecycleCredentials;
-    diagnostics = new ClientDiagnosticBuffer({ sdkVersion: SDK_VERSION });
-    diagnosticReportTimeoutMs = DIAGNOSTIC_REPORT_TIMEOUT_MS;
-    onDiagnosticVisibilityChange = () => {
-        if (globalThis.document?.visibilityState === "hidden")
-            this.flushDiagnostics("page_hidden");
+var DEFAULT_STARTUP_TIMEOUT_MS = 9e4;
+var RealtimeSessionHttpError = class extends Error {
+  status;
+  code;
+  requestId;
+  details;
+  constructor(message, options) {
+    super(message);
+    this.name = "RealtimeSessionHttpError";
+    this.status = options.status;
+    this.code = options.code ?? null;
+    this.requestId = options.requestId ?? null;
+    this.details = options.details ?? [];
+  }
+};
+var SessionConfigurationError = class extends TypeError {
+};
+var SessionErrorEventError = class extends Error {
+  retryable;
+  constructor(event) {
+    const payload = event.payload;
+    const message = typeof payload.message === "string" ? payload.message : "VoxEvolv reported a session error";
+    super(message);
+    this.name = "SessionErrorEventError";
+    this.retryable = payload.retryable === true;
+  }
+};
+var RealtimeSession = class _RealtimeSession {
+  id;
+  room;
+  accessToken;
+  credentials;
+  stateValue = "idle";
+  listeners = /* @__PURE__ */ new Set();
+  stateListeners = /* @__PURE__ */ new Set();
+  gapListeners = /* @__PURE__ */ new Set();
+  connectionQualityListeners = /* @__PURE__ */ new Set();
+  recoveryListeners = /* @__PURE__ */ new Set();
+  startupAttemptListeners = /* @__PURE__ */ new Set();
+  remoteAudioTrackListeners = /* @__PURE__ */ new Set();
+  remoteAudioTrackUnsubscribedListeners = /* @__PURE__ */ new Set();
+  readyListeners = /* @__PURE__ */ new Set();
+  userTranscriptListeners = /* @__PURE__ */ new Set();
+  agentTranscriptListeners = /* @__PURE__ */ new Set();
+  transcriptListeners = /* @__PURE__ */ new Set();
+  transcriptStore = new TranscriptStore();
+  errorListeners = /* @__PURE__ */ new Set();
+  endedListeners = /* @__PURE__ */ new Set();
+  toolCallListeners = /* @__PURE__ */ new Set();
+  audioPlaybackBlockedListeners = /* @__PURE__ */ new Set();
+  remoteAudioStreams = /* @__PURE__ */ new WeakMap();
+  outputMediaStream = null;
+  remoteAudioTrackResolve = null;
+  cursor = new EventCursor();
+  connectionId = `conn_${Math.random().toString(36).slice(2)}_${Date.now().toString(36)}`;
+  clientSeq = 0;
+  lastHelloMessageId = null;
+  reconnectStartedAt = null;
+  pendingReconnect = null;
+  agentReady = false;
+  agentStreamId = null;
+  contextGeneration = 0;
+  replacementContext = new ReplacementContextQueue(
+    (update, timeoutMs) => this.sendContextUpdate(update, timeoutMs)
+  );
+  readyResolve = null;
+  replayPromise = null;
+  pendingCommands = /* @__PURE__ */ new Map();
+  commandPublishTail = Promise.resolve();
+  toolHandlers = /* @__PURE__ */ new Map();
+  apiBase = "/v1";
+  hasConnectedValue = false;
+  sessionEnded = false;
+  pendingEndEvent = null;
+  agentDisconnected = false;
+  terminalSessionError = null;
+  endNotificationDelivered = false;
+  disconnectMode = null;
+  activeRecovery = null;
+  autoRejoinPromise = null;
+  autoRejoinController = null;
+  manualRejoinController = null;
+  startupConnectController = null;
+  startupAttemptController = null;
+  useManagedMicrophone = true;
+  microphoneEnabled = true;
+  applicationAudioTrack = null;
+  localApplicationAudioTrack = null;
+  connectDefaults;
+  recoveryReadiness;
+  credentialRefreshGeneration = 0;
+  fetcher;
+  endEndpoint;
+  refreshCredentialsCallback;
+  autoRejoinOptions;
+  startupRetryOptions;
+  lifecycleCredentials;
+  diagnostics = new ClientDiagnosticBuffer({ sdkVersion: SDK_VERSION });
+  activeContextTransfers = 0;
+  activeContextBytes = 0;
+  diagnosticLoopTimer;
+  diagnosticLoopExpectedAt = 0;
+  diagnosticLoopDelayMs;
+  diagnosticReportTimeoutMs = DIAGNOSTIC_REPORT_TIMEOUT_MS;
+  onDiagnosticVisibilityChange = () => {
+    if (globalThis.document?.visibilityState === "hidden") this.flushDiagnostics("page_hidden");
+  };
+  constructor(credentials, options = {}) {
+    validateSessionCredentials(credentials);
+    this.id = credentials.id;
+    this.accessToken = credentials.access_token;
+    this.credentials = credentials.connection;
+    this.connectDefaults = options.connect?.apiBase === void 0 ? options.connect ?? {} : { ...options.connect, apiBase: normalizeApiBase(options.connect.apiBase) };
+    this.apiBase = this.connectDefaults.apiBase ?? this.apiBase;
+    this.recoveryReadiness = {
+      readyTimeoutMs: this.connectDefaults.readyTimeoutMs ?? 15e3,
+      waitForRemoteAudio: this.connectDefaults.waitForRemoteAudio ?? true
     };
-    constructor(credentials, options = {}) {
-        validateSessionCredentials(credentials);
-        this.id = credentials.id;
-        this.accessToken = credentials.access_token;
-        this.credentials = credentials.connection;
-        this.connectDefaults = options.connect?.apiBase === undefined
-            ? (options.connect ?? {})
-            : { ...options.connect, apiBase: normalizeApiBase(options.connect.apiBase) };
-        this.apiBase = this.connectDefaults.apiBase ?? this.apiBase;
-        this.recoveryReadiness = {
-            readyTimeoutMs: this.connectDefaults.readyTimeoutMs ?? 15_000,
-            waitForRemoteAudio: this.connectDefaults.waitForRemoteAudio ?? true,
-        };
-        this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
-        this.endEndpoint = options.endEndpoint ?? null;
-        this.refreshCredentialsCallback = options.refreshCredentials ?? null;
-        this.autoRejoinOptions = resolveAutoRejoinOptions(options.autoRejoin);
-        this.startupRetryOptions = resolveStartupRetryOptions(options.startupRetry);
-        this.lifecycleCredentials = options.lifecycleCredentials ?? "same-origin";
-        this.room = new Room({ adaptiveStream: true, dynacast: true });
-        for (const [name, handler] of Object.entries(options.tools ?? {})) {
-            this.registerTool(name, handler);
-        }
-        this.room.registerRpcMethod("voxevolv.tool.invoke", async (invocation) => {
-            let payload;
-            try {
-                payload = JSON.parse(invocation.payload);
-            }
-            catch (error) {
-                throw new RpcError(1500, "Tool invocation payload was not valid JSON", undefined, { cause: error });
-            }
-            if (typeof payload.name !== "string") {
-                throw new RpcError(1500, "Tool invocation did not include a valid name");
-            }
-            const handler = this.toolHandlers.get(payload.name);
-            if (!handler)
-                throw new RpcError(1500, `No browser handler is registered for ${payload.name}`);
-            if (!payload.arguments || typeof payload.arguments !== "object" || Array.isArray(payload.arguments)) {
-                throw new RpcError(1500, "Tool invocation arguments must be an object");
-            }
-            const callId = typeof payload.call_id === "string" ? payload.call_id : invocation.requestId;
-            const arguments_ = payload.arguments;
-            this.notifyListeners(this.toolCallListeners, {
-                name: payload.name,
-                callId,
-                arguments: arguments_,
-            });
-            try {
-                const result = await handler(arguments_, { callId });
-                return JSON.stringify(result ?? null);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : "Browser tool handler failed";
-                throw new RpcError(1500, message, undefined, { cause: error });
-            }
-        });
-        this.bindRoomEvents();
-    }
-    static async create(options) {
-        if ("connect" in options) {
-            throw new TypeError("RealtimeSession.create() accepts apiBase and media options at the top level, not in connect");
-        }
-        const { endpoint, request, microphone, audioTrack, readyTimeoutMs, waitForRemoteAudio, apiBase, ...sessionOptions } = options;
-        if (!endpoint)
-            throw new TypeError("endpoint is required");
-        if (!apiBase) {
-            throw new TypeError("apiBase is required so rejoin, replay, and end use the intended VoxEvolv API or application proxy");
-        }
-        const normalizedApiBase = normalizeApiBase(apiBase);
-        const fetcher = sessionOptions.fetch ?? globalThis.fetch.bind(globalThis);
-        const response = await fetcher(endpoint, { ...request, method: "POST" });
-        if (!response.ok)
-            throw await httpError(response, "Could not create realtime session");
-        const credentials = await response.json();
-        return new RealtimeSession(credentials, {
-            ...sessionOptions,
-            fetch: fetcher,
-            connect: { microphone, audioTrack, readyTimeoutMs, waitForRemoteAudio, apiBase: normalizedApiBase },
-        });
-    }
-    get state() {
-        return this.stateValue;
-    }
-    get hasConnectedBefore() {
-        return this.hasConnectedValue;
-    }
-    /**
-     * Stable stream holding the agent's current remote audio tracks. The stream
-     * object never changes across track arrival, reconnects, or rejoin; tracks
-     * are added and removed as the room subscribes and unsubscribes them.
-     */
-    get outputStream() {
-        this.outputMediaStream ??= new MediaStream();
-        return this.outputMediaStream;
-    }
-    onEvent(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    onStateChange(listener) {
-        this.stateListeners.add(listener);
-        this.notifyListeners(new Set([listener]), this.stateValue);
-        return () => this.stateListeners.delete(listener);
-    }
-    onProtocolGap(listener) {
-        this.gapListeners.add(listener);
-        return () => this.gapListeners.delete(listener);
-    }
-    onConnectionQuality(listener) {
-        this.connectionQualityListeners.add(listener);
-        this.notifyListeners(new Set([listener]), this.room.localParticipant.connectionQuality);
-        return () => this.connectionQualityListeners.delete(listener);
-    }
-    onRecovery(listener) {
-        this.recoveryListeners.add(listener);
-        return () => this.recoveryListeners.delete(listener);
-    }
-    onStartupAttempt(listener) {
-        this.startupAttemptListeners.add(listener);
-        return () => this.startupAttemptListeners.delete(listener);
-    }
-    waitForState(states, timeoutMs, options = {}) {
-        if (!states.length)
-            throw new TypeError("states must contain at least one connection state");
-        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
-            throw new TypeError("timeoutMs must be a non-negative finite number");
-        }
-        const targets = new Set(states);
-        if (targets.has(this.stateValue))
-            return Promise.resolve(this.stateValue);
-        if (options.signal?.aborted) {
-            return Promise.reject(options.signal.reason ?? new DOMException("Aborted", "AbortError"));
-        }
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const finish = (state, error) => {
-                if (settled)
-                    return;
-                settled = true;
-                globalThis.clearTimeout(timeout);
-                this.stateListeners.delete(onState);
-                options.signal?.removeEventListener("abort", onAbort);
-                if (error !== undefined) {
-                    reject(error);
-                }
-                else if (state !== null) {
-                    resolve(state);
-                }
-            };
-            const onState = (state) => {
-                if (targets.has(state))
-                    finish(state);
-            };
-            const onAbort = () => {
-                finish(null, options.signal?.reason ?? new DOMException("Aborted", "AbortError"));
-            };
-            const timeout = globalThis.setTimeout(() => {
-                finish(null, new Error(`Session did not reach ${states.join(" or ")} within ${timeoutMs}ms`));
-            }, timeoutMs);
-            this.stateListeners.add(onState);
-            options.signal?.addEventListener("abort", onAbort, { once: true });
-        });
-    }
-    onRemoteAudioTrack(listener) {
-        this.remoteAudioTrackListeners.add(listener);
-        return () => this.remoteAudioTrackListeners.delete(listener);
-    }
-    onRemoteAudioTrackUnsubscribed(listener) {
-        this.remoteAudioTrackUnsubscribedListeners.add(listener);
-        return () => this.remoteAudioTrackUnsubscribedListeners.delete(listener);
-    }
-    onReady(listener) {
-        this.readyListeners.add(listener);
-        return () => this.readyListeners.delete(listener);
-    }
-    onUserTranscript(listener) {
-        this.userTranscriptListeners.add(listener);
-        return () => this.userTranscriptListeners.delete(listener);
-    }
-    onAgentTranscript(listener) {
-        this.agentTranscriptListeners.add(listener);
-        return () => this.agentTranscriptListeners.delete(listener);
-    }
-    /** Latest message snapshots, retained across transport recovery and replay. */
-    get transcript() {
-        return this.transcriptStore.snapshot;
-    }
-    onTranscriptUpdated(listener) {
-        this.transcriptListeners.add(listener);
-        return () => this.transcriptListeners.delete(listener);
-    }
-    onError(listener) {
-        this.errorListeners.add(listener);
-        return () => this.errorListeners.delete(listener);
-    }
-    onEnded(listener) {
-        this.endedListeners.add(listener);
-        return () => this.endedListeners.delete(listener);
-    }
-    onToolCall(listener) {
-        this.toolCallListeners.add(listener);
-        return () => this.toolCallListeners.delete(listener);
+    this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.endEndpoint = options.endEndpoint ?? null;
+    this.refreshCredentialsCallback = options.refreshCredentials ?? null;
+    this.autoRejoinOptions = resolveAutoRejoinOptions(options.autoRejoin);
+    this.startupRetryOptions = resolveStartupRetryOptions(options.startupRetry);
+    this.lifecycleCredentials = options.lifecycleCredentials ?? "same-origin";
+    this.room = new Room({ adaptiveStream: true, dynacast: true });
+    for (const [name, handler] of Object.entries(options.tools ?? {})) {
+      this.registerTool(name, handler);
+    }
+    this.room.registerRpcMethod("voxevolv.tool.invoke", (invocation) => this.invokeBrowserTool(invocation));
+    this.room.registerRpcMethod("voxevolv.diagnostics.flush", async (invocation) => {
+      const payload = JSON.parse(invocation.payload);
+      if (typeof payload?.call_id !== "string" || payload.call_id.length > 200) {
+        throw new RpcError(1500, "Invalid diagnostic request");
+      }
+      this.recordDiagnostic({
+        operation: "tool_rpc",
+        status: "started",
+        stage: "flush_requested",
+        call_id: payload.call_id,
+        rpc_request_id: invocation.requestId
+      });
+      this.flushDiagnostics("tool_rpc_worker_request");
+      return "{}";
+    });
+    this.bindRoomEvents();
+  }
+  async invokeBrowserTool(invocation) {
+    const receivedAt = performance.now();
+    let callId;
+    let toolName;
+    let slowTimer;
+    const record = (entry) => this.recordDiagnostic({
+      operation: "tool_rpc",
+      status: "started",
+      rpc_request_id: invocation.requestId,
+      call_id: callId,
+      tool_name: toolName,
+      duration_ms: performance.now() - receivedAt,
+      ...entry
+    });
+    record({ stage: "received" });
+    try {
+      let payload;
+      try {
+        payload = JSON.parse(invocation.payload);
+      } catch (error) {
+        throw new RpcError(1500, "Tool invocation payload was not valid JSON", void 0, { cause: error });
+      }
+      if (typeof payload?.name !== "string") {
+        throw new RpcError(1500, "Tool invocation did not include a valid name");
+      }
+      toolName = payload.name;
+      callId = typeof payload.call_id === "string" ? payload.call_id : invocation.requestId;
+      const handler = this.toolHandlers.get(toolName);
+      if (!handler) throw new RpcError(1500, `No browser handler is registered for ${toolName}`);
+      if (!payload.arguments || typeof payload.arguments !== "object" || Array.isArray(payload.arguments)) {
+        throw new RpcError(1500, "Tool invocation arguments must be an object");
+      }
+      const arguments_ = payload.arguments;
+      this.notifyListeners(this.toolCallListeners, { name: toolName, callId, arguments: arguments_ });
+      record({ stage: "handler_started" });
+      this.flushDiagnostics("tool_rpc_received");
+      slowTimer = globalThis.setTimeout(() => {
+        record({ stage: "handler_started", reason: "handler_slow" });
+        this.flushDiagnostics("tool_rpc_slow");
+      }, 2e3);
+      let response;
+      try {
+        const result = await handler(arguments_, { callId });
+        response = JSON.stringify(result ?? null);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Browser tool handler failed";
+        throw new RpcError(1500, message, void 0, { cause: error });
+      }
+      record({ stage: "response_ready", status: "succeeded" });
+      return response;
+    } catch (error) {
+      record({ status: "failed", rpc_error_code: error instanceof RpcError ? error.code : void 0 });
+      throw error;
+    } finally {
+      globalThis.clearTimeout(slowTimer);
+      this.flushDiagnostics("tool_rpc_finished");
+    }
+  }
+  static async create(options) {
+    if ("connect" in options) {
+      throw new TypeError(
+        "RealtimeSession.create() accepts apiBase and media options at the top level, not in connect"
+      );
+    }
+    const {
+      endpoint,
+      request,
+      microphone,
+      audioTrack,
+      readyTimeoutMs,
+      waitForRemoteAudio,
+      apiBase,
+      ...sessionOptions
+    } = options;
+    if (!endpoint) throw new TypeError("endpoint is required");
+    if (!apiBase) {
+      throw new TypeError(
+        "apiBase is required so rejoin, replay, and end use the intended VoxEvolv API or application proxy"
+      );
+    }
+    const normalizedApiBase = normalizeApiBase(apiBase);
+    const fetcher = sessionOptions.fetch ?? globalThis.fetch.bind(globalThis);
+    const response = await fetcher(endpoint, { ...request, method: "POST" });
+    if (!response.ok) throw await httpError(response, "Could not create realtime session");
+    const credentials = await response.json();
+    return new _RealtimeSession(credentials, {
+      ...sessionOptions,
+      fetch: fetcher,
+      connect: { microphone, audioTrack, readyTimeoutMs, waitForRemoteAudio, apiBase: normalizedApiBase }
+    });
+  }
+  get state() {
+    return this.stateValue;
+  }
+  get hasConnectedBefore() {
+    return this.hasConnectedValue;
+  }
+  /**
+   * Stable stream holding the agent's current remote audio tracks. The stream
+   * object never changes across track arrival, reconnects, or rejoin; tracks
+   * are added and removed as the room subscribes and unsubscribes them.
+   */
+  get outputStream() {
+    this.outputMediaStream ??= new MediaStream();
+    return this.outputMediaStream;
+  }
+  onEvent(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    this.notifyListeners(/* @__PURE__ */ new Set([listener]), this.stateValue);
+    return () => this.stateListeners.delete(listener);
+  }
+  onProtocolGap(listener) {
+    this.gapListeners.add(listener);
+    return () => this.gapListeners.delete(listener);
+  }
+  onConnectionQuality(listener) {
+    this.connectionQualityListeners.add(listener);
+    this.notifyListeners(
+      /* @__PURE__ */ new Set([listener]),
+      this.room.localParticipant.connectionQuality
+    );
+    return () => this.connectionQualityListeners.delete(listener);
+  }
+  onRecovery(listener) {
+    this.recoveryListeners.add(listener);
+    return () => this.recoveryListeners.delete(listener);
+  }
+  onStartupAttempt(listener) {
+    this.startupAttemptListeners.add(listener);
+    return () => this.startupAttemptListeners.delete(listener);
+  }
+  waitForState(states, timeoutMs, options = {}) {
+    if (!states.length) throw new TypeError("states must contain at least one connection state");
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+      throw new TypeError("timeoutMs must be a non-negative finite number");
+    }
+    const targets = new Set(states);
+    if (targets.has(this.stateValue)) return Promise.resolve(this.stateValue);
+    if (options.signal?.aborted) {
+      return Promise.reject(options.signal.reason ?? new DOMException("Aborted", "AbortError"));
     }
-    onAudioPlaybackBlocked(listener) {
-        this.audioPlaybackBlockedListeners.add(listener);
-        return () => this.audioPlaybackBlockedListeners.delete(listener);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (state, error) => {
+        if (settled) return;
+        settled = true;
+        globalThis.clearTimeout(timeout);
+        this.stateListeners.delete(onState);
+        options.signal?.removeEventListener("abort", onAbort);
+        if (error !== void 0) {
+          reject(error);
+        } else if (state !== null) {
+          resolve(state);
+        }
+      };
+      const onState = (state) => {
+        if (targets.has(state)) finish(state);
+      };
+      const onAbort = () => {
+        finish(null, options.signal?.reason ?? new DOMException("Aborted", "AbortError"));
+      };
+      const timeout = globalThis.setTimeout(() => {
+        finish(
+          null,
+          new Error(`Session did not reach ${states.join(" or ")} within ${timeoutMs}ms`)
+        );
+      }, timeoutMs);
+      this.stateListeners.add(onState);
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  onRemoteAudioTrack(listener) {
+    this.remoteAudioTrackListeners.add(listener);
+    return () => this.remoteAudioTrackListeners.delete(listener);
+  }
+  onRemoteAudioTrackUnsubscribed(listener) {
+    this.remoteAudioTrackUnsubscribedListeners.add(listener);
+    return () => this.remoteAudioTrackUnsubscribedListeners.delete(listener);
+  }
+  onReady(listener) {
+    this.readyListeners.add(listener);
+    return () => this.readyListeners.delete(listener);
+  }
+  onUserTranscript(listener) {
+    this.userTranscriptListeners.add(listener);
+    return () => this.userTranscriptListeners.delete(listener);
+  }
+  onAgentTranscript(listener) {
+    this.agentTranscriptListeners.add(listener);
+    return () => this.agentTranscriptListeners.delete(listener);
+  }
+  /** Latest message snapshots, retained across transport recovery and replay. */
+  get transcript() {
+    return this.transcriptStore.snapshot;
+  }
+  onTranscriptUpdated(listener) {
+    this.transcriptListeners.add(listener);
+    return () => this.transcriptListeners.delete(listener);
+  }
+  onError(listener) {
+    this.errorListeners.add(listener);
+    return () => this.errorListeners.delete(listener);
+  }
+  onEnded(listener) {
+    this.endedListeners.add(listener);
+    return () => this.endedListeners.delete(listener);
+  }
+  onToolCall(listener) {
+    this.toolCallListeners.add(listener);
+    return () => this.toolCallListeners.delete(listener);
+  }
+  onAudioPlaybackBlocked(listener) {
+    this.audioPlaybackBlockedListeners.add(listener);
+    return () => this.audioPlaybackBlockedListeners.delete(listener);
+  }
+  registerTool(name, handler) {
+    if (["connecting", "connected_not_ready", "connected", "reconnecting", "resuming"].includes(this.stateValue)) {
+      throw new Error("Browser tools must be registered before connect()");
+    }
+    if (!/^[a-z][a-z0-9_]{0,79}$/.test(name)) {
+      throw new TypeError("Tool name must be lowercase letters, numbers, and underscores");
+    }
+    if (this.toolHandlers.has(name)) throw new TypeError(`Tool ${name} is already registered`);
+    this.toolHandlers.set(name, handler);
+    return () => {
+      if (this.toolHandlers.get(name) === handler) this.toolHandlers.delete(name);
+    };
+  }
+  async connect(options = {}) {
+    if (this.startupConnectController || this.manualRejoinController) {
+      throw new Error("A session connection attempt is already in progress");
     }
-    registerTool(name, handler) {
-        if (["connecting", "connected_not_ready", "connected", "reconnecting", "resuming"]
-            .includes(this.stateValue)) {
-            throw new Error("Browser tools must be registered before connect()");
-        }
-        if (!/^[a-z][a-z0-9_]{0,79}$/.test(name)) {
-            throw new TypeError("Tool name must be lowercase letters, numbers, and underscores");
-        }
-        if (this.toolHandlers.has(name))
-            throw new TypeError(`Tool ${name} is already registered`);
-        this.toolHandlers.set(name, handler);
-        return () => {
-            if (this.toolHandlers.get(name) === handler)
-                this.toolHandlers.delete(name);
-        };
+    if (["connecting", "connected_not_ready", "connected", "reconnecting", "resuming"].includes(this.stateValue)) {
+      throw new Error(`Cannot connect while session is ${this.stateValue}`);
     }
-    async connect(options = {}) {
-        if (this.startupConnectController || this.manualRejoinController) {
-            throw new Error("A session connection attempt is already in progress");
-        }
-        if (["connecting", "connected_not_ready", "connected", "reconnecting", "resuming"]
-            .includes(this.stateValue)) {
-            throw new Error(`Cannot connect while session is ${this.stateValue}`);
-        }
-        this.cancelRecovery();
-        const controller = new AbortController();
-        this.startupConnectController = controller;
-        this.credentialRefreshGeneration += 1;
-        const resolved = { ...this.connectDefaults, ...options };
-        // Keep caller preferences separate from temporary startup-attempt budgets.
-        this.recoveryReadiness = {
-            readyTimeoutMs: resolved.readyTimeoutMs ?? 15_000,
-            waitForRemoteAudio: resolved.waitForRemoteAudio ?? true,
-        };
-        this.microphoneEnabled = resolved.audioTrack
-            ? resolved.audioTrack.enabled !== false
-            : resolved.microphone ?? true;
-        this.setState("connecting");
+    this.cancelRecovery();
+    const controller = new AbortController();
+    this.startupConnectController = controller;
+    this.credentialRefreshGeneration += 1;
+    const resolved = { ...this.connectDefaults, ...options };
+    this.recoveryReadiness = {
+      readyTimeoutMs: resolved.readyTimeoutMs ?? 15e3,
+      waitForRemoteAudio: resolved.waitForRemoteAudio ?? true
+    };
+    this.microphoneEnabled = resolved.audioTrack ? resolved.audioTrack.enabled !== false : resolved.microphone ?? true;
+    this.setState("connecting");
+    try {
+      if (this.startupRetryOptions) {
+        await this.connectWithStartupRetry(options, controller);
+      } else {
+        this.startupAttemptController = controller;
+        await this.connectWithMode(options, false, controller.signal, false);
+      }
+    } catch (error) {
+      if (this.startupConnectController === controller && this.terminalSessionError) {
+        this.sessionEnded = true;
+        this.setState("failed");
+      } else if (this.startupConnectController === controller && !this.sessionEnded) {
+        this.setState("failed");
+      }
+      throw error;
+    } finally {
+      if (this.startupAttemptController === controller) {
+        this.startupAttemptController = null;
+      }
+      if (this.startupConnectController === controller) {
+        this.startupConnectController = null;
+      }
+    }
+  }
+  async connectWithStartupRetry(options, controller) {
+    const startupOptions = this.startupRetryOptions;
+    if (!startupOptions) return;
+    const startupStartedAt = performance.now();
+    const timeout = globalThis.setTimeout(() => {
+      controller.abort(new Error(
+        `Session startup did not complete within ${startupOptions.timeoutMs}ms`
+      ));
+    }, startupOptions.timeoutMs);
+    let lastError = new Error("Session startup failed");
+    let startupRegistered = this.hasConnectedValue;
+    this.apiBase = normalizeApiBase(options.apiBase ?? this.connectDefaults.apiBase ?? this.apiBase);
+    try {
+      for (const [index, attempt] of startupOptions.attempts.entries()) {
+        const attemptNumber = index + 1;
+        if (attempt.delayBeforeMs > 0) {
+          this.setState("connecting");
+          await abortableDelay(attempt.delayBeforeMs, controller.signal);
+        }
+        throwIfAborted(controller.signal);
+        const attemptController = createLinkedAbortController(controller.signal);
+        this.startupAttemptController = attemptController;
+        this.notifyStartupAttempt("started", attemptNumber, attempt.readyTimeoutMs);
         try {
-            if (this.startupRetryOptions) {
-                await this.connectWithStartupRetry(options, controller);
-            }
-            else {
-                this.startupAttemptController = controller;
-                await this.connectWithMode(options, false, controller.signal, false);
-            }
-        }
-        catch (error) {
-            if (this.startupConnectController === controller && this.terminalSessionError) {
-                this.sessionEnded = true;
-                this.setState("failed");
-            }
-            else if (this.startupConnectController === controller && !this.sessionEnded) {
-                this.setState("failed");
-            }
+          if (!startupRegistered) {
+            const remainingMs = startupOptions.timeoutMs - (performance.now() - startupStartedAt);
+            await this.registerStartupRecovery(remainingMs, attemptController.signal);
+            startupRegistered = true;
+          }
+          throwIfAborted(attemptController.signal);
+          if (index === 0) {
+            await this.connectWithMode(
+              { ...options, readyTimeoutMs: attempt.readyTimeoutMs },
+              false,
+              attemptController.signal,
+              false
+            );
+          } else {
+            await this.performRejoin(this.apiBase, {
+              signal: attemptController.signal,
+              recovering: false,
+              connect: { ...options, readyTimeoutMs: attempt.readyTimeoutMs },
+              markFailureTerminal: false
+            });
+          }
+          throwIfAborted(controller.signal);
+          this.notifyStartupAttempt("succeeded", attemptNumber, attempt.readyTimeoutMs);
+          return;
+        } catch (error) {
+          lastError = toError(error);
+          this.notifyStartupAttempt("failed", attemptNumber, attempt.readyTimeoutMs, lastError);
+          if (controller.signal.aborted) throw abortError(controller.signal);
+          if (isTerminalStartupError(error) || attemptNumber === startupOptions.attempts.length) {
             throw error;
-        }
-        finally {
-            if (this.startupAttemptController === controller) {
-                this.startupAttemptController = null;
-            }
-            if (this.startupConnectController === controller) {
-                this.startupConnectController = null;
-            }
-        }
-    }
-    async connectWithStartupRetry(options, controller) {
-        const startupOptions = this.startupRetryOptions;
-        if (!startupOptions)
-            return;
-        const startupStartedAt = performance.now();
-        const timeout = globalThis.setTimeout(() => {
-            controller.abort(new Error(`Session startup did not complete within ${startupOptions.timeoutMs}ms`));
-        }, startupOptions.timeoutMs);
-        let lastError = new Error("Session startup failed");
-        let startupRegistered = this.hasConnectedValue;
-        this.apiBase = normalizeApiBase(options.apiBase ?? this.connectDefaults.apiBase ?? this.apiBase);
-        try {
-            for (const [index, attempt] of startupOptions.attempts.entries()) {
-                const attemptNumber = index + 1;
-                if (attempt.delayBeforeMs > 0) {
-                    this.setState("connecting");
-                    await abortableDelay(attempt.delayBeforeMs, controller.signal);
-                }
-                throwIfAborted(controller.signal);
-                const attemptController = createLinkedAbortController(controller.signal);
-                this.startupAttemptController = attemptController;
-                this.notifyStartupAttempt("started", attemptNumber, attempt.readyTimeoutMs);
-                try {
-                    if (!startupRegistered) {
-                        const remainingMs = startupOptions.timeoutMs - (performance.now() - startupStartedAt);
-                        await this.registerStartupRecovery(remainingMs, attemptController.signal);
-                        startupRegistered = true;
-                    }
-                    throwIfAborted(attemptController.signal);
-                    if (index === 0) {
-                        await this.connectWithMode({ ...options, readyTimeoutMs: attempt.readyTimeoutMs }, false, attemptController.signal, false);
-                    }
-                    else {
-                        await this.performRejoin(this.apiBase, {
-                            signal: attemptController.signal,
-                            recovering: false,
-                            connect: { ...options, readyTimeoutMs: attempt.readyTimeoutMs },
-                            markFailureTerminal: false,
-                        });
-                    }
-                    throwIfAborted(controller.signal);
-                    this.notifyStartupAttempt("succeeded", attemptNumber, attempt.readyTimeoutMs);
-                    return;
-                }
-                catch (error) {
-                    lastError = toError(error);
-                    this.notifyStartupAttempt("failed", attemptNumber, attempt.readyTimeoutMs, lastError);
-                    if (controller.signal.aborted)
-                        throw abortError(controller.signal);
-                    if (isTerminalStartupError(error) || attemptNumber === startupOptions.attempts.length) {
-                        throw error;
-                    }
-                    this.setState("connecting");
-                }
-                finally {
-                    if (this.startupAttemptController === attemptController) {
-                        this.startupAttemptController = null;
-                    }
-                }
-            }
-            throw lastError;
-        }
-        finally {
-            globalThis.clearTimeout(timeout);
-        }
-    }
-    async registerStartupRecovery(timeoutMs, signal) {
-        const reserveMs = Math.min(5_000, timeoutMs / 10);
-        const controller = createLinkedAbortController(signal);
-        const requestTimeout = globalThis.setTimeout(() => {
-            controller.abort(new Error("Startup registration timed out"));
-        }, Math.max(1, reserveMs));
-        try {
-            // Leave room for registration latency and final readiness before the
-            // browser's existing overall deadline. Rejoins never renew this window.
-            const send = () => raceWithAbort(this.fetcher(`${this.apiBase}/sessions/${this.id}/startup`, {
-                method: "POST",
-                headers: { Authorization: `Bearer ${this.accessToken}`, "Content-Type": "application/json" },
-                credentials: this.lifecycleCredentials,
-                body: JSON.stringify({ timeout_ms: Math.max(1, Math.floor(Math.min(timeoutMs - reserveMs, 85_000))) }),
-                signal: controller.signal,
-            }), controller.signal);
-            let response = await send();
-            if (response.status === 401 && this.refreshCredentialsCallback) {
-                await this.refreshCredentials(controller.signal);
-                response = await send();
-            }
-            if (!response.ok)
-                throw await httpError(response, "Could not register session startup");
-            const body = await raceWithAbort(response.json(), controller.signal);
-            if (typeof body.remaining_ms !== "number" || body.remaining_ms <= 0) {
-                throw new Error("Session startup window has expired");
-            }
-        }
-        finally {
-            globalThis.clearTimeout(requestTimeout);
-        }
-    }
-    notifyStartupAttempt(status, attempt, readyTimeoutMs, error) {
-        const maxAttempts = this.startupRetryOptions?.attempts.length ?? 1;
-        this.notifyListeners(this.startupAttemptListeners, {
-            status,
-            attempt,
-            maxAttempts,
-            readyTimeoutMs,
-            ...(error ? { error } : {}),
+          }
+          this.setState("connecting");
+        } finally {
+          if (this.startupAttemptController === attemptController) {
+            this.startupAttemptController = null;
+          }
+        }
+      }
+      throw lastError;
+    } finally {
+      globalThis.clearTimeout(timeout);
+    }
+  }
+  async registerStartupRecovery(timeoutMs, signal) {
+    const reserveMs = Math.min(5e3, timeoutMs / 10);
+    const controller = createLinkedAbortController(signal);
+    const requestTimeout = globalThis.setTimeout(() => {
+      controller.abort(new Error("Startup registration timed out"));
+    }, Math.max(1, reserveMs));
+    try {
+      const send = () => raceWithAbort(this.fetcher(`${this.apiBase}/sessions/${this.id}/startup`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.accessToken}`, "Content-Type": "application/json" },
+        credentials: this.lifecycleCredentials,
+        body: JSON.stringify({ timeout_ms: Math.max(1, Math.floor(Math.min(timeoutMs - reserveMs, 85e3))) }),
+        signal: controller.signal
+      }), controller.signal);
+      let response = await send();
+      if (response.status === 401 && this.refreshCredentialsCallback) {
+        await this.refreshCredentials(controller.signal);
+        response = await send();
+      }
+      if (!response.ok) throw await httpError(response, "Could not register session startup");
+      const body = await raceWithAbort(response.json(), controller.signal);
+      if (typeof body.remaining_ms !== "number" || body.remaining_ms <= 0) {
+        throw new Error("Session startup window has expired");
+      }
+    } finally {
+      globalThis.clearTimeout(requestTimeout);
+    }
+  }
+  notifyStartupAttempt(status, attempt, readyTimeoutMs, error) {
+    const maxAttempts = this.startupRetryOptions?.attempts.length ?? 1;
+    this.notifyListeners(this.startupAttemptListeners, {
+      status,
+      attempt,
+      maxAttempts,
+      readyTimeoutMs,
+      ...error ? { error } : {}
+    });
+  }
+  async connectWithMode(options, recovering, signal, markFailureTerminal = true) {
+    throwIfAborted(signal);
+    const blockedStates = recovering ? ["connecting", "connected_not_ready", "connected", "reconnecting"] : ["connecting", "connected_not_ready", "connected", "reconnecting", "resuming"];
+    const continuingStartupRetry = !recovering && !markFailureTerminal && this.stateValue === "connecting";
+    if (blockedStates.includes(this.stateValue) && !continuingStartupRetry) {
+      throw new Error(`Cannot connect while session is ${this.stateValue}`);
+    }
+    const generation = this.contextGeneration;
+    const resolved = { ...this.connectDefaults, ...options };
+    const audioTrack = resolved.audioTrack ?? null;
+    const microphone = resolved.microphone ?? audioTrack === null;
+    const readyTimeoutMs = resolved.readyTimeoutMs ?? 15e3;
+    const waitForRemoteAudio = resolved.waitForRemoteAudio ?? true;
+    const apiBase = normalizeApiBase(resolved.apiBase ?? this.apiBase);
+    this.validateAudioOptions(microphone, audioTrack);
+    this.useManagedMicrophone = microphone;
+    this.applicationAudioTrack = audioTrack;
+    if (!recovering) {
+      this.sessionEnded = false;
+      this.agentStreamId = null;
+      this.reconnectStartedAt = null;
+      this.pendingEndEvent = null;
+      this.agentDisconnected = false;
+      this.terminalSessionError = null;
+      this.endNotificationDelivered = false;
+      this.setState("connecting");
+    } else {
+      this.setState("resuming");
+    }
+    this.apiBase = apiBase;
+    this.agentReady = false;
+    try {
+      await this.connectRoom(signal, recovering);
+      throwIfAborted(signal);
+      if (audioTrack) {
+        await raceWithAbort(this.publishApplicationAudioTrack(audioTrack), signal);
+      } else if (microphone) {
+        await raceWithAbort(
+          this.room.localParticipant.setMicrophoneEnabled(this.microphoneEnabled),
+          signal
+        );
+      }
+      throwIfAborted(signal);
+      this.setState(recovering ? "resuming" : "connected_not_ready");
+      await raceWithAbort(this.sendHello(), signal);
+      const readyDeadline = Date.now() + readyTimeoutMs;
+      await this.waitForAgentReady(readyTimeoutMs, signal);
+      if (waitForRemoteAudio) await this.waitForRemoteAudioTrack(readyDeadline, signal);
+      throwIfAborted(signal);
+      if (this.sessionEnded || generation !== this.contextGeneration) {
+        throw new Error("Connection restoration interrupted");
+      }
+      this.resumeContextDelivery(recovering);
+      throwIfAborted(signal);
+      if (this.sessionEnded || generation !== this.contextGeneration) {
+        throw new Error("Connection restoration interrupted");
+      }
+      this.hasConnectedValue = true;
+      this.setState("connected");
+    } catch (error) {
+      if (signal?.aborted) this.rejectPendingCommands(toError(abortError(signal)));
+      this.disconnectMode = recovering ? "rejoin" : "connect_failure";
+      try {
+        await this.room.disconnect();
+      } catch {
+      } finally {
+        this.disconnectMode = null;
+      }
+      if (!recovering && markFailureTerminal) this.setState("failed");
+      throw error;
+    }
+  }
+  connectRoom(signal, recovering) {
+    throwIfAborted(signal);
+    const connection = this.room.connect(this.credentials.url, this.credentials.token);
+    if (!signal) return connection;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const resolveOnce = () => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      const rejectOnce = (error) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      };
+      const onAbort = () => {
+        this.disconnectMode = recovering ? "rejoin" : "connect_failure";
+        void this.room.disconnect().catch(() => {
         });
+        rejectOnce(abortError(signal));
+      };
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      connection.then(resolveOnce, rejectOnce);
+    });
+  }
+  async rejoin(apiBase = this.apiBase) {
+    if (this.startupConnectController || this.manualRejoinController) {
+      throw new Error("A session connection attempt is already in progress");
     }
-    async connectWithMode(options, recovering, signal, markFailureTerminal = true) {
-        throwIfAborted(signal);
-        const blockedStates = recovering
-            ? ["connecting", "connected_not_ready", "connected", "reconnecting"]
-            : ["connecting", "connected_not_ready", "connected", "reconnecting", "resuming"];
-        const continuingStartupRetry = (!recovering
-            && !markFailureTerminal
-            && this.stateValue === "connecting");
-        if (blockedStates.includes(this.stateValue) && !continuingStartupRetry) {
-            throw new Error(`Cannot connect while session is ${this.stateValue}`);
-        }
-        const generation = this.contextGeneration;
-        const resolved = { ...this.connectDefaults, ...options };
-        const audioTrack = resolved.audioTrack ?? null;
-        const microphone = resolved.microphone ?? audioTrack === null;
-        const readyTimeoutMs = resolved.readyTimeoutMs ?? 15_000;
-        const waitForRemoteAudio = resolved.waitForRemoteAudio ?? true;
-        const apiBase = normalizeApiBase(resolved.apiBase ?? this.apiBase);
-        this.validateAudioOptions(microphone, audioTrack);
-        this.useManagedMicrophone = microphone;
-        this.applicationAudioTrack = audioTrack;
-        if (!recovering) {
-            this.sessionEnded = false;
-            this.agentStreamId = null;
-            this.reconnectStartedAt = null;
-            this.pendingEndEvent = null;
-            this.agentDisconnected = false;
-            this.terminalSessionError = null;
-            this.endNotificationDelivered = false;
-            this.setState("connecting");
-        }
-        else {
-            this.setState("resuming");
-        }
-        this.apiBase = apiBase;
-        this.agentReady = false;
-        try {
-            await this.connectRoom(signal, recovering);
-            throwIfAborted(signal);
-            if (audioTrack) {
-                await raceWithAbort(this.publishApplicationAudioTrack(audioTrack), signal);
-            }
-            else if (microphone) {
-                await raceWithAbort(this.room.localParticipant.setMicrophoneEnabled(this.microphoneEnabled), signal);
-            }
-            throwIfAborted(signal);
-            this.setState(recovering ? "resuming" : "connected_not_ready");
-            await raceWithAbort(this.sendHello(), signal);
-            const readyDeadline = Date.now() + readyTimeoutMs;
-            await this.waitForAgentReady(readyTimeoutMs, signal);
-            if (waitForRemoteAudio)
-                await this.waitForRemoteAudioTrack(readyDeadline, signal);
-            throwIfAborted(signal);
-            if (this.sessionEnded || generation !== this.contextGeneration) {
-                throw new Error("Connection restoration interrupted");
-            }
-            this.resumeContextDelivery(recovering);
-            throwIfAborted(signal);
-            if (this.sessionEnded || generation !== this.contextGeneration) {
-                throw new Error("Connection restoration interrupted");
-            }
-            this.hasConnectedValue = true;
-            this.setState("connected");
-        }
-        catch (error) {
-            if (signal?.aborted)
-                this.rejectPendingCommands(toError(abortError(signal)));
-            this.disconnectMode = recovering ? "rejoin" : "connect_failure";
-            try {
-                await this.room.disconnect();
-            }
-            catch {
-                // Preserve the original connection/readiness failure.
-            }
-            finally {
-                this.disconnectMode = null;
-            }
-            if (!recovering && markFailureTerminal)
-                this.setState("failed");
-            throw error;
-        }
-    }
-    connectRoom(signal, recovering) {
-        throwIfAborted(signal);
-        const connection = this.room.connect(this.credentials.url, this.credentials.token);
-        if (!signal)
-            return connection;
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const resolveOnce = () => {
-                if (settled)
-                    return;
-                settled = true;
-                signal.removeEventListener("abort", onAbort);
-                resolve();
-            };
-            const rejectOnce = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                signal.removeEventListener("abort", onAbort);
-                reject(error);
-            };
-            const onAbort = () => {
-                this.disconnectMode = recovering ? "rejoin" : "connect_failure";
-                void this.room.disconnect().catch(() => { });
-                rejectOnce(abortError(signal));
-            };
-            if (signal.aborted) {
-                onAbort();
-            }
-            else {
-                signal.addEventListener("abort", onAbort, { once: true });
-            }
-            connection.then(resolveOnce, rejectOnce);
-        });
+    if (this.sessionEnded) {
+      throw this.terminalSessionError ?? new Error("Cannot rejoin a session that has ended");
     }
-    async rejoin(apiBase = this.apiBase) {
-        if (this.startupConnectController || this.manualRejoinController) {
-            throw new Error("A session connection attempt is already in progress");
-        }
-        if (this.sessionEnded) {
-            throw this.terminalSessionError ?? new Error("Cannot rejoin a session that has ended");
-        }
-        if (["connecting", "connected_not_ready", "reconnecting", "resuming"].includes(this.stateValue)) {
-            throw new Error(`Cannot rejoin while session is ${this.stateValue}`);
-        }
-        this.cancelRecovery();
-        const normalizedApiBase = normalizeApiBase(apiBase);
-        const recovering = this.hasConnectedValue;
-        const controller = new AbortController();
-        this.manualRejoinController = controller;
-        if (recovering) {
-            this.beginRecovery("rejoin", 1, { trigger: "manual_rejoin" });
-            this.setState("resuming");
-        }
-        try {
-            await this.performRejoin(normalizedApiBase, { recovering, signal: controller.signal });
-            if (this.sessionEnded)
-                return;
-            if (recovering)
-                this.completeRecovery();
-        }
-        catch (error) {
-            if (controller.signal.aborted && !this.terminalSessionError)
-                return;
-            const normalizedError = toError(error);
-            if (recovering)
-                this.failRecovery(normalizedError);
-            this.setState("failed");
-            throw error;
-        }
-        finally {
-            if (this.manualRejoinController === controller) {
-                this.manualRejoinController = null;
-            }
-        }
+    if (["connecting", "connected_not_ready", "reconnecting", "resuming"].includes(this.stateValue)) {
+      throw new Error(`Cannot rejoin while session is ${this.stateValue}`);
     }
-    async performRejoin(apiBase, options = {}) {
-        const { signal, recovering = true, connect, markFailureTerminal = true, } = options;
-        this.contextGeneration += 1;
-        this.replacementContext.pause();
-        this.rejectPendingCommands(new Error("Restoring the session"));
-        let response = await this.fetchRoomToken(apiBase, signal);
-        if (response.status === 401 && this.refreshCredentialsCallback) {
-            await this.refreshCredentials(signal);
-            throwIfAborted(signal);
-            response = await this.fetchRoomToken(apiBase, signal);
-        }
-        // A live ending may arrive while token renewal is in flight.
-        if (this.sessionEnded) {
-            if (this.terminalSessionError)
-                throw this.terminalSessionError;
-            return;
-        }
-        if (!response.ok) {
-            if (response.status === 409 && await this.recoverSessionEnd(apiBase, signal))
-                return;
-            throw await raceWithAbort(httpError(response, "Could not renew room token"), signal);
-        }
-        const payload = (await raceWithAbort(response.json(), signal));
-        throwIfAborted(signal);
-        this.credentials = payload.connection;
-        if (this.room.state !== LiveKitConnectionState.Disconnected) {
-            this.disconnectMode = "rejoin";
-            try {
-                await raceWithAbort(this.room.disconnect(), signal);
-            }
-            finally {
-                this.disconnectMode = null;
-            }
-        }
-        throwIfAborted(signal);
-        if (recovering && this.reconnectStartedAt !== null) {
-            this.pendingReconnect = {
-                started_at: new Date(this.reconnectStartedAt).toISOString(),
-                recovered_at: new Date().toISOString(),
-                duration_ms: Date.now() - this.reconnectStartedAt,
-            };
-        }
-        // Startup retries resolve the original caller options with constructor defaults.
-        // A later rejoin restores the audio settings saved by the previous connection.
-        const connectionOptions = connect ?? {
-            ...this.recoveryReadiness,
-            microphone: this.useManagedMicrophone,
-            ...(this.applicationAudioTrack ? { audioTrack: this.applicationAudioTrack } : {}),
-        };
-        await this.connectWithMode({ ...connectionOptions, apiBase }, recovering, signal, markFailureTerminal);
-    }
-    async setMicrophoneEnabled(enabled) {
-        // Recovery must see the user's latest intent while the media operation waits.
-        this.microphoneEnabled = enabled;
-        if (this.applicationAudioTrack) {
-            // The room may not know this track yet while publication is pending.
-            const track = this.localApplicationAudioTrack;
-            if (enabled)
-                await track?.unmute();
-            else
-                await track?.mute();
-            return;
-        }
-        await this.room.localParticipant.setMicrophoneEnabled(enabled);
+    this.cancelRecovery();
+    const normalizedApiBase = normalizeApiBase(apiBase);
+    const recovering = this.hasConnectedValue;
+    const controller = new AbortController();
+    this.manualRejoinController = controller;
+    if (recovering) {
+      this.beginRecovery("rejoin", 1, { trigger: "manual_rejoin" });
+      this.setState("resuming");
     }
-    async sendCommand(type, payload, timeoutMs = 10_000) {
-        const message = createClientMessage(this.connectionId, ++this.clientSeq, type, payload);
-        return this.sendTrackedCommand(message, timeoutMs);
+    try {
+      await this.performRejoin(normalizedApiBase, { recovering, signal: controller.signal });
+      if (this.sessionEnded) return;
+      if (recovering) this.completeRecovery();
+    } catch (error) {
+      if (controller.signal.aborted && !this.terminalSessionError) return;
+      const normalizedError = toError(error);
+      if (recovering) this.failRecovery(normalizedError);
+      this.setState("failed");
+      throw error;
+    } finally {
+      if (this.manualRejoinController === controller) {
+        this.manualRejoinController = null;
+      }
+    }
+  }
+  async performRejoin(apiBase, options = {}) {
+    const {
+      signal,
+      recovering = true,
+      connect,
+      markFailureTerminal = true
+    } = options;
+    this.contextGeneration += 1;
+    this.replacementContext.pause();
+    this.rejectPendingCommands(new Error("Restoring the session"));
+    let response = await this.fetchRoomToken(apiBase, signal);
+    if (response.status === 401 && this.refreshCredentialsCallback) {
+      await this.refreshCredentials(signal);
+      throwIfAborted(signal);
+      response = await this.fetchRoomToken(apiBase, signal);
+    }
+    if (this.sessionEnded) {
+      if (this.terminalSessionError) throw this.terminalSessionError;
+      return;
+    }
+    if (!response.ok) {
+      if (response.status === 409 && await this.recoverSessionEnd(apiBase, signal)) return;
+      throw await raceWithAbort(httpError(response, "Could not renew room token"), signal);
+    }
+    const payload = await raceWithAbort(response.json(), signal);
+    throwIfAborted(signal);
+    this.credentials = payload.connection;
+    if (this.room.state !== LiveKitConnectionState.Disconnected) {
+      this.disconnectMode = "rejoin";
+      try {
+        await raceWithAbort(this.room.disconnect(), signal);
+      } finally {
+        this.disconnectMode = null;
+      }
     }
-    async updateContext(update, timeoutMs = 20_000) {
-        if (this.sessionEnded || ["failed", "disconnected"].includes(this.stateValue)) {
-            throw new Error("Cannot update context while the session is inactive");
-        }
-        if (update.mode === "replace")
-            return this.replacementContext.submit(update, timeoutMs);
-        if (this.activeRecovery)
-            throw new Error("Cannot append context during recovery");
-        return this.sendContextUpdate(update, timeoutMs);
-    }
-    async sendContextUpdate(update, timeoutMs) {
-        const generation = this.contextGeneration;
-        const payloadBytes = contextUpdateBytes(update);
-        const transferStartedAt = Date.now();
-        let transferTimedOut = false;
-        this.recordDiagnostic({
-            operation: "context_transfer",
-            status: "started",
-            context_key: update.key,
-            payload_bytes: payloadBytes,
-        });
-        const uploading = "image" in update ? this.uploadImageContext(update) : this.uploadTextContext(update);
-        const transferSettled = uploading.then(() => { }, () => { });
-        let transferTimeout;
-        const transferExpired = new Promise((_resolve, reject) => {
-            transferTimeout = globalThis.setTimeout(() => {
-                transferTimedOut = true;
-                const error = new ContextDeliveryError(`Context transfer timed out after ${timeoutMs}ms`, {
-                    retryAfter: transferSettled,
-                });
-                this.recordDiagnostic({
-                    operation: "context_transfer",
-                    status: "timed_out",
-                    reason: "context_transfer_timeout",
-                    context_key: update.key,
-                    payload_bytes: payloadBytes,
-                    duration_ms: Date.now() - transferStartedAt,
-                    timeout_ms: timeoutMs,
-                });
-                this.flushDiagnostics("context_transfer_timeout");
-                reject(error);
-            }, timeoutMs);
+    throwIfAborted(signal);
+    if (recovering && this.reconnectStartedAt !== null) {
+      this.pendingReconnect = {
+        started_at: new Date(this.reconnectStartedAt).toISOString(),
+        recovered_at: (/* @__PURE__ */ new Date()).toISOString(),
+        duration_ms: Date.now() - this.reconnectStartedAt
+      };
+    }
+    const connectionOptions = connect ?? {
+      ...this.recoveryReadiness,
+      microphone: this.useManagedMicrophone,
+      ...this.applicationAudioTrack ? { audioTrack: this.applicationAudioTrack } : {}
+    };
+    await this.connectWithMode({ ...connectionOptions, apiBase }, recovering, signal, markFailureTerminal);
+  }
+  async setMicrophoneEnabled(enabled) {
+    this.microphoneEnabled = enabled;
+    if (this.applicationAudioTrack) {
+      const track = this.localApplicationAudioTrack;
+      if (enabled) await track?.unmute();
+      else await track?.mute();
+      return;
+    }
+    await this.room.localParticipant.setMicrophoneEnabled(enabled);
+  }
+  async sendCommand(type, payload, timeoutMs = 1e4) {
+    const message = createClientMessage(
+      this.connectionId,
+      ++this.clientSeq,
+      type,
+      payload
+    );
+    return this.sendTrackedCommand(message, timeoutMs);
+  }
+  async updateContext(update, timeoutMs = 2e4) {
+    if (this.sessionEnded || ["failed", "disconnected"].includes(this.stateValue)) {
+      throw new Error("Cannot update context while the session is inactive");
+    }
+    if (update.mode === "replace") return this.replacementContext.submit(update, timeoutMs);
+    if (this.activeRecovery) throw new Error("Cannot append context during recovery");
+    return this.sendContextUpdate(update, timeoutMs);
+  }
+  async sendContextUpdate(update, timeoutMs) {
+    const generation = this.contextGeneration;
+    const payloadBytes = contextUpdateBytes(update);
+    const transferStartedAt = Date.now();
+    let transferTimedOut = false;
+    this.recordDiagnostic({
+      operation: "context_transfer",
+      status: "started",
+      context_key: update.key,
+      payload_bytes: payloadBytes
+    });
+    this.activeContextTransfers += 1;
+    this.activeContextBytes += payloadBytes;
+    const uploading = ("image" in update ? this.uploadImageContext(update) : this.uploadTextContext(update)).finally(() => {
+      this.activeContextTransfers -= 1;
+      this.activeContextBytes -= payloadBytes;
+    });
+    const transferSettled = uploading.then(() => {
+    }, () => {
+    });
+    let transferTimeout;
+    const transferExpired = new Promise((_resolve, reject) => {
+      transferTimeout = globalThis.setTimeout(() => {
+        transferTimedOut = true;
+        const error = new ContextDeliveryError(`Context transfer timed out after ${timeoutMs}ms`, {
+          retryAfter: transferSettled
         });
-        let transfer;
-        try {
-            transfer = await Promise.race([
-                uploading,
-                transferExpired,
-            ]);
-        }
-        catch (error) {
-            if (!transferTimedOut) {
-                this.recordDiagnostic({
-                    operation: "context_transfer",
-                    status: "failed",
-                    reason: "context_transfer_failed",
-                    context_key: update.key,
-                    payload_bytes: payloadBytes,
-                    duration_ms: Date.now() - transferStartedAt,
-                });
-                this.flushDiagnostics("command_failed");
-            }
-            if (error instanceof TypeError || error instanceof ContextDeliveryError)
-                throw error;
-            throw new ContextDeliveryError(toError(error).message, { cause: error });
-        }
-        finally {
-            globalThis.clearTimeout(transferTimeout);
-        }
-        const transferDurationMs = Date.now() - transferStartedAt;
         this.recordDiagnostic({
-            operation: "context_transfer",
-            status: "succeeded",
-            context_key: update.key,
-            payload_bytes: payloadBytes,
-            duration_ms: transferDurationMs,
-        });
-        if (transferDurationMs > 2_000)
-            this.flushDiagnostics("slow_operation");
-        if (generation !== this.contextGeneration)
-            throw new Error("Context transfer interrupted by recovery");
-        const { payload } = transfer;
-        if (!isContextUpdatePayload(payload)) {
-            throw new TypeError("Invalid context update payload");
-        }
-        const message = createClientMessage(this.connectionId, ++this.clientSeq, "context.update", { ...payload });
-        return this.sendTrackedCommand(message, timeoutMs, transfer.resend);
-    }
-    resumeContextDelivery(restore) {
-        // Audio readiness owns connection recovery. Context delivery has its own
-        // deadlines and retries, and may be interrupted by a later disconnect.
-        void this.replacementContext.resume(restore).catch(() => { });
-    }
-    async uploadTextContext(update) {
-        const data = new TextEncoder().encode(update.text);
-        if (data.byteLength === 0)
-            throw new TypeError("Context text cannot be empty");
-        if (data.byteLength > 262_144) {
-            throw new TypeError("Context text must be at most 262144 UTF-8 bytes");
-        }
-        const base = {
-            key: update.key,
-            mode: update.mode,
-            label: update.label ?? "",
-            respond: update.respond ?? false,
-        };
-        if (data.byteLength <= 32_768)
-            return { payload: { ...base, text: update.text } };
-        const sha256 = await sha256Hex(data);
-        const streamId = contextStreamId();
-        const send = async () => {
-            const writer = await this.room.localParticipant.streamText({
-                streamId,
-                topic: "voxevolv.context.text",
-                totalSize: data.byteLength,
-                attributes: { sha256 },
-            });
-            await writer.write(update.text);
-            await writer.close();
-        };
-        await send();
-        return {
-            payload: {
-                ...base,
-                text_stream: { stream_id: streamId, bytes: data.byteLength, sha256 },
-            },
-            resend: send,
-        };
-    }
-    async uploadImageContext(update) {
-        const allowed = 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");
-        }
-        const data = new Uint8Array(await update.image.arrayBuffer());
-        if (data.byteLength === 0 || data.byteLength > 5_242_880) {
-            throw new TypeError("Image context must be between 1 byte and 5 MiB");
-        }
-        const sha256 = await sha256Hex(data);
-        const streamId = contextStreamId();
-        const send = async () => {
-            const writer = await this.room.localParticipant.streamBytes({
-                streamId,
-                topic: "voxevolv.context.image",
-                name: "context-image",
-                mimeType: update.image.type,
-                totalSize: data.byteLength,
-                attributes: { sha256 },
-            });
-            await writer.write(data);
-            await writer.close();
-        };
-        await send();
-        return {
-            payload: {
-                key: update.key,
-                mode: "replace",
-                label: update.label ?? "",
-                image: {
-                    stream_id: streamId,
-                    mime: update.image.type,
-                    bytes: data.byteLength,
-                    sha256,
-                    ...(update.width === undefined ? {} : { width: update.width }),
-                    ...(update.height === undefined ? {} : { height: update.height }),
-                    detail: update.detail ?? "low",
-                },
-                respond: update.respond ?? false,
-            },
-            resend: send,
-        };
-    }
-    async disconnect() {
-        this.abortStartupConnect(new Error("Session disconnected"));
-        this.startupConnectController = null;
-        this.failRecovery(new Error("Session disconnected during recovery"));
-        this.cancelRecovery();
-        this.contextGeneration += 1;
-        this.localApplicationAudioTrack = null;
-        this.replacementContext.clear(new Error("Session disconnected"));
-        if (this.stateValue === "disconnected")
-            return;
-        this.rejectPendingCommands(new Error("Session disconnected before command completion"));
-        this.disconnectMode = "intentional";
-        try {
-            await this.room.disconnect();
-        }
-        finally {
-            this.disconnectMode = null;
-            this.activeRecovery = null;
-            this.setState("disconnected");
-        }
-    }
-    async end(options = {}) {
-        this.credentialRefreshGeneration += 1;
-        this.abortStartupConnect(new Error("Session ended"));
-        this.startupConnectController = null;
-        this.failRecovery(new Error("Session ended during recovery"));
-        this.cancelRecovery();
-        this.sessionEnded = true;
-        const endpoint = options.endpoint ?? this.endEndpoint ?? `${this.apiBase}/sessions/${this.id}`;
-        const request = options.request ?? {};
-        const headers = new Headers(request.headers);
-        const usesScopedSessionEndpoint = !options.endpoint && !this.endEndpoint;
-        if (!headers.has("Authorization") && usesScopedSessionEndpoint) {
-            headers.set("Authorization", `Bearer ${this.accessToken}`);
-        }
-        let response = await this.fetcher(endpoint, {
-            ...request,
-            method: request.method ?? "DELETE",
-            headers,
-            credentials: request.credentials ?? this.lifecycleCredentials,
-        });
-        if (response.status === 401 && usesScopedSessionEndpoint && this.refreshCredentialsCallback) {
-            await this.refreshCredentials(request.signal ?? undefined);
-            headers.set("Authorization", `Bearer ${this.accessToken}`);
-            response = await this.fetcher(endpoint, {
-                ...request,
-                method: request.method ?? "DELETE",
-                headers,
-                credentials: request.credentials ?? this.lifecycleCredentials,
-            });
-        }
-        if (!response.ok)
-            throw await httpError(response, "Could not end realtime session");
-        if (options.disconnect ?? true)
-            await this.disconnect();
-    }
-    async replay(apiBase = this.apiBase, afterSeq = this.cursor.lastServerSeq) {
-        if (this.replayPromise)
-            return this.replayPromise;
-        const normalizedApiBase = normalizeApiBase(apiBase);
-        this.replayPromise = this.fetchReplay(normalizedApiBase, afterSeq).finally(() => {
-            this.replayPromise = null;
-        });
-        return this.replayPromise;
-    }
-    setState(state) {
-        if (this.stateValue === state)
-            return;
-        this.stateValue = state;
-        if (state === "connecting" || state === "resuming") {
-            globalThis.document?.addEventListener?.("visibilitychange", this.onDiagnosticVisibilityChange);
-        }
-        if (state === "disconnected" || state === "failed") {
-            globalThis.document?.removeEventListener?.("visibilitychange", this.onDiagnosticVisibilityChange);
-            this.flushDiagnostics("session_finished");
-            const error = new Error(`Session ${state}`);
-            this.contextGeneration += 1;
-            this.replacementContext.clear(error);
-            this.rejectPendingCommands(error);
-        }
-        this.notifyListeners(this.stateListeners, state);
-    }
-    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" });
-            }
-        });
-        this.room.on(RoomEvent.SignalReconnecting, () => this.handleLiveKitReconnecting());
-        this.room.on(RoomEvent.Reconnecting, () => this.handleLiveKitReconnecting());
-        this.room.on(RoomEvent.Reconnected, () => {
-            void this.handleLiveKitReconnected();
-        });
-        this.room.on(RoomEvent.Disconnected, (reason) => {
-            this.handleLiveKitDisconnected(reason);
-        });
-        this.room.on(RoomEvent.ConnectionStateChanged, (state) => {
-            if (this.sessionEnded || this.terminalSessionError)
-                return;
-            if (state === LiveKitConnectionState.Connected) {
-                const recovering = this.activeRecovery !== null || this.stateValue === "resuming";
-                this.setState(this.agentReady
-                    ? "connected"
-                    : recovering
-                        ? "resuming"
-                        : "connected_not_ready");
-            }
-        });
-        this.room.on(RoomEvent.ConnectionQualityChanged, (quality, participant) => {
-            if (!participant.isLocal)
-                return;
-            this.notifyListeners(this.connectionQualityListeners, quality);
-        });
-        this.room.on(RoomEvent.TrackSubscribed, (track) => {
-            if (track.kind !== Track.Kind.Audio)
-                return;
-            const element = track.attach();
-            element.dataset.voxevolvRemoteAudio = "true";
-            element.style.display = "none";
-            document.body.appendChild(element);
-            try {
-                const playback = element.play();
-                void playback.catch((error) => {
-                    this.notifyListeners(this.audioPlaybackBlockedListeners, {
-                        error,
-                        element,
-                        track: track.mediaStreamTrack,
-                    });
-                });
-            }
-            catch (error) {
-                this.notifyListeners(this.audioPlaybackBlockedListeners, {
-                    error,
-                    element,
-                    track: track.mediaStreamTrack,
-                });
-            }
-            const stream = new MediaStream([track.mediaStreamTrack]);
-            this.remoteAudioStreams.set(track, stream);
-            this.outputStream.addTrack(track.mediaStreamTrack);
-            this.notifyRemoteAudioListeners(this.remoteAudioTrackListeners, track.mediaStreamTrack, stream);
-            this.remoteAudioTrackResolve?.();
-        });
-        this.room.on(RoomEvent.TrackUnsubscribed, (track) => {
-            if (track.kind !== Track.Kind.Audio)
-                return;
-            const stream = this.remoteAudioStreams.get(track) ?? new MediaStream([track.mediaStreamTrack]);
-            this.notifyRemoteAudioListeners(this.remoteAudioTrackUnsubscribedListeners, track.mediaStreamTrack, stream);
-            this.remoteAudioStreams.delete(track);
-            this.outputMediaStream?.removeTrack(track.mediaStreamTrack);
-            track.detach().forEach((element) => element.remove());
-        });
-        this.room.on(RoomEvent.DataReceived, (data, _participant, kind, topic) => {
-            if (topic !== "voxevolv.events" || kind !== DataPacket_Kind.RELIABLE)
-                return;
-            let value;
-            try {
-                value = JSON.parse(new TextDecoder().decode(data));
-            }
-            catch {
-                // Ignore data from other room participants that is not a VoxEvolv envelope.
-                return;
-            }
-            if (!isRealtimeEvent(value))
-                return;
-            const result = this.cursor.accept(value);
-            if (result.gap) {
-                this.notifyListeners(this.gapListeners, result.gap);
-                void this.replay(this.apiBase, result.gap.after_server_seq);
-            }
-            if (!result.deliver)
-                return;
-            this.observeReadiness(value);
-            this.observeCommandResult(value);
-            this.observeConvenienceEvents(value);
-            this.notifyListeners(this.listeners, value);
-        });
-    }
-    handleLiveKitReconnecting() {
-        if (this.sessionEnded || this.disconnectMode === "intentional")
-            return;
-        this.agentReady = false;
-        // Once full rejoin owns recovery, late LiveKit reconnect notifications
-        // from the old transport must not move the wrapper back to reconnecting.
-        // Doing so makes connectWithMode() reject the replacement connection.
-        if (this.autoRejoinPromise !== null
-            || this.activeRecovery?.strategy === "rejoin"
-            || this.disconnectMode === "rejoin") {
-            this.setState("resuming");
-            return;
-        }
-        this.contextGeneration += 1;
-        this.replacementContext.pause();
-        this.reconnectStartedAt ??= Date.now();
-        this.rejectPendingCommands(new Error("Connection interrupted before command completion"), true);
-        if (this.activeRecovery === null) {
-            this.beginRecovery("livekit", 1, { trigger: "livekit_reconnecting" });
-        }
-        this.setState("reconnecting");
-    }
-    async handleLiveKitReconnected() {
-        if (this.sessionEnded || this.disconnectMode || this.autoRejoinPromise)
-            return;
-        const generation = this.contextGeneration;
-        const recoveredAt = Date.now();
-        if (this.reconnectStartedAt !== null) {
-            this.pendingReconnect = {
-                started_at: new Date(this.reconnectStartedAt).toISOString(),
-                recovered_at: new Date(recoveredAt).toISOString(),
-                duration_ms: Math.max(recoveredAt - this.reconnectStartedAt, 0),
-            };
-            this.reconnectStartedAt = null;
-        }
-        if (this.hasConnectedValue && this.activeRecovery === null) {
-            this.beginRecovery("livekit", 1, { trigger: "livekit_reconnecting" });
-        }
-        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();
-            const deadline = Date.now() + this.recoveryReadiness.readyTimeoutMs;
-            await this.waitForAgentReady(Math.max(deadline - Date.now(), 0));
-            if (this.recoveryReadiness.waitForRemoteAudio)
-                await this.waitForRemoteAudioTrack(deadline);
-            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;
-            const normalizedError = toError(error);
-            if (this.shouldAutoRejoin()) {
-                this.startAutoRejoin(normalizedError, { trigger: "livekit_resume_failed" });
-            }
-            else {
-                this.failRecovery(normalizedError);
-                this.setState("failed");
-            }
-        }
-    }
-    handleLiveKitDisconnected(reason) {
-        this.agentReady = false;
-        if (this.disconnectMode !== "rejoin") {
-            this.pendingReconnect = null;
-        }
-        // Drop any remaining remote tracks so a stale, ended track cannot
-        // satisfy the next connect()'s wait for agent audio.
-        this.outputMediaStream?.getTracks().forEach((track) => {
-            this.outputMediaStream?.removeTrack(track);
+          operation: "context_transfer",
+          status: "timed_out",
+          reason: "context_transfer_timeout",
+          context_key: update.key,
+          payload_bytes: payloadBytes,
+          duration_ms: Date.now() - transferStartedAt,
+          timeout_ms: timeoutMs
         });
-        this.rejectPendingCommands(new Error("Session disconnected before command completion"));
-        if (this.disconnectMode === "rejoin")
-            return;
-        if (this.disconnectMode === "connect_failure")
-            return;
-        if (this.disconnectMode === "intentional") {
-            this.activeRecovery = null;
-            this.deliverPendingEndEvent();
-            this.setState("disconnected");
-            return;
-        }
-        if (this.terminalSessionError)
-            return;
-        if (this.shouldAutoRejoin(reason)) {
-            this.startAutoRejoin(new Error(`LiveKit disconnected (${disconnectReasonName(reason)})`), { trigger: "livekit_disconnected" });
-            return;
-        }
-        if (this.activeRecovery !== null) {
-            this.failRecovery(new Error(`LiveKit disconnected (${disconnectReasonName(reason)})`));
-        }
-        this.deliverPendingEndEvent();
-        this.setState("disconnected");
-    }
-    // The terminal session.ended event is recorded durably after room teardown,
-    // so turn the earlier live announcement into the browser completion signal.
-    deliverPendingEndEvent() {
-        const ending = this.pendingEndEvent;
-        if (!ending)
-            return;
-        this.pendingEndEvent = null;
-        this.notifyEnded({ ...ending, type: "session.ended" });
-    }
-    finishPendingEnd() {
-        this.deliverPendingEndEvent();
-        // The agent can leave while the browser remains in the room. Close that
-        // transport ourselves, after notifying the application of the true reason.
-        void this.disconnect().catch(() => { });
-    }
-    async recoverSessionEnd(apiBase, signal) {
-        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(), 5_000);
-        try {
-            // A later live event may have advanced the cursor past a missed ending.
-            // Replay from the start; event IDs suppress already delivered messages.
-            await this.fetchReplay(apiBase, 0, { signal: controller.signal, terminalOnly: true });
-        }
-        catch {
-            // A 409 also covers failed sessions. Without an authoritative ending,
-            // retain the original HTTP failure rather than invent a normal end.
-        }
-        finally {
-            globalThis.clearTimeout(timeout);
-            signal?.removeEventListener("abort", cancel);
-        }
-        if (!this.sessionEnded || this.terminalSessionError)
-            return false;
-        this.finishPendingEnd();
-        return true;
-    }
-    notifyEnded(event) {
-        if (this.endNotificationDelivered)
-            return;
-        this.endNotificationDelivered = true;
-        this.notifyListeners(this.endedListeners, event);
-    }
-    beginRecovery(strategy, attempt, details) {
-        this.activeRecovery = { strategy, attempt, details };
+        this.flushDiagnostics("context_transfer_timeout");
+        reject(error);
+      }, timeoutMs);
+    });
+    let transfer;
+    try {
+      transfer = await Promise.race([
+        uploading,
+        transferExpired
+      ]);
+    } catch (error) {
+      if (!transferTimedOut) {
         this.recordDiagnostic({
-            operation: "connection_recovery",
-            status: "started",
-            reason: details.trigger,
-            message_id: details.messageId,
-            context_key: details.contextKey,
-            timeout_ms: details.timeoutMs,
-        });
-        this.flushDiagnostics("recovery_started");
-        this.notifyListeners(this.recoveryListeners, {
-            status: "started",
-            strategy,
-            attempt,
-            ...details,
-        });
-    }
-    completeRecovery() {
-        const recovery = this.activeRecovery;
-        if (!recovery)
-            return;
-        this.activeRecovery = null;
-        this.notifyListeners(this.recoveryListeners, {
-            status: "succeeded",
-            strategy: recovery.strategy,
-            attempt: recovery.attempt,
-            ...recovery.details,
+          operation: "context_transfer",
+          status: "failed",
+          reason: "context_transfer_failed",
+          context_key: update.key,
+          payload_bytes: payloadBytes,
+          duration_ms: Date.now() - transferStartedAt
         });
-    }
-    failRecovery(error) {
-        const recovery = this.activeRecovery;
-        if (!recovery)
-            return;
-        this.activeRecovery = null;
-        this.notifyListeners(this.recoveryListeners, {
-            status: "failed",
-            strategy: recovery.strategy,
-            attempt: recovery.attempt,
-            ...recovery.details,
+        this.flushDiagnostics("command_failed");
+      }
+      if (error instanceof TypeError || error instanceof ContextDeliveryError) throw error;
+      throw new ContextDeliveryError(toError(error).message, { cause: error });
+    } finally {
+      globalThis.clearTimeout(transferTimeout);
+    }
+    const transferDurationMs = Date.now() - transferStartedAt;
+    this.recordDiagnostic({
+      operation: "context_transfer",
+      status: "succeeded",
+      context_key: update.key,
+      payload_bytes: payloadBytes,
+      duration_ms: transferDurationMs
+    });
+    if (transferDurationMs > 2e3) this.flushDiagnostics("slow_operation");
+    if (generation !== this.contextGeneration) throw new Error("Context transfer interrupted by recovery");
+    const { payload } = transfer;
+    if (!isContextUpdatePayload(payload)) {
+      throw new TypeError("Invalid context update payload");
+    }
+    const message = createClientMessage(
+      this.connectionId,
+      ++this.clientSeq,
+      "context.update",
+      { ...payload }
+    );
+    return this.sendTrackedCommand(
+      message,
+      timeoutMs,
+      transfer.resend
+    );
+  }
+  resumeContextDelivery(restore) {
+    void this.replacementContext.resume(restore).catch(() => {
+    });
+  }
+  async uploadTextContext(update) {
+    const data = new TextEncoder().encode(update.text);
+    if (data.byteLength === 0) throw new TypeError("Context text cannot be empty");
+    if (data.byteLength > 262144) {
+      throw new TypeError("Context text must be at most 262144 UTF-8 bytes");
+    }
+    const base = {
+      key: update.key,
+      mode: update.mode,
+      label: update.label ?? "",
+      respond: update.respond ?? false
+    };
+    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({
+        streamId,
+        topic: "voxevolv.context.text",
+        totalSize: data.byteLength,
+        attributes: { sha256 }
+      });
+      await writer.write(update.text);
+      await writer.close();
+    };
+    await send();
+    return {
+      payload: {
+        ...base,
+        text_stream: { stream_id: streamId, bytes: data.byteLength, sha256 }
+      },
+      resend: send
+    };
+  }
+  async uploadImageContext(update) {
+    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");
+    }
+    const data = new Uint8Array(await update.image.arrayBuffer());
+    if (data.byteLength === 0 || data.byteLength > 5242880) {
+      throw new TypeError("Image context must be between 1 byte and 5 MiB");
+    }
+    const sha256 = await sha256Hex(data);
+    const streamId = contextStreamId();
+    const send = async () => {
+      const writer = await this.room.localParticipant.streamBytes({
+        streamId,
+        topic: "voxevolv.context.image",
+        name: "context-image",
+        mimeType: update.image.type,
+        totalSize: data.byteLength,
+        attributes: { sha256 }
+      });
+      await writer.write(data);
+      await writer.close();
+    };
+    await send();
+    return {
+      payload: {
+        key: update.key,
+        mode: "replace",
+        label: update.label ?? "",
+        image: {
+          stream_id: streamId,
+          mime: update.image.type,
+          bytes: data.byteLength,
+          sha256,
+          ...update.width === void 0 ? {} : { width: update.width },
+          ...update.height === void 0 ? {} : { height: update.height },
+          detail: update.detail ?? "low"
+        },
+        respond: update.respond ?? false
+      },
+      resend: send
+    };
+  }
+  async disconnect() {
+    this.abortStartupConnect(new Error("Session disconnected"));
+    this.startupConnectController = null;
+    this.failRecovery(new Error("Session disconnected during recovery"));
+    this.cancelRecovery();
+    this.contextGeneration += 1;
+    this.localApplicationAudioTrack = null;
+    this.replacementContext.clear(new Error("Session disconnected"));
+    if (this.stateValue === "disconnected") return;
+    this.rejectPendingCommands(new Error("Session disconnected before command completion"));
+    this.disconnectMode = "intentional";
+    try {
+      await this.room.disconnect();
+    } finally {
+      this.disconnectMode = null;
+      this.activeRecovery = null;
+      this.setState("disconnected");
+    }
+  }
+  async end(options = {}) {
+    this.credentialRefreshGeneration += 1;
+    this.abortStartupConnect(new Error("Session ended"));
+    this.startupConnectController = null;
+    this.failRecovery(new Error("Session ended during recovery"));
+    this.cancelRecovery();
+    this.sessionEnded = true;
+    const endpoint = options.endpoint ?? this.endEndpoint ?? `${this.apiBase}/sessions/${this.id}`;
+    const request = options.request ?? {};
+    const headers = new Headers(request.headers);
+    const usesScopedSessionEndpoint = !options.endpoint && !this.endEndpoint;
+    if (!headers.has("Authorization") && usesScopedSessionEndpoint) {
+      headers.set("Authorization", `Bearer ${this.accessToken}`);
+    }
+    let response = await this.fetcher(endpoint, {
+      ...request,
+      method: request.method ?? "DELETE",
+      headers,
+      credentials: request.credentials ?? this.lifecycleCredentials
+    });
+    if (response.status === 401 && usesScopedSessionEndpoint && this.refreshCredentialsCallback) {
+      await this.refreshCredentials(request.signal ?? void 0);
+      headers.set("Authorization", `Bearer ${this.accessToken}`);
+      response = await this.fetcher(endpoint, {
+        ...request,
+        method: request.method ?? "DELETE",
+        headers,
+        credentials: request.credentials ?? this.lifecycleCredentials
+      });
+    }
+    if (!response.ok) throw await httpError(response, "Could not end realtime session");
+    if (options.disconnect ?? true) await this.disconnect();
+  }
+  async replay(apiBase = this.apiBase, afterSeq = this.cursor.lastServerSeq) {
+    if (this.replayPromise) return this.replayPromise;
+    const normalizedApiBase = normalizeApiBase(apiBase);
+    this.replayPromise = this.fetchReplay(normalizedApiBase, afterSeq).finally(() => {
+      this.replayPromise = null;
+    });
+    return this.replayPromise;
+  }
+  setState(state) {
+    if (this.stateValue === state) return;
+    this.stateValue = state;
+    if (state === "connecting" || state === "resuming") {
+      this.startDiagnosticLoopMonitor();
+      globalThis.document?.addEventListener?.("visibilitychange", this.onDiagnosticVisibilityChange);
+    }
+    if (state === "disconnected" || state === "failed") {
+      globalThis.clearInterval(this.diagnosticLoopTimer);
+      this.diagnosticLoopTimer = void 0;
+      this.diagnosticLoopDelayMs = void 0;
+      globalThis.document?.removeEventListener?.("visibilitychange", this.onDiagnosticVisibilityChange);
+      this.flushDiagnostics("session_finished");
+      const error = new Error(`Session ${state}`);
+      this.contextGeneration += 1;
+      this.replacementContext.clear(error);
+      this.rejectPendingCommands(error);
+    }
+    this.notifyListeners(this.stateListeners, state);
+  }
+  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" }
+        );
+      }
+    });
+    this.room.on(RoomEvent.SignalReconnecting, () => this.handleLiveKitReconnecting());
+    this.room.on(RoomEvent.Reconnecting, () => this.handleLiveKitReconnecting());
+    this.room.on(RoomEvent.Reconnected, () => {
+      void this.handleLiveKitReconnected();
+    });
+    this.room.on(RoomEvent.Disconnected, (reason) => {
+      this.handleLiveKitDisconnected(reason);
+    });
+    this.room.on(RoomEvent.ConnectionStateChanged, (state) => {
+      if (this.sessionEnded || this.terminalSessionError) return;
+      if (state === LiveKitConnectionState.Connected) {
+        const recovering = this.activeRecovery !== null || this.stateValue === "resuming";
+        this.setState(
+          this.agentReady ? "connected" : recovering ? "resuming" : "connected_not_ready"
+        );
+      }
+    });
+    this.room.on(RoomEvent.ConnectionQualityChanged, (quality, participant) => {
+      if (!participant.isLocal) return;
+      this.notifyListeners(
+        this.connectionQualityListeners,
+        quality
+      );
+    });
+    this.room.on(RoomEvent.TrackSubscribed, (track) => {
+      if (track.kind !== Track.Kind.Audio) return;
+      const element = track.attach();
+      element.dataset.voxevolvRemoteAudio = "true";
+      element.style.display = "none";
+      document.body.appendChild(element);
+      try {
+        const playback = element.play();
+        void playback.catch((error) => {
+          this.notifyListeners(this.audioPlaybackBlockedListeners, {
             error,
+            element,
+            track: track.mediaStreamTrack
+          });
         });
-    }
-    shouldAutoRejoin(reason) {
-        return (this.autoRejoinOptions !== null
-            && this.hasConnectedValue
-            && !this.sessionEnded
-            && !["disconnected", "failed"].includes(this.stateValue)
-            && !isTerminalDisconnectReason(reason));
-    }
-    startAutoRejoin(initialError, details) {
-        if (this.autoRejoinPromise || !this.shouldAutoRejoin())
-            return;
-        this.agentReady = false;
-        this.contextGeneration += 1;
-        this.replacementContext.pause();
-        this.rejectPendingCommands(initialError);
-        this.reconnectStartedAt ??= Date.now();
-        const controller = new AbortController();
-        this.autoRejoinController = controller;
-        const timeout = globalThis.setTimeout(() => {
-            if (controller.signal.aborted)
-                return;
-            const error = new Error("Session recovery timed out");
-            controller.abort(error);
-            this.contextGeneration += 1;
-            this.rejectPendingCommands(error);
-            this.replacementContext.clear(error);
-            this.failRecovery(error);
-            this.setState("failed");
-        }, this.autoRejoinOptions.timeoutMs);
-        const promise = this.runAutoRejoin(initialError, controller.signal, details)
-            .finally(() => {
-            globalThis.clearTimeout(timeout);
-            if (this.autoRejoinController === controller) {
-                this.autoRejoinController = null;
-                this.autoRejoinPromise = null;
-            }
+      } catch (error) {
+        this.notifyListeners(this.audioPlaybackBlockedListeners, {
+          error,
+          element,
+          track: track.mediaStreamTrack
         });
-        this.autoRejoinPromise = promise;
-        void promise;
-    }
-    async runAutoRejoin(initialError, signal, details) {
-        const options = this.autoRejoinOptions;
-        if (!options)
-            return;
-        let lastError = initialError;
-        if (this.activeRecovery?.strategy === "livekit") {
-            this.failRecovery(initialError);
-        }
-        this.setState("resuming");
-        for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
-            try {
-                await waitUntilOnline(signal);
-                if (attempt > 1) {
-                    const exponentialDelay = options.baseDelayMs * (2 ** (attempt - 2));
-                    const delayMs = Math.min(exponentialDelay, options.maxDelayMs);
-                    await abortableDelay(delayMs + Math.random() * Math.min(delayMs, 500), signal);
-                }
-                throwIfAborted(signal);
-                this.beginRecovery("rejoin", attempt, details);
-                await this.performRejoin(this.apiBase, { signal });
-                if (this.sessionEnded)
-                    return;
-                throwIfAborted(signal);
-                this.reconnectStartedAt = null;
-                this.completeRecovery();
-                return;
-            }
-            catch (error) {
-                if (signal.aborted)
-                    return;
-                lastError = toError(error);
-                if (isTerminalRejoinError(error))
-                    break;
-            }
-        }
-        this.failRecovery(lastError);
-        this.replacementContext.clear(lastError);
+      }
+      const stream = new MediaStream([track.mediaStreamTrack]);
+      this.remoteAudioStreams.set(track, stream);
+      this.outputStream.addTrack(track.mediaStreamTrack);
+      this.notifyRemoteAudioListeners(this.remoteAudioTrackListeners, track.mediaStreamTrack, stream);
+      this.remoteAudioTrackResolve?.();
+    });
+    this.room.on(RoomEvent.TrackUnsubscribed, (track) => {
+      if (track.kind !== Track.Kind.Audio) return;
+      const stream = this.remoteAudioStreams.get(track) ?? new MediaStream([track.mediaStreamTrack]);
+      this.notifyRemoteAudioListeners(
+        this.remoteAudioTrackUnsubscribedListeners,
+        track.mediaStreamTrack,
+        stream
+      );
+      this.remoteAudioStreams.delete(track);
+      this.outputMediaStream?.removeTrack(track.mediaStreamTrack);
+      track.detach().forEach((element) => element.remove());
+    });
+    this.room.on(RoomEvent.DataReceived, (data, _participant, kind, topic) => {
+      if (topic !== "voxevolv.events" || kind !== DataPacket_Kind.RELIABLE) return;
+      let value;
+      try {
+        value = JSON.parse(new TextDecoder().decode(data));
+      } catch {
+        return;
+      }
+      if (!isRealtimeEvent(value)) return;
+      const result = this.cursor.accept(value);
+      if (result.gap) {
+        this.notifyListeners(this.gapListeners, result.gap);
+        void this.replay(this.apiBase, result.gap.after_server_seq);
+      }
+      if (!result.deliver) return;
+      this.observeReadiness(value);
+      this.observeCommandResult(value);
+      this.observeConvenienceEvents(value);
+      this.notifyListeners(this.listeners, value);
+    });
+  }
+  handleLiveKitReconnecting() {
+    if (this.sessionEnded || this.disconnectMode === "intentional") return;
+    this.agentReady = false;
+    if (this.autoRejoinPromise !== null || this.activeRecovery?.strategy === "rejoin" || this.disconnectMode === "rejoin") {
+      this.setState("resuming");
+      return;
+    }
+    this.contextGeneration += 1;
+    this.replacementContext.pause();
+    this.reconnectStartedAt ??= Date.now();
+    this.rejectPendingCommands(
+      new Error("Connection interrupted before command completion"),
+      true
+    );
+    if (this.activeRecovery === null) {
+      this.beginRecovery("livekit", 1, { trigger: "livekit_reconnecting" });
+    }
+    this.setState("reconnecting");
+  }
+  async handleLiveKitReconnected() {
+    if (this.sessionEnded || this.disconnectMode || this.autoRejoinPromise) return;
+    const generation = this.contextGeneration;
+    const recoveredAt = Date.now();
+    if (this.reconnectStartedAt !== null) {
+      this.pendingReconnect = {
+        started_at: new Date(this.reconnectStartedAt).toISOString(),
+        recovered_at: new Date(recoveredAt).toISOString(),
+        duration_ms: Math.max(recoveredAt - this.reconnectStartedAt, 0)
+      };
+      this.reconnectStartedAt = null;
+    }
+    if (this.hasConnectedValue && this.activeRecovery === null) {
+      this.beginRecovery("livekit", 1, { trigger: "livekit_reconnecting" });
+    }
+    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();
+      const deadline = Date.now() + this.recoveryReadiness.readyTimeoutMs;
+      await this.waitForAgentReady(Math.max(deadline - Date.now(), 0));
+      if (this.recoveryReadiness.waitForRemoteAudio) await this.waitForRemoteAudioTrack(deadline);
+      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;
+      const normalizedError = toError(error);
+      if (this.shouldAutoRejoin()) {
+        this.startAutoRejoin(normalizedError, { trigger: "livekit_resume_failed" });
+      } else {
+        this.failRecovery(normalizedError);
         this.setState("failed");
+      }
+    }
+  }
+  handleLiveKitDisconnected(reason) {
+    this.agentReady = false;
+    if (this.disconnectMode !== "rejoin") {
+      this.pendingReconnect = null;
     }
-    cancelRecovery() {
-        this.autoRejoinController?.abort();
+    this.outputMediaStream?.getTracks().forEach((track) => {
+      this.outputMediaStream?.removeTrack(track);
+    });
+    this.rejectPendingCommands(new Error("Session disconnected before command completion"));
+    if (this.disconnectMode === "rejoin") return;
+    if (this.disconnectMode === "connect_failure") return;
+    if (this.disconnectMode === "intentional") {
+      this.activeRecovery = null;
+      this.deliverPendingEndEvent();
+      this.setState("disconnected");
+      return;
+    }
+    if (this.terminalSessionError) return;
+    if (this.shouldAutoRejoin(reason)) {
+      this.startAutoRejoin(
+        new Error(`LiveKit disconnected (${disconnectReasonName(reason)})`),
+        { trigger: "livekit_disconnected" }
+      );
+      return;
+    }
+    if (this.activeRecovery !== null) {
+      this.failRecovery(
+        new Error(`LiveKit disconnected (${disconnectReasonName(reason)})`)
+      );
+    }
+    this.deliverPendingEndEvent();
+    this.setState("disconnected");
+  }
+  // The terminal session.ended event is recorded durably after room teardown,
+  // so turn the earlier live announcement into the browser completion signal.
+  deliverPendingEndEvent() {
+    const ending = this.pendingEndEvent;
+    if (!ending) return;
+    this.pendingEndEvent = null;
+    this.notifyEnded({ ...ending, type: "session.ended" });
+  }
+  finishPendingEnd() {
+    this.deliverPendingEndEvent();
+    void this.disconnect().catch(() => {
+    });
+  }
+  async recoverSessionEnd(apiBase, signal) {
+    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 });
+    } catch {
+    } finally {
+      globalThis.clearTimeout(timeout);
+      signal?.removeEventListener("abort", cancel);
+    }
+    if (!this.sessionEnded || this.terminalSessionError) return false;
+    this.finishPendingEnd();
+    return true;
+  }
+  notifyEnded(event) {
+    if (this.endNotificationDelivered) return;
+    this.endNotificationDelivered = true;
+    this.notifyListeners(this.endedListeners, event);
+  }
+  beginRecovery(strategy, attempt, details) {
+    this.activeRecovery = { strategy, attempt, details };
+    this.recordDiagnostic({
+      operation: "connection_recovery",
+      status: "started",
+      reason: details.trigger,
+      message_id: details.messageId,
+      context_key: details.contextKey,
+      timeout_ms: details.timeoutMs
+    });
+    this.flushDiagnostics("recovery_started");
+    this.notifyListeners(this.recoveryListeners, {
+      status: "started",
+      strategy,
+      attempt,
+      ...details
+    });
+  }
+  completeRecovery() {
+    const recovery = this.activeRecovery;
+    if (!recovery) return;
+    this.activeRecovery = null;
+    this.notifyListeners(this.recoveryListeners, {
+      status: "succeeded",
+      strategy: recovery.strategy,
+      attempt: recovery.attempt,
+      ...recovery.details
+    });
+  }
+  failRecovery(error) {
+    const recovery = this.activeRecovery;
+    if (!recovery) return;
+    this.activeRecovery = null;
+    this.notifyListeners(this.recoveryListeners, {
+      status: "failed",
+      strategy: recovery.strategy,
+      attempt: recovery.attempt,
+      ...recovery.details,
+      error
+    });
+  }
+  shouldAutoRejoin(reason) {
+    return this.autoRejoinOptions !== null && this.hasConnectedValue && !this.sessionEnded && !["disconnected", "failed"].includes(this.stateValue) && !isTerminalDisconnectReason(reason);
+  }
+  startAutoRejoin(initialError, details) {
+    if (this.autoRejoinPromise || !this.shouldAutoRejoin()) return;
+    this.agentReady = false;
+    this.contextGeneration += 1;
+    this.replacementContext.pause();
+    this.rejectPendingCommands(initialError);
+    this.reconnectStartedAt ??= Date.now();
+    const controller = new AbortController();
+    this.autoRejoinController = controller;
+    const timeout = globalThis.setTimeout(() => {
+      if (controller.signal.aborted) return;
+      const error = new Error("Session recovery timed out");
+      controller.abort(error);
+      this.contextGeneration += 1;
+      this.rejectPendingCommands(error);
+      this.replacementContext.clear(error);
+      this.failRecovery(error);
+      this.setState("failed");
+    }, this.autoRejoinOptions.timeoutMs);
+    const promise = this.runAutoRejoin(initialError, controller.signal, details).finally(() => {
+      globalThis.clearTimeout(timeout);
+      if (this.autoRejoinController === controller) {
         this.autoRejoinController = null;
-        this.manualRejoinController?.abort();
-        this.manualRejoinController = null;
         this.autoRejoinPromise = null;
-        this.activeRecovery = null;
-    }
-    notifyListeners(listeners, value) {
-        for (const listener of listeners) {
-            try {
-                listener(value);
-            }
-            catch (error) {
-                console.error("VoxEvolv event listener failed", error);
-            }
-        }
-    }
-    notifyRemoteAudioListeners(listeners, track, stream) {
-        for (const listener of listeners) {
-            try {
-                listener(track, stream);
-            }
-            catch (error) {
-                console.error("VoxEvolv remote audio listener failed", error);
-            }
-        }
-    }
-    validateAudioOptions(microphone, audioTrack) {
-        if (microphone && audioTrack) {
-            throw new SessionConfigurationError("microphone and audioTrack cannot both be enabled");
-        }
-        if (!audioTrack)
-            return;
-        if (audioTrack.kind !== "audio") {
-            throw new SessionConfigurationError("audioTrack must be an audio MediaStreamTrack");
-        }
-        if (audioTrack.readyState === "ended") {
-            throw new SessionConfigurationError("audioTrack has already ended");
-        }
-    }
-    async fetchRoomToken(apiBase, signal) {
-        const controller = new AbortController();
-        const cancel = () => controller.abort(signal?.reason);
-        signal?.addEventListener("abort", cancel, { once: true });
-        const timeout = globalThis.setTimeout(() => controller.abort(), 10_000);
-        try {
-            throwIfAborted(signal);
-            return 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);
-        }
-        finally {
-            globalThis.clearTimeout(timeout);
-            signal?.removeEventListener("abort", cancel);
+      }
+    });
+    this.autoRejoinPromise = promise;
+    void promise;
+  }
+  async runAutoRejoin(initialError, signal, details) {
+    const options = this.autoRejoinOptions;
+    if (!options) return;
+    let lastError = initialError;
+    if (this.activeRecovery?.strategy === "livekit") {
+      this.failRecovery(initialError);
+    }
+    this.setState("resuming");
+    for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
+      try {
+        await waitUntilOnline(signal);
+        if (attempt > 1) {
+          const exponentialDelay = options.baseDelayMs * 2 ** (attempt - 2);
+          const delayMs = Math.min(exponentialDelay, options.maxDelayMs);
+          await abortableDelay(delayMs + Math.random() * Math.min(delayMs, 500), signal);
         }
-    }
-    async refreshCredentials(signal) {
-        if (!this.refreshCredentialsCallback)
-            return;
         throwIfAborted(signal);
-        const connectionGeneration = this.contextGeneration;
-        const refreshGeneration = ++this.credentialRefreshGeneration;
-        const refreshed = await raceWithAbort(this.refreshCredentialsCallback(), signal);
+        this.beginRecovery("rejoin", attempt, details);
+        await this.performRejoin(this.apiBase, { signal });
+        if (this.sessionEnded) return;
         throwIfAborted(signal);
-        if (connectionGeneration !== this.contextGeneration
-            || refreshGeneration !== this.credentialRefreshGeneration) {
-            throw new Error("Credential refresh was superseded");
-        }
-        validateSessionCredentials(refreshed);
-        if (refreshed.id !== this.id) {
-            throw new Error("Refreshed credentials belong to a different session");
-        }
-        this.accessToken = refreshed.access_token;
-        this.credentials = refreshed.connection;
-    }
-    async finishSessionFailure(error) {
-        this.sessionEnded = true;
-        this.contextGeneration += 1;
-        this.rejectPendingCommands(error);
-        this.replacementContext.clear(error);
-        this.failRecovery(error);
-        this.cancelRecovery();
-        this.disconnectMode = "connect_failure";
-        try {
-            await this.room.disconnect();
-        }
-        finally {
-            this.disconnectMode = null;
-            this.setState("failed");
-        }
-    }
-    observeConvenienceEvents(event) {
-        if (event.type === "session.error") {
-            // Teardown errors must not overwrite an already announced normal ending.
-            if (this.sessionEnded)
-                return;
-            const error = new SessionErrorEventError(event);
-            // Retryability applies to an active startup attempt. Once connected,
-            // a durable session.error means the server has failed the session.
-            if (error.retryable && this.startupAttemptController) {
-                this.startupAttemptController.abort(error);
-            }
-            else {
-                this.terminalSessionError = error;
-                this.abortStartupConnect(error);
-                // Startup owns its aborted attempt's cleanup. An established session
-                // needs to release media and settle recovery immediately on failure.
-                if (!this.startupConnectController) {
-                    void this.finishSessionFailure(error).catch(() => { });
-                }
-            }
-        }
-        if (event.type === "session.ending" || event.type === "session.ended") {
-            // A worker shutdown event can follow a durable session.error. The server
-            // retains FAILED in that case, so it must not become a normal completion.
-            if (this.terminalSessionError)
-                return;
-            this.abortStartupConnect(new Error("Session ended during startup"));
-            this.contextGeneration += 1;
-            this.rejectPendingCommands(new Error("Session ended"));
-            this.failRecovery(new Error("Session ended during recovery"));
-        }
-        if (event.type === "session.ending") {
-            // The server announced an intentional hang-up before tearing down the
-            // room, so the coming disconnect must not fail recovery or auto-rejoin.
-            this.sessionEnded = true;
-            this.cancelRecovery();
-            this.replacementContext.clear(new Error("Session ended"));
-            // Match the server's first terminal outcome, even if teardown announces
-            // another ending before the agent has left the room.
-            this.pendingEndEvent ??= event;
-            if (!this.hasConnectedValue
-                || this.agentDisconnected
-                || this.room.state === LiveKitConnectionState.Disconnected) {
-                this.finishPendingEnd();
-            }
-        }
-        if (event.type === "session.ended") {
-            const ending = this.pendingEndEvent;
-            this.pendingEndEvent = null;
-            this.sessionEnded = true;
-            this.replacementContext.clear(new Error("Session ended"));
-            this.cancelRecovery();
-            this.notifyEnded(ending ? { ...ending, type: "session.ended" } : event);
-            void this.disconnect().catch(() => { });
-        }
-        if (event.type.endsWith(".error"))
-            this.notifyListeners(this.errorListeners, event);
-        const message = this.transcriptStore.accept(event);
-        if (message)
-            this.notifyListeners(this.transcriptListeners, message);
-        const transcript = transcriptEvent(event);
-        if (!transcript)
-            return;
-        this.notifyListeners(transcript.role === "user" ? this.userTranscriptListeners : this.agentTranscriptListeners, transcript);
-    }
-    abortStartupConnect(error) {
-        if (!this.startupConnectController?.signal.aborted) {
-            this.startupConnectController?.abort(error);
-        }
-    }
-    async publishApplicationAudioTrack(audioTrack) {
-        const clonedTrack = audioTrack.clone();
-        let publishedTrack = null;
-        try {
-            publishedTrack = new LocalAudioTrack(clonedTrack, undefined, true);
-            this.localApplicationAudioTrack = publishedTrack;
-            if (!this.microphoneEnabled) {
-                // LiveKit can re-enable a raw track when wrapping it. Mute the wrapper
-                // before publication so recovery cannot briefly transmit muted input.
-                await publishedTrack.mute();
-            }
-            await this.room.localParticipant.publishTrack(publishedTrack, {
-                source: Track.Source.Microphone,
-                name: "voxevolv-application-audio",
-            });
-        }
-        catch (error) {
-            if (this.localApplicationAudioTrack === publishedTrack) {
-                this.localApplicationAudioTrack = null;
-            }
-            clonedTrack.stop();
-            throw error;
-        }
-    }
-    async sendHello() {
-        const reconnect = this.pendingReconnect;
-        const message = createClientMessage(this.connectionId, ++this.clientSeq, "client.hello", {
-            last_server_seq: this.cursor.lastServerSeq,
-            sdk: `@voxevolv/client@${SDK_VERSION}`,
-            tool_handlers: [...this.toolHandlers.keys()].sort(),
-            ...(reconnect ? { reconnect } : {}),
-        });
-        this.lastHelloMessageId = message.message_id;
-        await this.sendTrackedCommand(message, CLIENT_HELLO_TIMEOUT_MS);
-        if (this.pendingReconnect === reconnect)
-            this.pendingReconnect = null;
-    }
-    async sendTrackedCommand(message, timeoutMs, retryTransfer) {
-        const contextKey = contextKeyFromMessage(message);
-        const payloadBytes = contextPayloadBytes(message.payload);
-        const startedAt = Date.now();
-        this.recordDiagnostic({
-            operation: "command_send",
-            status: "started",
-            message_id: message.message_id,
-            connection_id: message.connection_id,
-            client_seq: message.client_seq,
-            context_key: contextKey,
-            payload_bytes: payloadBytes,
-            retry_count: 0,
-            timeout_ms: timeoutMs,
-            event_type: diagnosticEventType(message.type),
-        });
-        let markSettled = () => { };
-        const settled = new Promise((resolve) => { markSettled = resolve; });
-        const response = new Promise((resolve, reject) => {
-            const timeout = globalThis.setTimeout(() => {
-                const pending = this.pendingCommands.get(message.message_id);
-                if (pending)
-                    globalThis.clearTimeout(pending.retry);
-                pending?.markSettled();
-                this.pendingCommands.delete(message.message_id);
-                const detail = `Command ${message.type} timed out after ${timeoutMs}ms`;
-                const error = message.type === "context.update"
-                    ? new ContextDeliveryError(detail, { retryAfter: pending?.transferSettled })
-                    : new Error(detail);
-                this.recordDiagnostic({
-                    operation: "command_send",
-                    status: "timed_out",
-                    reason: message.type === "context.update"
-                        ? "context_command_timeout"
-                        : "command_timeout",
-                    message_id: message.message_id,
-                    connection_id: message.connection_id,
-                    client_seq: message.client_seq,
-                    context_key: contextKey,
-                    payload_bytes: payloadBytes,
-                    duration_ms: Date.now() - startedAt,
-                    retry_count: pending?.retryCount ?? 0,
-                    timeout_ms: timeoutMs,
-                    event_type: diagnosticEventType(message.type),
-                });
-                this.flushDiagnostics("command_timeout");
-                reject(error);
-            }, timeoutMs);
-            this.pendingCommands.set(message.message_id, {
-                commandType: message.type,
-                message,
-                startedAt,
-                contextKey,
-                payloadBytes,
-                retryCount: 0,
-                publishQueued: false,
-                resolve,
-                reject,
-                timeout,
-                settled,
-                markSettled,
-                retryTransfer,
-                transferRetrying: false,
-                transferRetryRequested: false,
-            });
-            this.scheduleCommandRetry(message);
-        });
-        void this.publishCommandAttempt(message, false).catch(() => {
-            // The reliable data channel may still be warming immediately after a
-            // reconnect. Keep the command pending so the retry timer can publish
-            // it once the transport accepts writes, or reject at the normal timeout.
-        });
-        return response;
-    }
-    scheduleCommandRetry(message) {
-        const pending = this.pendingCommands.get(message.message_id);
-        if (!pending)
-            return;
-        const delayMs = message.type === "context.update"
-            ? contextRetryDelay(pending.retryCount + 1)
-            : 500;
-        pending.retry = globalThis.setTimeout(() => {
-            void this.retryCommand(message).finally(() => this.scheduleCommandRetry(message));
-        }, delayMs);
-    }
-    async retryCommand(message) {
-        const pending = this.pendingCommands.get(message.message_id);
-        if (!pending)
-            return;
-        if (message.type === "context.update" && (this.sessionEnded || ["reconnecting", "resuming", "disconnected", "failed"].includes(this.stateValue)))
-            return;
-        try {
-            if (pending.transferRetryRequested && pending.retryTransfer) {
-                pending.transferRetryRequested = false;
-                pending.transferRetrying = true;
-                const transfer = pending.retryTransfer();
-                pending.transferSettled = transfer.then(() => { }, () => { });
-                if (pending.contextKey) {
-                    this.replacementContext.blockUntilTransferSettles(pending.contextKey, pending.transferSettled);
-                }
-                await Promise.race([transfer, pending.settled]);
-            }
-            await this.publishCommandAttempt(message, true);
-        }
-        catch {
-            // Failed writes retain their original deadline and retry with backoff.
-        }
-        finally {
-            pending.transferRetrying = false;
-        }
-    }
-    publishCommandAttempt(message, retrying) {
-        const pending = this.pendingCommands.get(message.message_id);
-        if (!pending || pending.publishQueued)
-            return Promise.resolve();
-        pending.publishQueued = true;
-        // Context keys drain independently, but client_seq is global. Serialize the
-        // asynchronous LiveKit publish boundary so a later sequence cannot overtake
-        // an earlier one before the reliable data channel receives it.
-        const attempt = this.commandPublishTail
-            .then(() => this.publishCommandAttemptNow(message, retrying))
-            .finally(() => {
-            const current = this.pendingCommands.get(message.message_id);
-            if (current === pending)
-                current.publishQueued = false;
-        });
-        this.commandPublishTail = attempt.catch(() => { });
-        return attempt;
-    }
-    async publishCommandAttemptNow(message, retrying) {
+        this.reconnectStartedAt = null;
+        this.completeRecovery();
+        return;
+      } catch (error) {
+        if (signal.aborted) return;
+        lastError = toError(error);
+        if (isTerminalRejoinError(error)) break;
+      }
+    }
+    this.failRecovery(lastError);
+    this.replacementContext.clear(lastError);
+    this.setState("failed");
+  }
+  cancelRecovery() {
+    this.autoRejoinController?.abort();
+    this.autoRejoinController = null;
+    this.manualRejoinController?.abort();
+    this.manualRejoinController = null;
+    this.autoRejoinPromise = null;
+    this.activeRecovery = null;
+  }
+  notifyListeners(listeners, value) {
+    for (const listener of listeners) {
+      try {
+        listener(value);
+      } catch (error) {
+        console.error("VoxEvolv event listener failed", error);
+      }
+    }
+  }
+  notifyRemoteAudioListeners(listeners, track, stream) {
+    for (const listener of listeners) {
+      try {
+        listener(track, stream);
+      } catch (error) {
+        console.error("VoxEvolv remote audio listener failed", error);
+      }
+    }
+  }
+  validateAudioOptions(microphone, audioTrack) {
+    if (microphone && audioTrack) {
+      throw new SessionConfigurationError("microphone and audioTrack cannot both be enabled");
+    }
+    if (!audioTrack) return;
+    if (audioTrack.kind !== "audio") {
+      throw new SessionConfigurationError("audioTrack must be an audio MediaStreamTrack");
+    }
+    if (audioTrack.readyState === "ended") {
+      throw new SessionConfigurationError("audioTrack has already ended");
+    }
+  }
+  async fetchRoomToken(apiBase, signal) {
+    const controller = new AbortController();
+    const cancel = () => controller.abort(signal?.reason);
+    signal?.addEventListener("abort", cancel, { once: true });
+    const timeout = globalThis.setTimeout(() => controller.abort(), 1e4);
+    try {
+      throwIfAborted(signal);
+      return 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);
+    } finally {
+      globalThis.clearTimeout(timeout);
+      signal?.removeEventListener("abort", cancel);
+    }
+  }
+  async refreshCredentials(signal) {
+    if (!this.refreshCredentialsCallback) return;
+    throwIfAborted(signal);
+    const connectionGeneration = this.contextGeneration;
+    const refreshGeneration = ++this.credentialRefreshGeneration;
+    const refreshed = await raceWithAbort(this.refreshCredentialsCallback(), signal);
+    throwIfAborted(signal);
+    if (connectionGeneration !== this.contextGeneration || refreshGeneration !== this.credentialRefreshGeneration) {
+      throw new Error("Credential refresh was superseded");
+    }
+    validateSessionCredentials(refreshed);
+    if (refreshed.id !== this.id) {
+      throw new Error("Refreshed credentials belong to a different session");
+    }
+    this.accessToken = refreshed.access_token;
+    this.credentials = refreshed.connection;
+  }
+  async finishSessionFailure(error) {
+    this.sessionEnded = true;
+    this.contextGeneration += 1;
+    this.rejectPendingCommands(error);
+    this.replacementContext.clear(error);
+    this.failRecovery(error);
+    this.cancelRecovery();
+    this.disconnectMode = "connect_failure";
+    try {
+      await this.room.disconnect();
+    } finally {
+      this.disconnectMode = null;
+      this.setState("failed");
+    }
+  }
+  observeConvenienceEvents(event) {
+    if (event.type === "session.error") {
+      if (this.sessionEnded) return;
+      const error = new SessionErrorEventError(event);
+      if (error.retryable && this.startupAttemptController) {
+        this.startupAttemptController.abort(error);
+      } else {
+        this.terminalSessionError = error;
+        this.abortStartupConnect(error);
+        if (!this.startupConnectController) {
+          void this.finishSessionFailure(error).catch(() => {
+          });
+        }
+      }
+    }
+    if (event.type === "session.ending" || event.type === "session.ended") {
+      if (this.terminalSessionError) return;
+      this.abortStartupConnect(new Error("Session ended during startup"));
+      this.contextGeneration += 1;
+      this.rejectPendingCommands(new Error("Session ended"));
+      this.failRecovery(new Error("Session ended during recovery"));
+    }
+    if (event.type === "session.ending") {
+      this.sessionEnded = true;
+      this.cancelRecovery();
+      this.replacementContext.clear(new Error("Session ended"));
+      this.pendingEndEvent ??= event;
+      if (!this.hasConnectedValue || this.agentDisconnected || this.room.state === LiveKitConnectionState.Disconnected) {
+        this.finishPendingEnd();
+      }
+    }
+    if (event.type === "session.ended") {
+      const ending = this.pendingEndEvent;
+      this.pendingEndEvent = null;
+      this.sessionEnded = true;
+      this.replacementContext.clear(new Error("Session ended"));
+      this.cancelRecovery();
+      this.notifyEnded(ending ? { ...ending, type: "session.ended" } : event);
+      void this.disconnect().catch(() => {
+      });
+    }
+    if (event.type.endsWith(".error")) this.notifyListeners(this.errorListeners, event);
+    const message = this.transcriptStore.accept(event);
+    if (message) this.notifyListeners(this.transcriptListeners, message);
+    const transcript = transcriptEvent(event);
+    if (!transcript) return;
+    this.notifyListeners(
+      transcript.role === "user" ? this.userTranscriptListeners : this.agentTranscriptListeners,
+      transcript
+    );
+  }
+  abortStartupConnect(error) {
+    if (!this.startupConnectController?.signal.aborted) {
+      this.startupConnectController?.abort(error);
+    }
+  }
+  async publishApplicationAudioTrack(audioTrack) {
+    const clonedTrack = audioTrack.clone();
+    let publishedTrack = null;
+    try {
+      publishedTrack = new LocalAudioTrack(clonedTrack, void 0, true);
+      this.localApplicationAudioTrack = publishedTrack;
+      if (!this.microphoneEnabled) {
+        await publishedTrack.mute();
+      }
+      await this.room.localParticipant.publishTrack(publishedTrack, {
+        source: Track.Source.Microphone,
+        name: "voxevolv-application-audio"
+      });
+    } catch (error) {
+      if (this.localApplicationAudioTrack === publishedTrack) {
+        this.localApplicationAudioTrack = null;
+      }
+      clonedTrack.stop();
+      throw error;
+    }
+  }
+  async sendHello() {
+    const reconnect = this.pendingReconnect;
+    const message = createClientMessage(
+      this.connectionId,
+      ++this.clientSeq,
+      "client.hello",
+      {
+        last_server_seq: this.cursor.lastServerSeq,
+        sdk: `@voxevolv/client@${SDK_VERSION}`,
+        tool_handlers: [...this.toolHandlers.keys()].sort(),
+        ...reconnect ? { reconnect } : {}
+      }
+    );
+    this.lastHelloMessageId = message.message_id;
+    await this.sendTrackedCommand(message, CLIENT_HELLO_TIMEOUT_MS);
+    if (this.pendingReconnect === reconnect) this.pendingReconnect = null;
+  }
+  async sendTrackedCommand(message, timeoutMs, retryTransfer) {
+    const contextKey = contextKeyFromMessage(message);
+    const payloadBytes = contextPayloadBytes(message.payload);
+    const startedAt = Date.now();
+    this.recordDiagnostic({
+      operation: "command_send",
+      status: "started",
+      message_id: message.message_id,
+      connection_id: message.connection_id,
+      client_seq: message.client_seq,
+      context_key: contextKey,
+      payload_bytes: payloadBytes,
+      retry_count: 0,
+      timeout_ms: timeoutMs,
+      event_type: diagnosticEventType(message.type)
+    });
+    let markSettled = () => {
+    };
+    const settled = new Promise((resolve) => {
+      markSettled = resolve;
+    });
+    const response = new Promise((resolve, reject) => {
+      const timeout = globalThis.setTimeout(() => {
         const pending = this.pendingCommands.get(message.message_id);
-        if (!pending)
-            return;
-        if (retrying) {
-            pending.retryCount += 1;
-            this.recordDiagnostic({
-                operation: "command_send",
-                status: "retrying",
-                message_id: message.message_id,
-                connection_id: message.connection_id,
-                client_seq: message.client_seq,
-                context_key: pending.contextKey,
-                payload_bytes: pending.payloadBytes,
-                retry_count: pending.retryCount,
-                event_type: diagnosticEventType(message.type),
-            });
-        }
-        const attemptStartedAt = Date.now();
-        try {
-            let publishFinished = false;
-            const publish = this.publishCommand(message).then(() => { publishFinished = true; });
-            await Promise.race([publish, pending.settled]);
-            if (!publishFinished)
-                return;
-        }
-        catch (error) {
-            this.recordDiagnostic({
-                operation: "command_send",
-                status: "failed",
-                reason: "command_publish_failed",
-                message_id: message.message_id,
-                connection_id: message.connection_id,
-                client_seq: message.client_seq,
-                context_key: pending.contextKey,
-                payload_bytes: pending.payloadBytes,
-                duration_ms: Date.now() - attemptStartedAt,
-                retry_count: pending.retryCount,
-                event_type: diagnosticEventType(message.type),
-            });
-            this.flushDiagnostics("command_failed");
-            throw error;
-        }
-        const durationMs = Date.now() - attemptStartedAt;
+        if (pending) globalThis.clearTimeout(pending.retry);
+        pending?.markSettled();
+        this.pendingCommands.delete(message.message_id);
+        const detail = `Command ${message.type} timed out after ${timeoutMs}ms`;
+        const error = message.type === "context.update" ? new ContextDeliveryError(detail, { retryAfter: pending?.transferSettled }) : new Error(detail);
         this.recordDiagnostic({
-            operation: "command_send",
-            status: "succeeded",
-            message_id: message.message_id,
-            connection_id: message.connection_id,
-            client_seq: message.client_seq,
-            context_key: pending.contextKey,
-            payload_bytes: pending.payloadBytes,
-            duration_ms: durationMs,
-            retry_count: pending.retryCount,
-            event_type: diagnosticEventType(message.type),
-        });
-        if (durationMs > 2_000)
-            this.flushDiagnostics("slow_operation");
-    }
-    async publishCommand(message) {
-        await this.room.localParticipant.publishData(new TextEncoder().encode(JSON.stringify(message)), { reliable: true, topic: "voxevolv.commands" });
-    }
-    recordDiagnostic(entry) {
-        this.diagnostics.record({
-            ...entry,
-            connection_state: this.stateValue,
-            buffered_bytes: this.reliableDataChannelBufferedBytes(),
+          operation: "command_send",
+          status: "timed_out",
+          reason: message.type === "context.update" ? "context_command_timeout" : "command_timeout",
+          message_id: message.message_id,
+          connection_id: message.connection_id,
+          client_seq: message.client_seq,
+          context_key: contextKey,
+          payload_bytes: payloadBytes,
+          duration_ms: Date.now() - startedAt,
+          retry_count: pending?.retryCount ?? 0,
+          timeout_ms: timeoutMs,
+          event_type: diagnosticEventType(message.type)
         });
-    }
-    reliableDataChannelBufferedBytes() {
-        try {
-            const bufferedAmount = this.room.engine.dataChannelForKind(0)?.bufferedAmount;
-            return typeof bufferedAmount === "number" ? bufferedAmount : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    flushDiagnostics(trigger) {
-        void this.diagnostics.flush(trigger, (report) => this.postDiagnostics(report));
-    }
-    async postDiagnostics(report) {
-        const controller = new AbortController();
-        let timeout;
-        const timeoutExpired = new Promise((_resolve, reject) => {
-            timeout = globalThis.setTimeout(() => {
-                controller.abort();
-                reject(new Error(`Diagnostic report timed out after ${this.diagnosticReportTimeoutMs}ms`));
-            }, this.diagnosticReportTimeoutMs);
-        });
-        try {
-            const upload = async () => {
-                const response = await this.fetcher(`${this.apiBase}/sessions/${this.id}/diagnostics`, {
-                    method: "POST",
-                    headers: {
-                        Authorization: `Bearer ${this.accessToken}`,
-                        "Content-Type": "application/json",
-                    },
-                    credentials: this.lifecycleCredentials,
-                    body: JSON.stringify(report),
-                    signal: controller.signal,
-                    keepalive: true,
-                });
-                const body = await response.json().catch(() => null);
-                if (!response.ok) {
-                    const retryable = response.status === 408 || response.status === 429 || response.status >= 500;
-                    const headerDelay = Number(response.headers.get("Retry-After")) * 1000;
-                    const retryAfterMs = typeof body?.retry_after_ms === "number"
-                        ? body.retry_after_ms : headerDelay;
-                    throw new DiagnosticDeliveryError(`Diagnostic report failed (${response.status})`, retryable, Number.isFinite(retryAfterMs) ? Math.max(retryAfterMs, 0) : 0);
-                }
-                if (body?.report_id !== report.report_id) {
-                    throw new DiagnosticDeliveryError("Diagnostic report was not acknowledged");
-                }
-            };
-            // The receipt body is part of the timeout too, not just the response headers.
-            await Promise.race([upload(), timeoutExpired]);
-        }
-        finally {
-            if (timeout !== undefined)
-                globalThis.clearTimeout(timeout);
-        }
-    }
-    waitForRemoteAudioTrack(deadline, signal) {
-        if ((this.outputMediaStream?.getAudioTracks().length ?? 0) > 0)
-            return Promise.resolve();
-        throwIfAborted(signal);
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                globalThis.clearTimeout(timeout);
-                signal?.removeEventListener("abort", onAbort);
-                this.remoteAudioTrackResolve = null;
-            };
-            const timeout = globalThis.setTimeout(() => {
-                cleanup();
-                reject(new Error("Agent audio track did not arrive within the ready timeout;"
-                    + " pass waitForRemoteAudio: false to resolve connect() on signaling readiness alone"));
-            }, Math.max(deadline - Date.now(), 0));
-            const onAbort = () => {
-                cleanup();
-                reject(abortError(signal));
-            };
-            this.remoteAudioTrackResolve = () => {
-                cleanup();
-                resolve();
-            };
-            signal?.addEventListener("abort", onAbort, { once: true });
-        });
-    }
-    waitForAgentReady(timeoutMs, signal) {
-        if (this.agentReady)
-            return Promise.resolve();
-        throwIfAborted(signal);
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                globalThis.clearTimeout(timeout);
-                signal?.removeEventListener("abort", onAbort);
-                this.readyResolve = null;
-            };
-            const timeout = globalThis.setTimeout(() => {
-                cleanup();
-                reject(new Error(`Agent did not become ready within ${timeoutMs}ms`));
-            }, timeoutMs);
-            const onAbort = () => {
-                cleanup();
-                reject(abortError(signal));
-            };
-            this.readyResolve = () => {
-                cleanup();
-                resolve();
-            };
-            signal?.addEventListener("abort", onAbort, { once: true });
+        this.flushDiagnostics("command_timeout");
+        reject(error);
+      }, timeoutMs);
+      this.pendingCommands.set(
+        message.message_id,
+        {
+          commandType: message.type,
+          message,
+          startedAt,
+          contextKey,
+          payloadBytes,
+          retryCount: 0,
+          publishQueued: false,
+          resolve,
+          reject,
+          timeout,
+          settled,
+          markSettled,
+          retryTransfer,
+          transferRetrying: false,
+          transferRetryRequested: false
+        }
+      );
+      this.scheduleCommandRetry(message);
+    });
+    void this.publishCommandAttempt(message, false).catch(() => {
+    });
+    return response;
+  }
+  scheduleCommandRetry(message) {
+    const pending = this.pendingCommands.get(message.message_id);
+    if (!pending) return;
+    const delayMs = message.type === "context.update" ? contextRetryDelay(pending.retryCount + 1) : 500;
+    pending.retry = globalThis.setTimeout(() => {
+      void this.retryCommand(message).finally(() => this.scheduleCommandRetry(message));
+    }, delayMs);
+  }
+  async retryCommand(message) {
+    const pending = this.pendingCommands.get(message.message_id);
+    if (!pending) return;
+    if (message.type === "context.update" && (this.sessionEnded || ["reconnecting", "resuming", "disconnected", "failed"].includes(this.stateValue))) return;
+    try {
+      if (pending.transferRetryRequested && pending.retryTransfer) {
+        pending.transferRetryRequested = false;
+        pending.transferRetrying = true;
+        const transfer = pending.retryTransfer();
+        pending.transferSettled = transfer.then(() => {
+        }, () => {
         });
-    }
-    observeReadiness(event) {
-        // Replayed readiness describes an old worker, not the current transport.
-        if (event.stream_id === "durable-replay")
-            return;
-        const payload = event.payload;
-        const snapshotReady = event.type === "agent.snapshot"
-            && payload.status === "ready"
-            && payload.connection_id === this.connectionId
-            && payload.ack_message_id === this.lastHelloMessageId;
-        if (event.type !== "agent.ready" && !snapshotReady)
-            return;
-        if (this.agentStreamId && this.agentStreamId !== event.stream_id && !this.activeRecovery) {
-            this.startAutoRejoin(new Error("Agent worker was replaced"), { trigger: "worker_replaced" });
-            return;
-        }
-        this.agentStreamId = event.stream_id;
-        this.agentDisconnected = false;
-        const wasReady = this.agentReady;
-        this.agentReady = true;
-        // connect/reconnect owns the transition after hello and audio are ready.
-        // Context restoration proceeds independently in the background.
-        this.readyResolve?.();
-        if (!wasReady)
-            this.notifyListeners(this.readyListeners, event);
-    }
-    observeCommandResult(event) {
-        if (event.type !== "command.ack"
-            && event.type !== "command.error"
-            && event.type !== "context.updated"
-            && event.type !== "context.rejected")
-            return;
-        const pending = this.pendingCommands.get(String(event.payload.message_id ?? ""));
-        if (!pending)
-            return;
-        if (event.type === "command.ack" && isCommandAckPayload(event.payload)) {
-            this.recordCommandResult(pending, event.type, "acknowledged");
-            globalThis.clearTimeout(pending.timeout);
-            globalThis.clearTimeout(pending.retry);
-            pending.markSettled();
-            this.pendingCommands.delete(event.payload.message_id);
-            pending.resolve(event.payload);
-            return;
-        }
-        if (event.type === "context.updated" && isContextUpdatedPayload(event.payload)) {
-            this.recordCommandResult(pending, event.type, "acknowledged");
-            globalThis.clearTimeout(pending.timeout);
-            globalThis.clearTimeout(pending.retry);
-            pending.markSettled();
-            this.pendingCommands.delete(event.payload.message_id);
-            pending.resolve(event.payload);
-            return;
-        }
-        if ((event.type === "command.error" && isCommandErrorPayload(event.payload))
-            || (event.type === "context.rejected" && isContextRejectedPayload(event.payload))) {
-            this.recordCommandResult(pending, event.type, "rejected", event.payload.code);
-            this.flushDiagnostics("command_rejected");
-            if (event.type === "context.rejected" && event.payload.retryable) {
-                if (event.payload.code === "stream_unavailable" && pending.retryTransfer && !pending.transferRetrying) {
-                    pending.transferRetryRequested = true;
-                }
-                return;
-            }
-            globalThis.clearTimeout(pending.timeout);
-            globalThis.clearTimeout(pending.retry);
-            pending.markSettled();
-            this.pendingCommands.delete(event.payload.message_id);
-            pending.reject(new CommandError(event.payload));
-        }
-    }
-    rejectPendingCommands(error, preserveContext = false) {
-        for (const [messageId, pending] of this.pendingCommands) {
-            if (preserveContext && pending.commandType === "context.update")
-                continue;
-            this.recordCommandResult(pending, pending.commandType === "context.update" ? "context.rejected" : "command.error", "failed", "pending_command_cancelled");
-            globalThis.clearTimeout(pending.timeout);
-            globalThis.clearTimeout(pending.retry);
-            pending.markSettled();
-            pending.reject(pending.commandType === "context.update"
-                ? new ContextDeliveryError(error.message, { cause: error, retryAfter: pending.transferSettled })
-                : error);
-            this.pendingCommands.delete(messageId);
-        }
-    }
-    recordCommandResult(pending, eventType, status, reason) {
-        const durationMs = Date.now() - pending.startedAt;
-        this.recordDiagnostic({
-            operation: "command_result",
-            status,
-            reason,
-            message_id: pending.message.message_id,
-            connection_id: pending.message.connection_id,
-            client_seq: pending.message.client_seq,
-            context_key: pending.contextKey,
-            payload_bytes: pending.payloadBytes,
-            duration_ms: durationMs,
-            retry_count: pending.retryCount,
-            event_type: eventType,
+        if (pending.contextKey) {
+          this.replacementContext.blockUntilTransferSettles(pending.contextKey, pending.transferSettled);
+        }
+        await Promise.race([transfer, pending.settled]);
+      }
+      await this.publishCommandAttempt(message, true);
+    } catch {
+    } finally {
+      pending.transferRetrying = false;
+    }
+  }
+  publishCommandAttempt(message, retrying) {
+    const pending = this.pendingCommands.get(message.message_id);
+    if (!pending || pending.publishQueued) return Promise.resolve();
+    pending.publishQueued = true;
+    const attempt = this.commandPublishTail.then(() => this.publishCommandAttemptNow(message, retrying)).finally(() => {
+      const current = this.pendingCommands.get(message.message_id);
+      if (current === pending) current.publishQueued = false;
+    });
+    this.commandPublishTail = attempt.catch(() => {
+    });
+    return attempt;
+  }
+  async publishCommandAttemptNow(message, retrying) {
+    const pending = this.pendingCommands.get(message.message_id);
+    if (!pending) return;
+    if (retrying) {
+      pending.retryCount += 1;
+      this.recordDiagnostic({
+        operation: "command_send",
+        status: "retrying",
+        message_id: message.message_id,
+        connection_id: message.connection_id,
+        client_seq: message.client_seq,
+        context_key: pending.contextKey,
+        payload_bytes: pending.payloadBytes,
+        retry_count: pending.retryCount,
+        event_type: diagnosticEventType(message.type)
+      });
+    }
+    const attemptStartedAt = Date.now();
+    try {
+      let publishFinished = false;
+      const publish = this.publishCommand(message).then(() => {
+        publishFinished = true;
+      });
+      await Promise.race([publish, pending.settled]);
+      if (!publishFinished) return;
+    } catch (error) {
+      this.recordDiagnostic({
+        operation: "command_send",
+        status: "failed",
+        reason: "command_publish_failed",
+        message_id: message.message_id,
+        connection_id: message.connection_id,
+        client_seq: message.client_seq,
+        context_key: pending.contextKey,
+        payload_bytes: pending.payloadBytes,
+        duration_ms: Date.now() - attemptStartedAt,
+        retry_count: pending.retryCount,
+        event_type: diagnosticEventType(message.type)
+      });
+      this.flushDiagnostics("command_failed");
+      throw error;
+    }
+    const durationMs = Date.now() - attemptStartedAt;
+    this.recordDiagnostic({
+      operation: "command_send",
+      status: "succeeded",
+      message_id: message.message_id,
+      connection_id: message.connection_id,
+      client_seq: message.client_seq,
+      context_key: pending.contextKey,
+      payload_bytes: pending.payloadBytes,
+      duration_ms: durationMs,
+      retry_count: pending.retryCount,
+      event_type: diagnosticEventType(message.type)
+    });
+    if (durationMs > 2e3) this.flushDiagnostics("slow_operation");
+  }
+  async publishCommand(message) {
+    await this.room.localParticipant.publishData(
+      new TextEncoder().encode(JSON.stringify(message)),
+      { reliable: true, topic: "voxevolv.commands" }
+    );
+  }
+  startDiagnosticLoopMonitor() {
+    if (this.diagnosticLoopTimer !== void 0) return;
+    this.diagnosticLoopExpectedAt = performance.now() + 1e3;
+    this.diagnosticLoopTimer = globalThis.setInterval(() => {
+      const now = performance.now();
+      this.diagnosticLoopDelayMs = Math.max(0, now - this.diagnosticLoopExpectedAt);
+      this.diagnosticLoopExpectedAt = now + 1e3;
+    }, 1e3);
+    this.diagnosticLoopTimer.unref?.();
+  }
+  recordDiagnostic(entry) {
+    const snapshot = {
+      ...entry,
+      connection_state: this.stateValue,
+      buffered_bytes: this.reliableDataChannelBufferedBytes()
+    };
+    if (entry.operation === "tool_rpc") {
+      snapshot.page_visibility = globalThis.document?.visibilityState;
+      snapshot.active_context_transfers = this.activeContextTransfers;
+      snapshot.active_context_bytes = this.activeContextBytes;
+      if (this.diagnosticLoopTimer !== void 0) {
+        snapshot.event_loop_delay_ms = Math.max(
+          this.diagnosticLoopDelayMs ?? 0,
+          performance.now() - this.diagnosticLoopExpectedAt
+        );
+      }
+    }
+    this.diagnostics.record(snapshot);
+  }
+  reliableDataChannelBufferedBytes() {
+    try {
+      const bufferedAmount = this.room.engine.dataChannelForKind(0)?.bufferedAmount;
+      return typeof bufferedAmount === "number" ? bufferedAmount : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  flushDiagnostics(trigger) {
+    void this.diagnostics.flush(trigger, (report) => this.postDiagnostics(report));
+  }
+  async postDiagnostics(report) {
+    const controller = new AbortController();
+    let timeout;
+    const timeoutExpired = new Promise((_resolve, reject) => {
+      timeout = globalThis.setTimeout(() => {
+        controller.abort();
+        reject(new Error(
+          `Diagnostic report timed out after ${this.diagnosticReportTimeoutMs}ms`
+        ));
+      }, this.diagnosticReportTimeoutMs);
+    });
+    try {
+      const upload = async () => {
+        const response = await this.fetcher(`${this.apiBase}/sessions/${this.id}/diagnostics`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`,
+            "Content-Type": "application/json"
+          },
+          credentials: this.lifecycleCredentials,
+          body: JSON.stringify(report),
+          signal: controller.signal,
+          keepalive: true
         });
-        if (durationMs > 2_000)
-            this.flushDiagnostics("slow_operation");
-    }
-    async fetchReplay(apiBase, afterSeq, options = {}) {
-        const { signal, terminalOnly = false } = options;
-        let nextAfter = afterSeq;
-        while (true) {
-            throwIfAborted(signal);
-            const url = `${apiBase}/sessions/${this.id}/events?after_seq=${nextAfter}&limit=200`
-                + (terminalOnly ? "&terminal_only=true" : "");
-            let response = await raceWithAbort(this.fetcher(url, {
-                headers: { Authorization: `Bearer ${this.accessToken}` },
-                credentials: this.lifecycleCredentials,
-                signal,
-            }), signal);
-            if (response.status === 401 && this.refreshCredentialsCallback) {
-                await this.refreshCredentials(signal);
-                response = await raceWithAbort(this.fetcher(url, {
-                    headers: { Authorization: `Bearer ${this.accessToken}` },
-                    credentials: this.lifecycleCredentials,
-                    signal,
-                }), signal);
-            }
-            if (!response.ok) {
-                throw await raceWithAbort(httpError(response, "Could not replay session events"), signal);
-            }
-            const page = (await raceWithAbort(response.json(), signal));
-            throwIfAborted(signal);
-            for (const stored of page.items) {
-                nextAfter = Math.max(nextAfter, stored.server_seq);
-                const event = {
-                    protocol_version: 1,
-                    event_id: stored.event_id,
-                    stream_id: "durable-replay",
-                    stream_seq: Math.max(this.cursor.lastStreamSeq, 1),
-                    server_seq: stored.server_seq,
-                    ts: stored.created_at,
-                    type: stored.type,
-                    payload: stored.payload,
-                };
-                if (!this.cursor.acceptReplay(event))
-                    continue;
-                this.observeReadiness(event);
-                this.observeConvenienceEvents(event);
-                this.notifyListeners(this.listeners, event);
-            }
-            nextAfter = Math.max(nextAfter, page.next_after_seq);
-            if (!page.has_more)
-                return;
-        }
-    }
-}
+        const body = await response.json().catch(() => null);
+        if (!response.ok) {
+          const retryable = response.status === 408 || response.status === 429 || response.status >= 500;
+          const headerDelay = Number(response.headers.get("Retry-After")) * 1e3;
+          const retryAfterMs = typeof body?.retry_after_ms === "number" ? body.retry_after_ms : headerDelay;
+          throw new DiagnosticDeliveryError(
+            `Diagnostic report failed (${response.status})`,
+            retryable,
+            Number.isFinite(retryAfterMs) ? Math.max(retryAfterMs, 0) : 0
+          );
+        }
+        if (body?.report_id !== report.report_id) {
+          throw new DiagnosticDeliveryError("Diagnostic report was not acknowledged");
+        }
+      };
+      await Promise.race([upload(), timeoutExpired]);
+    } finally {
+      if (timeout !== void 0) globalThis.clearTimeout(timeout);
+    }
+  }
+  waitForRemoteAudioTrack(deadline, signal) {
+    if ((this.outputMediaStream?.getAudioTracks().length ?? 0) > 0) return Promise.resolve();
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        globalThis.clearTimeout(timeout);
+        signal?.removeEventListener("abort", onAbort);
+        this.remoteAudioTrackResolve = null;
+      };
+      const timeout = globalThis.setTimeout(() => {
+        cleanup();
+        reject(new Error(
+          "Agent audio track did not arrive within the ready timeout; pass waitForRemoteAudio: false to resolve connect() on signaling readiness alone"
+        ));
+      }, Math.max(deadline - Date.now(), 0));
+      const onAbort = () => {
+        cleanup();
+        reject(abortError(signal));
+      };
+      this.remoteAudioTrackResolve = () => {
+        cleanup();
+        resolve();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  waitForAgentReady(timeoutMs, signal) {
+    if (this.agentReady) return Promise.resolve();
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        globalThis.clearTimeout(timeout);
+        signal?.removeEventListener("abort", onAbort);
+        this.readyResolve = null;
+      };
+      const timeout = globalThis.setTimeout(() => {
+        cleanup();
+        reject(new Error(`Agent did not become ready within ${timeoutMs}ms`));
+      }, timeoutMs);
+      const onAbort = () => {
+        cleanup();
+        reject(abortError(signal));
+      };
+      this.readyResolve = () => {
+        cleanup();
+        resolve();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  observeReadiness(event) {
+    if (event.stream_id === "durable-replay") return;
+    const payload = event.payload;
+    const snapshotReady = event.type === "agent.snapshot" && payload.status === "ready" && payload.connection_id === this.connectionId && payload.ack_message_id === this.lastHelloMessageId;
+    if (event.type !== "agent.ready" && !snapshotReady) return;
+    if (this.agentStreamId && this.agentStreamId !== event.stream_id && !this.activeRecovery) {
+      this.startAutoRejoin(
+        new Error("Agent worker was replaced"),
+        { trigger: "worker_replaced" }
+      );
+      return;
+    }
+    this.agentStreamId = event.stream_id;
+    this.agentDisconnected = false;
+    const wasReady = this.agentReady;
+    this.agentReady = true;
+    this.readyResolve?.();
+    if (!wasReady) this.notifyListeners(this.readyListeners, event);
+  }
+  observeCommandResult(event) {
+    if (event.type !== "command.ack" && event.type !== "command.error" && event.type !== "context.updated" && event.type !== "context.rejected") return;
+    const pending = this.pendingCommands.get(String(event.payload.message_id ?? ""));
+    if (!pending) return;
+    if (event.type === "command.ack" && isCommandAckPayload(event.payload)) {
+      this.recordCommandResult(pending, event.type, "acknowledged");
+      globalThis.clearTimeout(pending.timeout);
+      globalThis.clearTimeout(pending.retry);
+      pending.markSettled();
+      this.pendingCommands.delete(event.payload.message_id);
+      pending.resolve(event.payload);
+      return;
+    }
+    if (event.type === "context.updated" && isContextUpdatedPayload(event.payload)) {
+      this.recordCommandResult(pending, event.type, "acknowledged");
+      globalThis.clearTimeout(pending.timeout);
+      globalThis.clearTimeout(pending.retry);
+      pending.markSettled();
+      this.pendingCommands.delete(event.payload.message_id);
+      pending.resolve(event.payload);
+      return;
+    }
+    if (event.type === "command.error" && isCommandErrorPayload(event.payload) || event.type === "context.rejected" && isContextRejectedPayload(event.payload)) {
+      this.recordCommandResult(pending, event.type, "rejected", event.payload.code);
+      this.flushDiagnostics("command_rejected");
+      if (event.type === "context.rejected" && event.payload.retryable) {
+        if (event.payload.code === "stream_unavailable" && pending.retryTransfer && !pending.transferRetrying) {
+          pending.transferRetryRequested = true;
+        }
+        return;
+      }
+      globalThis.clearTimeout(pending.timeout);
+      globalThis.clearTimeout(pending.retry);
+      pending.markSettled();
+      this.pendingCommands.delete(event.payload.message_id);
+      pending.reject(new CommandError(event.payload));
+    }
+  }
+  rejectPendingCommands(error, preserveContext = false) {
+    for (const [messageId, pending] of this.pendingCommands) {
+      if (preserveContext && pending.commandType === "context.update") continue;
+      this.recordCommandResult(
+        pending,
+        pending.commandType === "context.update" ? "context.rejected" : "command.error",
+        "failed",
+        "pending_command_cancelled"
+      );
+      globalThis.clearTimeout(pending.timeout);
+      globalThis.clearTimeout(pending.retry);
+      pending.markSettled();
+      pending.reject(pending.commandType === "context.update" ? new ContextDeliveryError(error.message, { cause: error, retryAfter: pending.transferSettled }) : error);
+      this.pendingCommands.delete(messageId);
+    }
+  }
+  recordCommandResult(pending, eventType, status, reason) {
+    const durationMs = Date.now() - pending.startedAt;
+    this.recordDiagnostic({
+      operation: "command_result",
+      status,
+      reason,
+      message_id: pending.message.message_id,
+      connection_id: pending.message.connection_id,
+      client_seq: pending.message.client_seq,
+      context_key: pending.contextKey,
+      payload_bytes: pending.payloadBytes,
+      duration_ms: durationMs,
+      retry_count: pending.retryCount,
+      event_type: eventType
+    });
+    if (durationMs > 2e3) this.flushDiagnostics("slow_operation");
+  }
+  async fetchReplay(apiBase, afterSeq, options = {}) {
+    const { signal, terminalOnly = false } = options;
+    let nextAfter = afterSeq;
+    while (true) {
+      throwIfAborted(signal);
+      const url = `${apiBase}/sessions/${this.id}/events?after_seq=${nextAfter}&limit=200` + (terminalOnly ? "&terminal_only=true" : "");
+      let response = await raceWithAbort(this.fetcher(
+        url,
+        {
+          headers: { Authorization: `Bearer ${this.accessToken}` },
+          credentials: this.lifecycleCredentials,
+          signal
+        }
+      ), signal);
+      if (response.status === 401 && this.refreshCredentialsCallback) {
+        await this.refreshCredentials(signal);
+        response = await raceWithAbort(this.fetcher(
+          url,
+          {
+            headers: { Authorization: `Bearer ${this.accessToken}` },
+            credentials: this.lifecycleCredentials,
+            signal
+          }
+        ), signal);
+      }
+      if (!response.ok) {
+        throw await raceWithAbort(httpError(response, "Could not replay session events"), signal);
+      }
+      const page = await raceWithAbort(response.json(), signal);
+      throwIfAborted(signal);
+      for (const stored of page.items) {
+        nextAfter = Math.max(nextAfter, stored.server_seq);
+        const event = {
+          protocol_version: 1,
+          event_id: stored.event_id,
+          stream_id: "durable-replay",
+          stream_seq: Math.max(this.cursor.lastStreamSeq, 1),
+          server_seq: stored.server_seq,
+          ts: stored.created_at,
+          type: stored.type,
+          payload: stored.payload
+        };
+        if (!this.cursor.acceptReplay(event)) continue;
+        this.observeReadiness(event);
+        this.observeConvenienceEvents(event);
+        this.notifyListeners(this.listeners, event);
+      }
+      nextAfter = Math.max(nextAfter, page.next_after_seq);
+      if (!page.has_more) return;
+    }
+  }
+};
 function resolveAutoRejoinOptions(value) {
-    if (!value)
-        return null;
-    const options = value === true ? {} : value;
-    const resolved = {
-        maxAttempts: options.maxAttempts ?? Number.MAX_SAFE_INTEGER,
-        baseDelayMs: options.baseDelayMs ?? 750,
-        maxDelayMs: options.maxDelayMs ?? 5_000,
-        timeoutMs: options.timeoutMs ?? 180_000,
-    };
-    if (!Number.isFinite(resolved.timeoutMs) || resolved.timeoutMs <= 0) {
-        throw new TypeError("autoRejoin.timeoutMs must be a positive finite number");
-    }
-    if (!Number.isInteger(resolved.maxAttempts) || resolved.maxAttempts < 1) {
-        throw new TypeError("autoRejoin.maxAttempts must be a positive integer");
-    }
-    if (!Number.isFinite(resolved.baseDelayMs) || resolved.baseDelayMs < 0) {
-        throw new TypeError("autoRejoin.baseDelayMs must be a non-negative finite number");
-    }
-    if (!Number.isFinite(resolved.maxDelayMs) || resolved.maxDelayMs < 0) {
-        throw new TypeError("autoRejoin.maxDelayMs must be a non-negative finite number");
-    }
-    return resolved;
+  if (!value) return null;
+  const options = value === true ? {} : value;
+  const resolved = {
+    maxAttempts: options.maxAttempts ?? Number.MAX_SAFE_INTEGER,
+    baseDelayMs: options.baseDelayMs ?? 750,
+    maxDelayMs: options.maxDelayMs ?? 5e3,
+    timeoutMs: options.timeoutMs ?? 18e4
+  };
+  if (!Number.isFinite(resolved.timeoutMs) || resolved.timeoutMs <= 0) {
+    throw new TypeError("autoRejoin.timeoutMs must be a positive finite number");
+  }
+  if (!Number.isInteger(resolved.maxAttempts) || resolved.maxAttempts < 1) {
+    throw new TypeError("autoRejoin.maxAttempts must be a positive integer");
+  }
+  if (!Number.isFinite(resolved.baseDelayMs) || resolved.baseDelayMs < 0) {
+    throw new TypeError("autoRejoin.baseDelayMs must be a non-negative finite number");
+  }
+  if (!Number.isFinite(resolved.maxDelayMs) || resolved.maxDelayMs < 0) {
+    throw new TypeError("autoRejoin.maxDelayMs must be a non-negative finite number");
+  }
+  return resolved;
 }
 function resolveStartupRetryOptions(value) {
-    if (value === false)
-        return null;
-    const options = typeof value === "object" ? value : {};
-    const attempts = (options.attempts ?? DEFAULT_STARTUP_ATTEMPTS).map((attempt) => ({
-        readyTimeoutMs: attempt.readyTimeoutMs,
-        delayBeforeMs: attempt.delayBeforeMs ?? 0,
-    }));
-    const timeoutMs = options.timeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
-    if (attempts.length === 0) {
-        throw new TypeError("startupRetry.attempts must contain at least one attempt");
-    }
-    for (const attempt of attempts) {
-        if (!Number.isFinite(attempt.readyTimeoutMs) || attempt.readyTimeoutMs <= 0) {
-            throw new TypeError("startupRetry.attempts readyTimeoutMs must be a positive finite number");
-        }
-        if (!Number.isFinite(attempt.delayBeforeMs) || attempt.delayBeforeMs < 0) {
-            throw new TypeError("startupRetry.attempts delayBeforeMs must be a non-negative finite number");
-        }
-    }
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-        throw new TypeError("startupRetry.timeoutMs must be a positive finite number");
-    }
-    return { attempts, timeoutMs };
+  if (value === false) return null;
+  const options = typeof value === "object" ? value : {};
+  const attempts = (options.attempts ?? DEFAULT_STARTUP_ATTEMPTS).map((attempt) => ({
+    readyTimeoutMs: attempt.readyTimeoutMs,
+    delayBeforeMs: attempt.delayBeforeMs ?? 0
+  }));
+  const timeoutMs = options.timeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+  if (attempts.length === 0) {
+    throw new TypeError("startupRetry.attempts must contain at least one attempt");
+  }
+  for (const attempt of attempts) {
+    if (!Number.isFinite(attempt.readyTimeoutMs) || attempt.readyTimeoutMs <= 0) {
+      throw new TypeError(
+        "startupRetry.attempts readyTimeoutMs must be a positive finite number"
+      );
+    }
+    if (!Number.isFinite(attempt.delayBeforeMs) || attempt.delayBeforeMs < 0) {
+      throw new TypeError(
+        "startupRetry.attempts delayBeforeMs must be a non-negative finite number"
+      );
+    }
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new TypeError("startupRetry.timeoutMs must be a positive finite number");
+  }
+  return { attempts, timeoutMs };
 }
 function isTerminalDisconnectReason(reason) {
-    return reason !== undefined && [
-        DisconnectReason.CLIENT_INITIATED,
-        DisconnectReason.DUPLICATE_IDENTITY,
-        DisconnectReason.PARTICIPANT_REMOVED,
-        DisconnectReason.ROOM_DELETED,
-        DisconnectReason.ROOM_CLOSED,
-        DisconnectReason.USER_UNAVAILABLE,
-        DisconnectReason.USER_REJECTED,
-    ].includes(reason);
+  return reason !== void 0 && [
+    DisconnectReason.CLIENT_INITIATED,
+    DisconnectReason.DUPLICATE_IDENTITY,
+    DisconnectReason.PARTICIPANT_REMOVED,
+    DisconnectReason.ROOM_DELETED,
+    DisconnectReason.ROOM_CLOSED,
+    DisconnectReason.USER_UNAVAILABLE,
+    DisconnectReason.USER_REJECTED
+  ].includes(reason);
 }
 function disconnectReasonName(reason) {
-    if (reason === undefined)
-        return "unknown";
-    return DisconnectReason[reason] ?? String(reason);
+  if (reason === void 0) return "unknown";
+  return DisconnectReason[reason] ?? String(reason);
 }
 function isTerminalRejoinError(error) {
-    return error instanceof RealtimeSessionHttpError
-        && [401, 403, 409].includes(error.status);
+  return error instanceof RealtimeSessionHttpError && [401, 403, 409].includes(error.status);
 }
 function isTerminalStartupError(error) {
-    if (error instanceof SessionErrorEventError)
-        return !error.retryable;
-    if (error instanceof RealtimeSessionHttpError) {
-        return error.status >= 400
-            && error.status < 500
-            && ![408, 425, 429].includes(error.status);
-    }
-    // Browser fetch also rejects network failures with TypeError. Only our
-    // explicit configuration errors are terminal before transport is established.
-    if (error instanceof SessionConfigurationError)
-        return true;
-    return error instanceof Error && [
-        "ConstraintNotSatisfiedError",
-        "DevicesNotFoundError",
-        "InvalidStateError",
-        "NotAllowedError",
-        "NotFoundError",
-        "NotReadableError",
-        "NotSupportedError",
-        "OverconstrainedError",
-        "SecurityError",
-        "TrackStartError",
-    ].includes(error.name);
+  if (error instanceof SessionErrorEventError) return !error.retryable;
+  if (error instanceof RealtimeSessionHttpError) {
+    return error.status >= 400 && error.status < 500 && ![408, 425, 429].includes(error.status);
+  }
+  if (error instanceof SessionConfigurationError) return true;
+  return error instanceof Error && [
+    "ConstraintNotSatisfiedError",
+    "DevicesNotFoundError",
+    "InvalidStateError",
+    "NotAllowedError",
+    "NotFoundError",
+    "NotReadableError",
+    "NotSupportedError",
+    "OverconstrainedError",
+    "SecurityError",
+    "TrackStartError"
+  ].includes(error.name);
 }
 function toError(error) {
-    return error instanceof Error ? error : new Error(String(error));
+  return error instanceof Error ? error : new Error(String(error));
 }
 function abortError(signal) {
-    return signal.reason ?? new DOMException("Aborted", "AbortError");
+  return signal.reason ?? new DOMException("Aborted", "AbortError");
 }
 function createLinkedAbortController(parentSignal) {
-    const controller = new AbortController();
-    if (parentSignal.aborted) {
-        controller.abort(abortError(parentSignal));
-    }
-    else {
-        parentSignal.addEventListener("abort", () => controller.abort(abortError(parentSignal)), { once: true });
-    }
-    return controller;
+  const controller = new AbortController();
+  if (parentSignal.aborted) {
+    controller.abort(abortError(parentSignal));
+  } else {
+    parentSignal.addEventListener(
+      "abort",
+      () => controller.abort(abortError(parentSignal)),
+      { once: true }
+    );
+  }
+  return controller;
 }
 function throwIfAborted(signal) {
-    if (signal?.aborted)
-        throw abortError(signal);
+  if (signal?.aborted) throw abortError(signal);
 }
 function raceWithAbort(promise, signal) {
-    if (!signal)
-        return promise;
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const resolveOnce = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            signal.removeEventListener("abort", onAbort);
-            resolve(value);
-        };
-        const rejectOnce = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            signal.removeEventListener("abort", onAbort);
-            reject(error);
-        };
-        const onAbort = () => rejectOnce(abortError(signal));
-        if (signal.aborted) {
-            onAbort();
-        }
-        else {
-            signal.addEventListener("abort", onAbort, { once: true });
-        }
-        // Always observe the operation, including when it aborted the signal before
-        // returning its promise, so a later rejection cannot escape to the caller.
-        promise.then(resolveOnce, rejectOnce);
-    });
+  if (!signal) return promise;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const resolveOnce = (value) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      resolve(value);
+    };
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      reject(error);
+    };
+    const onAbort = () => rejectOnce(abortError(signal));
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+    promise.then(resolveOnce, rejectOnce);
+  });
 }
 function abortableDelay(delayMs, signal) {
-    throwIfAborted(signal);
-    if (delayMs <= 0)
-        return Promise.resolve();
-    return new Promise((resolve, reject) => {
-        const timeout = globalThis.setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, delayMs);
-        const onAbort = () => {
-            globalThis.clearTimeout(timeout);
-            reject(abortError(signal));
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
+  throwIfAborted(signal);
+  if (delayMs <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timeout = globalThis.setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      globalThis.clearTimeout(timeout);
+      reject(abortError(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
 }
 function waitUntilOnline(signal) {
-    throwIfAborted(signal);
-    if (typeof navigator === "undefined" || navigator.onLine !== false) {
-        return Promise.resolve();
-    }
-    if (typeof globalThis.addEventListener !== "function")
-        return Promise.resolve();
-    return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            globalThis.removeEventListener("online", onOnline);
-            signal.removeEventListener("abort", onAbort);
-        };
-        const onOnline = () => {
-            cleanup();
-            resolve();
-        };
-        const onAbort = () => {
-            cleanup();
-            reject(abortError(signal));
-        };
-        globalThis.addEventListener("online", onOnline, { once: true });
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
+  throwIfAborted(signal);
+  if (typeof navigator === "undefined" || navigator.onLine !== false) {
+    return Promise.resolve();
+  }
+  if (typeof globalThis.addEventListener !== "function") return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      globalThis.removeEventListener("online", onOnline);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onOnline = () => {
+      cleanup();
+      resolve();
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(abortError(signal));
+    };
+    globalThis.addEventListener("online", onOnline, { once: true });
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
 }
 async function sha256Hex(data) {
-    if (!globalThis.crypto?.subtle)
-        throw new Error("Web Crypto SHA-256 is unavailable");
-    const digest = await globalThis.crypto.subtle.digest("SHA-256", Uint8Array.from(data).buffer);
-    return [...new Uint8Array(digest)]
-        .map((byte) => byte.toString(16).padStart(2, "0"))
-        .join("");
+  if (!globalThis.crypto?.subtle) throw new Error("Web Crypto SHA-256 is unavailable");
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", Uint8Array.from(data).buffer);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function contextStreamId() {
-    if (globalThis.crypto?.randomUUID)
-        return globalThis.crypto.randomUUID();
-    return `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+  if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
+  return `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
 }
 function contextUpdateBytes(update) {
-    return "image" in update
-        ? update.image.size
-        : new TextEncoder().encode(update.text).byteLength;
+  return "image" in update ? update.image.size : new TextEncoder().encode(update.text).byteLength;
 }
 function contextPayloadBytes(payload) {
-    const image = payload.image;
-    if (image && typeof image === "object" && "bytes" in image) {
-        const bytes = image.bytes;
-        if (typeof bytes === "number")
-            return bytes;
-    }
-    const textStream = payload.text_stream;
-    if (textStream && typeof textStream === "object" && "bytes" in textStream) {
-        const bytes = textStream.bytes;
-        if (typeof bytes === "number")
-            return bytes;
-    }
-    if (typeof payload.text === "string") {
-        return new TextEncoder().encode(payload.text).byteLength;
-    }
-    try {
-        return new TextEncoder().encode(JSON.stringify(payload)).byteLength;
-    }
-    catch {
-        return undefined;
-    }
+  const image = payload.image;
+  if (image && typeof image === "object" && "bytes" in image) {
+    const bytes = image.bytes;
+    if (typeof bytes === "number") return bytes;
+  }
+  const textStream = payload.text_stream;
+  if (textStream && typeof textStream === "object" && "bytes" in textStream) {
+    const bytes = textStream.bytes;
+    if (typeof bytes === "number") return bytes;
+  }
+  if (typeof payload.text === "string") {
+    return new TextEncoder().encode(payload.text).byteLength;
+  }
+  try {
+    return new TextEncoder().encode(JSON.stringify(payload)).byteLength;
+  } catch {
+    return void 0;
+  }
 }
 function contextKeyFromMessage(message) {
-    if (message.type !== "context.update")
-        return undefined;
-    const key = message.payload.key;
-    return typeof key === "string" ? key : undefined;
+  if (message.type !== "context.update") return void 0;
+  const key = message.payload.key;
+  return typeof key === "string" ? key : void 0;
 }
 function diagnosticEventType(type) {
-    return type === "client.hello" || type === "context.update" ? type : undefined;
+  return type === "client.hello" || type === "context.update" ? type : void 0;
 }
 function validateSessionCredentials(value) {
-    if (!value || typeof value !== "object") {
-        throw new SessionConfigurationError("Session credentials must be an object");
-    }
-    if (!value.id || !value.access_token || !value.access_token_expires_at) {
-        throw new SessionConfigurationError("Session credentials are incomplete");
-    }
-    if (!value.connection
-        || !value.connection.url
-        || !value.connection.token
-        || !value.connection.room_name) {
-        throw new SessionConfigurationError("Session connection credentials are incomplete");
-    }
+  if (!value || typeof value !== "object") {
+    throw new SessionConfigurationError("Session credentials must be an object");
+  }
+  if (!value.id || !value.access_token || !value.access_token_expires_at) {
+    throw new SessionConfigurationError("Session credentials are incomplete");
+  }
+  if (!value.connection || !value.connection.url || !value.connection.token || !value.connection.room_name) {
+    throw new SessionConfigurationError("Session connection credentials are incomplete");
+  }
 }
 function normalizeApiBase(value) {
-    const normalized = value.trim().replace(/\/+$/, "");
-    if (!normalized) {
-        throw new SessionConfigurationError("apiBase must be a non-root relative path or an absolute URL");
-    }
-    return normalized;
+  const normalized = value.trim().replace(/\/+$/, "");
+  if (!normalized) {
+    throw new SessionConfigurationError("apiBase must be a non-root relative path or an absolute URL");
+  }
+  return normalized;
 }
 function transcriptEvent(event) {
-    const match = /^transcript\.(user|agent)\.(interim|final)$/.exec(event.type);
-    if (!match)
-        return null;
-    const text = event.payload.text;
-    if (typeof text !== "string")
-        return null;
-    return {
-        role: match[1],
-        text,
-        final: match[2] === "final",
-        event,
-    };
+  const match = /^transcript\.(user|agent)\.(interim|final)$/.exec(event.type);
+  if (!match) return null;
+  const text = event.payload.text;
+  if (typeof text !== "string") return null;
+  return {
+    role: match[1],
+    text,
+    final: match[2] === "final",
+    event
+  };
 }
 async function httpError(response, fallback) {
-    let payload = {};
-    try {
-        payload = await response.json();
-    }
-    catch {
-        // The HTTP status and fallback message remain actionable without a JSON body.
-    }
-    return new RealtimeSessionHttpError(typeof payload.message === "string" ? payload.message : `${fallback} (${response.status})`, {
-        status: response.status,
-        code: typeof payload.error === "string" ? payload.error : null,
-        requestId: typeof payload.request_id === "string" ? payload.request_id : null,
-        details: Array.isArray(payload.details) ? payload.details : [],
-    });
+  let payload = {};
+  try {
+    payload = await response.json();
+  } catch {
+  }
+  return new RealtimeSessionHttpError(
+    typeof payload.message === "string" ? payload.message : `${fallback} (${response.status})`,
+    {
+      status: response.status,
+      code: typeof payload.error === "string" ? payload.error : null,
+      requestId: typeof payload.request_id === "string" ? payload.request_id : null,
+      details: Array.isArray(payload.details) ? payload.details : []
+    }
+  );
 }
-//# sourceMappingURL=index.js.map
+export {
+  CommandError2 as CommandError,
+  EventCursor2 as EventCursor,
+  RealtimeSession,
+  RealtimeSessionHttpError,
+  SDK_VERSION,
+  TranscriptStore2 as TranscriptStore,
+  createClientMessage2 as createClientMessage,
+  decodeAgentSnapshotPayload,
+  decodeClientHelloPayload,
+  decodeClientMessage,
+  decodeCommandAckPayload,
+  decodeCommandErrorPayload,
+  decodeContextRejectedPayload,
+  decodeContextUpdatePayload,
+  decodeContextUpdatedPayload,
+  decodeRealtimeEvent,
+  isCommandAckPayload2 as isCommandAckPayload,
+  isCommandErrorPayload2 as isCommandErrorPayload,
+  isContextRejectedPayload2 as isContextRejectedPayload,
+  isContextUpdatePayload2 as isContextUpdatePayload,
+  isContextUpdatedPayload2 as isContextUpdatedPayload,
+  isRealtimeEvent2 as isRealtimeEvent
+};
+//# sourceMappingURL=index.js.map