@absolutejs/voice 0.0.22-beta.51 → 0.0.22-beta.511

package/dist/client/htmxBootstrap.js

@@ -188,6 +188,11 @@ var serverMessageToAction = (message) => {
         sessionId: message.sessionId,
         type: "complete"
       };
+    case "connection":
+      return {
+        reconnect: message.reconnect,
+        type: "connection"
+      };
     case "call_lifecycle":
       return {
         event: message.event,
@@ -209,9 +214,22 @@ var serverMessageToAction = (message) => {
         transcript: message.transcript,
         type: "partial"
       };
+    case "replay":
+      return {
+        assistantTexts: message.assistantTexts,
+        call: message.call,
+        partial: message.partial,
+        scenarioId: message.scenarioId,
+        sessionId: message.sessionId,
+        sessionMetadata: message.sessionMetadata,
+        status: message.status,
+        turns: message.turns,
+        type: "replay"
+      };
     case "session":
       return {
         sessionId: message.sessionId,
+        sessionMetadata: message.sessionMetadata,
         scenarioId: message.scenarioId,
         status: message.status,
         type: "session"
@@ -226,6 +244,232 @@ var serverMessageToAction = (message) => {
   }
 };
 
+// node_modules/@absolutejs/media/dist/index.js
+var pushIssue = (issues, severity, code, message) => {
+  issues.push({ code, message, severity });
+};
+var average = (values) => values.length === 0 ? undefined : values.reduce((total, value) => total + value, 0) / values.length;
+var max = (values) => values.length === 0 ? undefined : Math.max(...values);
+var numericStat = (stat, key) => {
+  const value = stat[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+};
+var booleanStat = (stat, key) => {
+  const value = stat[key];
+  return typeof value === "boolean" ? value : undefined;
+};
+var stringStat = (stat, key) => {
+  const value = stat[key];
+  return typeof value === "string" ? value : undefined;
+};
+var statKey = (stat) => String(stat.id ?? stringStat(stat, "ssrc") ?? numericStat(stat, "ssrc") ?? stringStat(stat, "trackIdentifier") ?? stringStat(stat, "mid") ?? "unknown");
+var secondsToMs = (value) => value === undefined ? undefined : value * 1000;
+var normalizeWebRTCStat = (stat) => {
+  const sample = {};
+  for (const [key, value] of Object.entries(stat)) {
+    if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+      sample[key] = value;
+    }
+  }
+  return sample;
+};
+var buildMediaWebRTCStatsReport = (input = {}) => {
+  const stats = input.stats ?? [];
+  const issues = [];
+  const inbound = stats.filter((stat) => stat.type === "inbound-rtp" && stringStat(stat, "kind") !== "video");
+  const outbound = stats.filter((stat) => stat.type === "outbound-rtp" && stringStat(stat, "kind") !== "video");
+  const candidatePairs = stats.filter((stat) => stat.type === "candidate-pair");
+  const audioTracks = stats.filter((stat) => (stat.type === "track" || stat.type === "media-source") && stringStat(stat, "kind") === "audio");
+  const activeCandidatePairs = candidatePairs.filter((stat) => booleanStat(stat, "selected") === true || booleanStat(stat, "nominated") === true || stringStat(stat, "state") === "succeeded").length;
+  const liveAudioTracks = audioTracks.filter((stat) => stringStat(stat, "readyState") !== "ended" && stringStat(stat, "trackState") !== "ended" && booleanStat(stat, "ended") !== true).length;
+  const endedAudioTracks = audioTracks.filter((stat) => stringStat(stat, "readyState") === "ended" || stringStat(stat, "trackState") === "ended" || booleanStat(stat, "ended") === true).length;
+  const inboundPackets = inbound.reduce((total, stat) => total + (numericStat(stat, "packetsReceived") ?? 0), 0);
+  const outboundPackets = outbound.reduce((total, stat) => total + (numericStat(stat, "packetsSent") ?? 0), 0);
+  const packetsLost = [...inbound, ...outbound].reduce((total, stat) => total + Math.max(0, numericStat(stat, "packetsLost") ?? 0), 0);
+  const packetLossDenominator = inboundPackets + packetsLost;
+  const packetLossRatio = packetLossDenominator === 0 ? 0 : packetsLost / packetLossDenominator;
+  const bytesReceived = inbound.reduce((total, stat) => total + (numericStat(stat, "bytesReceived") ?? 0), 0);
+  const bytesSent = outbound.reduce((total, stat) => total + (numericStat(stat, "bytesSent") ?? 0), 0);
+  const roundTripTimeMs = max(candidatePairs.map((stat) => secondsToMs(numericStat(stat, "currentRoundTripTime") ?? numericStat(stat, "roundTripTime"))).filter((value) => value !== undefined));
+  const jitterMs = max([...inbound, ...outbound].map((stat) => secondsToMs(numericStat(stat, "jitter"))).filter((value) => value !== undefined));
+  const jitterBufferDelayMs = max(inbound.map((stat) => {
+    const delay = numericStat(stat, "jitterBufferDelay");
+    const emitted = numericStat(stat, "jitterBufferEmittedCount");
+    return delay !== undefined && emitted !== undefined && emitted > 0 ? delay / emitted * 1000 : undefined;
+  }).filter((value) => value !== undefined));
+  const audioLevels = audioTracks.map((stat) => numericStat(stat, "audioLevel")).filter((value) => value !== undefined);
+  if (input.requireConnectedCandidatePair && candidatePairs.length > 0 && activeCandidatePairs === 0) {
+    pushIssue(issues, "error", "media.webrtc_candidate_pair_missing", "No active WebRTC candidate pair was observed.");
+  }
+  if (input.requireLiveAudioTrack && liveAudioTracks === 0) {
+    pushIssue(issues, "error", "media.webrtc_audio_track_missing", "No live WebRTC audio track was observed.");
+  }
+  if (input.maxPacketLossRatio !== undefined && packetLossRatio > input.maxPacketLossRatio) {
+    pushIssue(issues, "warning", "media.webrtc_packet_loss", `Observed WebRTC packet loss ratio ${String(packetLossRatio)} above ${String(input.maxPacketLossRatio)}.`);
+  }
+  if (input.maxRoundTripTimeMs !== undefined && roundTripTimeMs !== undefined && roundTripTimeMs > input.maxRoundTripTimeMs) {
+    pushIssue(issues, "warning", "media.webrtc_round_trip_time", `Observed WebRTC RTT ${String(roundTripTimeMs)}ms above ${String(input.maxRoundTripTimeMs)}ms.`);
+  }
+  if (input.maxJitterMs !== undefined && jitterMs !== undefined && jitterMs > input.maxJitterMs) {
+    pushIssue(issues, "warning", "media.webrtc_jitter", `Observed WebRTC jitter ${String(jitterMs)}ms above ${String(input.maxJitterMs)}ms.`);
+  }
+  return {
+    activeCandidatePairs,
+    audioLevelAverage: average(audioLevels),
+    bytesReceived,
+    bytesSent,
+    checkedAt: Date.now(),
+    endedAudioTracks,
+    inboundPackets,
+    issues,
+    jitterBufferDelayMs,
+    jitterMs,
+    liveAudioTracks,
+    outboundPackets,
+    packetLossRatio,
+    packetsLost,
+    roundTripTimeMs,
+    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
+    totalStats: stats.length
+  };
+};
+var collectMediaWebRTCStats = async (input) => {
+  const report = await input.peerConnection.getStats(input.selector ?? null);
+  return [...report.values()].map(normalizeWebRTCStat);
+};
+var buildMediaWebRTCStreamContinuityReport = (input = {}) => {
+  const stats = input.stats ?? [];
+  const previousStats = input.previousStats ?? [];
+  const issues = [];
+  const previousByKey = new Map(previousStats.map((stat) => [statKey(stat), stat]));
+  const audioRtp = stats.filter((stat) => (stat.type === "inbound-rtp" || stat.type === "outbound-rtp") && stringStat(stat, "kind") !== "video" && stringStat(stat, "mediaType") !== "video");
+  const streams = audioRtp.map((stat) => {
+    const direction = stat.type === "outbound-rtp" ? "outbound" : "inbound";
+    const packetsKey = direction === "outbound" ? "packetsSent" : "packetsReceived";
+    const bytesKey = direction === "outbound" ? "bytesSent" : "bytesReceived";
+    const previous = previousByKey.get(statKey(stat));
+    const currentPackets = numericStat(stat, packetsKey);
+    const previousPackets = previous ? numericStat(previous, packetsKey) : undefined;
+    const currentBytes = numericStat(stat, bytesKey);
+    const previousBytes = previous ? numericStat(previous, bytesKey) : undefined;
+    const timeDeltaMs = stat.timestamp !== undefined && previous?.timestamp !== undefined ? stat.timestamp - previous.timestamp : undefined;
+    return {
+      bytesDelta: currentBytes !== undefined && previousBytes !== undefined ? currentBytes - previousBytes : undefined,
+      currentPackets,
+      direction,
+      id: statKey(stat),
+      packetDelta: currentPackets !== undefined && previousPackets !== undefined ? currentPackets - previousPackets : undefined,
+      previousPackets,
+      timeDeltaMs
+    };
+  });
+  const inbound = streams.filter((stream) => stream.direction === "inbound");
+  const outbound = streams.filter((stream) => stream.direction === "outbound");
+  const maxObservedGapMs = max(streams.map((stream) => stream.timeDeltaMs).filter((value) => value !== undefined));
+  const stalledInboundStreams = inbound.filter((stream) => input.maxInboundPacketStallMs !== undefined && stream.timeDeltaMs !== undefined && stream.timeDeltaMs >= input.maxInboundPacketStallMs && stream.packetDelta !== undefined && stream.packetDelta <= 0).length;
+  const stalledOutboundStreams = outbound.filter((stream) => input.maxOutboundPacketStallMs !== undefined && stream.timeDeltaMs !== undefined && stream.timeDeltaMs >= input.maxOutboundPacketStallMs && stream.packetDelta !== undefined && stream.packetDelta <= 0).length;
+  if (input.requireInboundAudio && inbound.length === 0) {
+    pushIssue(issues, "error", "media.webrtc_inbound_audio_missing", "No inbound WebRTC audio RTP stream was observed.");
+  }
+  if (input.requireOutboundAudio && outbound.length === 0) {
+    pushIssue(issues, "error", "media.webrtc_outbound_audio_missing", "No outbound WebRTC audio RTP stream was observed.");
+  }
+  if (input.maxGapMs !== undefined && maxObservedGapMs !== undefined && maxObservedGapMs > input.maxGapMs) {
+    pushIssue(issues, "warning", "media.webrtc_stream_gap", `Observed WebRTC stream sample gap ${String(maxObservedGapMs)}ms above ${String(input.maxGapMs)}ms.`);
+  }
+  if (stalledInboundStreams > 0) {
+    pushIssue(issues, "error", "media.webrtc_inbound_stalled", `${String(stalledInboundStreams)} inbound WebRTC audio stream(s) stopped receiving packets.`);
+  }
+  if (stalledOutboundStreams > 0) {
+    pushIssue(issues, "error", "media.webrtc_outbound_stalled", `${String(stalledOutboundStreams)} outbound WebRTC audio stream(s) stopped sending packets.`);
+  }
+  return {
+    checkedAt: Date.now(),
+    inboundAudioStreams: inbound.length,
+    issues,
+    maxObservedGapMs,
+    outboundAudioStreams: outbound.length,
+    stalledInboundStreams,
+    stalledOutboundStreams,
+    status: issues.some((issue) => issue.severity === "error") ? "fail" : issues.length > 0 ? "warn" : "pass",
+    streams,
+    totalStats: stats.length
+  };
+};
+
+// src/client/browserMedia.ts
+var DEFAULT_BROWSER_MEDIA_PATH = "/api/voice/browser-media";
+var DEFAULT_BROWSER_MEDIA_INTERVAL_MS = 5000;
+var resolvePeerConnection = async (options) => options.peerConnection ?? await options.getPeerConnection?.() ?? null;
+var postBrowserMediaReport = async (payload, options) => {
+  const requestFetch = options.fetch ?? globalThis.fetch;
+  if (!requestFetch) {
+    return;
+  }
+  await requestFetch(options.path ?? DEFAULT_BROWSER_MEDIA_PATH, {
+    body: JSON.stringify(payload),
+    headers: {
+      "Content-Type": "application/json"
+    },
+    keepalive: true,
+    method: "POST"
+  });
+};
+var createVoiceBrowserMediaReporter = (options) => {
+  let interval = null;
+  let previousStats = [];
+  const reportOnce = async () => {
+    const peerConnection = await resolvePeerConnection(options);
+    if (!peerConnection) {
+      return;
+    }
+    const stats = await collectMediaWebRTCStats({ peerConnection });
+    const report = buildMediaWebRTCStatsReport({
+      ...options,
+      stats
+    });
+    const continuity = options.continuity === false ? undefined : buildMediaWebRTCStreamContinuityReport({
+      ...options.continuity,
+      previousStats,
+      stats
+    });
+    const payload = {
+      at: Date.now(),
+      continuity,
+      report,
+      scenarioId: options.getScenarioId?.() ?? null,
+      sessionId: options.getSessionId?.() ?? null
+    };
+    previousStats = stats;
+    options.onReport?.(payload);
+    await postBrowserMediaReport(payload, options);
+    return payload;
+  };
+  const run = () => {
+    reportOnce().catch((error) => {
+      options.onError?.(error);
+    });
+  };
+  const stop = () => {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+  };
+  return {
+    close: stop,
+    reportOnce,
+    start: () => {
+      if (interval) {
+        return;
+      }
+      run();
+      interval = setInterval(run, options.intervalMs ?? DEFAULT_BROWSER_MEDIA_INTERVAL_MS);
+    },
+    stop
+  };
+};
+
 // src/client/connection.ts
 var WS_OPEN = 1;
 var WS_CLOSED = 3;
@@ -245,6 +489,7 @@ var NOOP_CONNECTION = {
   getSessionId: () => "",
   send: noop,
   sendAudio: noop,
+  simulateDisconnect: noop,
   start: () => {},
   subscribe: noopUnsubscribe
 };
@@ -269,10 +514,12 @@ var isVoiceServerMessage = (value) => {
     case "assistant":
     case "call_lifecycle":
     case "complete":
+    case "connection":
     case "error":
     case "final":
     case "partial":
     case "pong":
+    case "replay":
     case "session":
     case "turn":
       return true;
@@ -309,6 +556,9 @@ var createVoiceConnection = (path, options = {}) => {
     sessionId: options.sessionId ?? createSessionId(),
     ws: null
   };
+  const emitConnection = (reconnect) => {
+    listeners.forEach((listener) => listener(reconnect));
+  };
   const clearTimers = () => {
     if (state.pingInterval) {
       clearInterval(state.pingInterval);
@@ -331,9 +581,28 @@ var createVoiceConnection = (path, options = {}) => {
     }
   };
   const scheduleReconnect = () => {
+    const nextAttemptAt = Date.now() + RECONNECT_DELAY_MS;
     state.reconnectAttempts += 1;
+    emitConnection({
+      reconnect: {
+        attempts: state.reconnectAttempts,
+        lastDisconnectAt: Date.now(),
+        maxAttempts: maxReconnectAttempts,
+        nextAttemptAt,
+        status: "reconnecting"
+      },
+      type: "connection"
+    });
     state.reconnectTimeout = setTimeout(() => {
       if (state.reconnectAttempts > maxReconnectAttempts) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
         return;
       }
       connect();
@@ -343,9 +612,21 @@ var createVoiceConnection = (path, options = {}) => {
     const ws = new WebSocket(buildWsUrl(path, state.sessionId, state.scenarioId));
     ws.binaryType = "arraybuffer";
     ws.onopen = () => {
+      const wasReconnecting = state.reconnectAttempts > 0;
       state.isConnected = true;
-      state.reconnectAttempts = 0;
       flushPendingMessages();
+      if (wasReconnecting) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastResumedAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "resumed"
+          },
+          type: "connection"
+        });
+        state.reconnectAttempts = 0;
+      }
       listeners.forEach((listener) => listener({
         scenarioId: state.scenarioId ?? undefined,
         sessionId: state.sessionId,
@@ -375,6 +656,16 @@ var createVoiceConnection = (path, options = {}) => {
       const reconnectable = shouldReconnect && event.code !== WS_NORMAL_CLOSURE && state.reconnectAttempts < maxReconnectAttempts;
       if (reconnectable) {
         scheduleReconnect();
+      } else if (shouldReconnect && event.code !== WS_NORMAL_CLOSURE) {
+        emitConnection({
+          reconnect: {
+            attempts: state.reconnectAttempts,
+            lastDisconnectAt: Date.now(),
+            maxAttempts: maxReconnectAttempts,
+            status: "exhausted"
+          },
+          type: "connection"
+        });
       }
     };
     state.ws = ws;
@@ -423,6 +714,11 @@ var createVoiceConnection = (path, options = {}) => {
     state.isConnected = false;
     listeners.clear();
   };
+  const simulateDisconnect = () => {
+    if (state.ws?.readyState === WS_OPEN) {
+      state.ws.close(4000, "absolutejs-voice-reconnect-proof");
+    }
+  };
   const subscribe = (callback) => {
     listeners.add(callback);
     return () => {
@@ -439,20 +735,28 @@ var createVoiceConnection = (path, options = {}) => {
     getSessionId: () => state.sessionId,
     send,
     sendAudio,
+    simulateDisconnect,
     start,
     subscribe
   };
 };
 
 // src/client/store.ts
+var createInitialReconnectState = () => ({
+  attempts: 0,
+  maxAttempts: 0,
+  status: "idle"
+});
 var createInitialState = () => ({
   assistantAudio: [],
   assistantTexts: [],
   call: null,
   error: null,
   isConnected: false,
+  sessionMetadata: null,
   scenarioId: null,
   partial: "",
+  reconnect: createInitialReconnectState(),
   sessionId: null,
   status: "idle",
   turns: []
@@ -509,7 +813,19 @@ var createVoiceStreamStore = () => {
       case "connected":
         state = {
           ...state,
-          isConnected: true
+          isConnected: true,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect
+        };
+        break;
+      case "connection":
+        state = {
+          ...state,
+          reconnect: action.reconnect
         };
         break;
       case "disconnected":
@@ -537,6 +853,27 @@ var createVoiceStreamStore = () => {
           partial: action.transcript.text
         };
         break;
+      case "replay":
+        state = {
+          ...state,
+          assistantTexts: [...action.assistantTexts],
+          call: action.call ?? null,
+          error: null,
+          isConnected: action.status === "active",
+          partial: action.partial,
+          reconnect: state.reconnect.status === "reconnecting" ? {
+            ...state.reconnect,
+            lastResumedAt: Date.now(),
+            nextAttemptAt: undefined,
+            status: "resumed"
+          } : state.reconnect,
+          scenarioId: action.scenarioId ?? state.scenarioId,
+          sessionId: action.sessionId,
+          sessionMetadata: action.sessionMetadata ?? state.sessionMetadata,
+          status: action.status,
+          turns: [...action.turns]
+        };
+        break;
       case "session":
         state = {
           ...state,
@@ -544,6 +881,7 @@ var createVoiceStreamStore = () => {
           scenarioId: action.scenarioId ?? state.scenarioId,
           isConnected: action.status === "active",
           sessionId: action.sessionId,
+          sessionMetadata: action.sessionMetadata ?? state.sessionMetadata,
           status: action.status
         };
         break;
@@ -574,20 +912,50 @@ var createVoiceStreamStore = () => {
 var createVoiceStream = (path, options = {}) => {
   const connection = createVoiceConnection(path, options);
   const store = createVoiceStreamStore();
+  const browserMediaReporter = options.browserMedia && typeof window !== "undefined" ? createVoiceBrowserMediaReporter({
+    ...options.browserMedia,
+    getScenarioId: () => options.browserMedia ? options.browserMedia.getScenarioId?.() ?? connection.getScenarioId() : connection.getScenarioId(),
+    getSessionId: () => options.browserMedia ? options.browserMedia.getSessionId?.() ?? connection.getSessionId() : connection.getSessionId()
+  }) : null;
   const subscribers = new Set;
   const start = (input) => Promise.resolve().then(() => {
     if (!input?.sessionId && !input?.scenarioId) {
       return;
     }
     connection.start(input);
+    browserMediaReporter?.start();
   });
   const notify = () => {
     subscribers.forEach((subscriber) => subscriber());
   };
+  const reportReconnect = () => {
+    if (!options.reconnectReportPath || typeof fetch === "undefined") {
+      return;
+    }
+    const snapshot = store.getSnapshot();
+    const body = JSON.stringify({
+      at: Date.now(),
+      reconnect: snapshot.reconnect,
+      scenarioId: snapshot.scenarioId,
+      sessionId: connection.getSessionId(),
+      turnIds: snapshot.turns.map((turn) => turn.id)
+    });
+    fetch(options.reconnectReportPath, {
+      body,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      keepalive: true,
+      method: "POST"
+    }).catch(() => {});
+  };
   const unsubscribeConnection = connection.subscribe((message) => {
     const action = serverMessageToAction(message);
     if (action) {
       store.dispatch(action);
+      if (message.type === "connection") {
+        reportReconnect();
+      }
       notify();
     }
   });
@@ -597,6 +965,7 @@ var createVoiceStream = (path, options = {}) => {
     },
     close() {
       unsubscribeConnection();
+      browserMediaReporter?.close();
       connection.close();
       store.dispatch({ type: "disconnected" });
       notify();
@@ -619,10 +988,16 @@ var createVoiceStream = (path, options = {}) => {
     get scenarioId() {
       return store.getSnapshot().scenarioId;
     },
+    get sessionMetadata() {
+      return store.getSnapshot().sessionMetadata;
+    },
     start,
     get partial() {
       return store.getSnapshot().partial;
     },
+    get reconnect() {
+      return store.getSnapshot().reconnect;
+    },
     get sessionId() {
       return connection.getSessionId();
     },
@@ -644,6 +1019,9 @@ var createVoiceStream = (path, options = {}) => {
     sendAudio(audio) {
       connection.sendAudio(audio);
     },
+    simulateDisconnect() {
+      connection.simulateDisconnect();
+    },
     subscribe(subscriber) {
       subscribers.add(subscriber);
       return () => {
@@ -941,8 +1319,10 @@ var createInitialState2 = (stream) => ({
   isConnected: stream.isConnected,
   isRecording: false,
   partial: stream.partial,
+  reconnect: stream.reconnect,
   recordingError: null,
   sessionId: stream.sessionId,
+  sessionMetadata: stream.sessionMetadata,
   scenarioId: stream.scenarioId,
   status: stream.status,
   turns: [...stream.turns]
@@ -970,7 +1350,9 @@ var createVoiceController = (path, options = {}) => {
       error: stream.error,
       isConnected: stream.isConnected,
       partial: stream.partial,
+      reconnect: stream.reconnect,
       sessionId: stream.sessionId,
+      sessionMetadata: stream.sessionMetadata,
       scenarioId: stream.scenarioId,
       status: stream.status,
       turns: [...stream.turns]
@@ -994,7 +1376,13 @@ var createVoiceController = (path, options = {}) => {
     capture = createMicrophoneCapture({
       channelCount: options.capture?.channelCount ?? preset.capture.channelCount,
       onLevel: options.capture?.onLevel,
-      onAudio: (audio) => stream.sendAudio(audio),
+      onAudio: (audio) => {
+        if (options.capture?.onAudio) {
+          options.capture.onAudio(audio, stream.sendAudio);
+          return;
+        }
+        stream.sendAudio(audio);
+      },
       sampleRateHz: options.capture?.sampleRateHz ?? preset.capture.sampleRateHz
     });
     return capture;
@@ -1064,10 +1452,17 @@ var createVoiceController = (path, options = {}) => {
     get recordingError() {
       return state.recordingError;
     },
+    get reconnect() {
+      return state.reconnect;
+    },
     sendAudio: (audio) => stream.sendAudio(audio),
+    simulateDisconnect: () => stream.simulateDisconnect(),
     get sessionId() {
       return state.sessionId;
     },
+    get sessionMetadata() {
+      return state.sessionMetadata;
+    },
     get scenarioId() {
       return state.scenarioId;
     },
@@ -1104,6 +1499,475 @@ var createVoiceController = (path, options = {}) => {
   };
 };
 
+// src/client/audioPlayer.ts
+var DEFAULT_LOOKAHEAD_MS = 15;
+var createInitialState3 = () => ({
+  activeSourceCount: 0,
+  error: null,
+  isActive: false,
+  isPlaying: false,
+  lastInterruptLatencyMs: undefined,
+  lastPlaybackStopLatencyMs: undefined,
+  processedChunkCount: 0,
+  queuedChunkCount: 0
+});
+var getAudioContextCtor = () => {
+  if (typeof window === "undefined") {
+    return typeof AudioContext === "undefined" ? undefined : AudioContext;
+  }
+  return window.AudioContext ?? window.webkitAudioContext;
+};
+var decodePCM16LEChunk = (audioContext, chunk) => {
+  const format = chunk.format;
+  if (format.container !== "raw" || format.encoding !== "pcm_s16le") {
+    throw new Error(`Unsupported assistant audio format: ${format.container}/${format.encoding}`);
+  }
+  const bytes = chunk.chunk;
+  const channels = Math.max(1, format.channels);
+  const sampleCount = Math.floor(bytes.byteLength / 2);
+  const frameCount = Math.max(1, Math.floor(sampleCount / channels));
+  const audioBuffer = audioContext.createBuffer(channels, frameCount, format.sampleRateHz);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (let channelIndex = 0;channelIndex < channels; channelIndex += 1) {
+    const channelData = audioBuffer.getChannelData(channelIndex);
+    for (let frameIndex = 0;frameIndex < frameCount; frameIndex += 1) {
+      const sampleIndex = frameIndex * channels + channelIndex;
+      const sampleOffset = sampleIndex * 2;
+      if (sampleOffset + 1 >= bytes.byteLength) {
+        channelData[frameIndex] = 0;
+        continue;
+      }
+      channelData[frameIndex] = view.getInt16(sampleOffset, true) / 32768;
+    }
+  }
+  return audioBuffer;
+};
+var createVoiceAudioPlayer = (source, options = {}) => {
+  const subscribers = new Set;
+  const sourceNodes = new Set;
+  const lookaheadSeconds = (options.lookaheadMs ?? DEFAULT_LOOKAHEAD_MS) / 1000;
+  let state = createInitialState3();
+  let audioContext = null;
+  let outputNode = null;
+  let queueEndTime = 0;
+  let syncPromise = Promise.resolve();
+  let interruptStartedAt = null;
+  let interruptPromise = null;
+  let resolveInterruptPromise = null;
+  let interruptFallbackTimer = null;
+  const notify = () => {
+    for (const subscriber of subscribers) {
+      subscriber();
+    }
+  };
+  const setState = (next) => {
+    state = {
+      ...state,
+      ...next
+    };
+    notify();
+  };
+  const clearError = () => {
+    if (state.error !== null) {
+      setState({ error: null });
+    }
+  };
+  const clearInterruptTimer = () => {
+    if (interruptFallbackTimer !== null) {
+      clearTimeout(interruptFallbackTimer);
+      interruptFallbackTimer = null;
+    }
+  };
+  const resolveInterrupt = (latencyMs) => {
+    clearInterruptTimer();
+    interruptStartedAt = null;
+    setState({
+      activeSourceCount: sourceNodes.size,
+      isPlaying: false,
+      lastInterruptLatencyMs: latencyMs,
+      lastPlaybackStopLatencyMs: state.lastPlaybackStopLatencyMs ?? latencyMs
+    });
+    resolveInterruptPromise?.();
+    resolveInterruptPromise = null;
+    interruptPromise = null;
+  };
+  const estimateOutputStopLatencyMs = (context) => {
+    if (!context) {
+      return 0;
+    }
+    return Math.max(0, ((context.baseLatency ?? 0) + (context.outputLatency ?? 0)) * 1000);
+  };
+  const restoreOutputGain = (context) => {
+    if (!outputNode) {
+      return;
+    }
+    const gainValue = 1;
+    if (outputNode.gain.setValueAtTime) {
+      outputNode.gain.setValueAtTime(gainValue, context?.currentTime ?? 0);
+      return;
+    }
+    outputNode.gain.value = gainValue;
+  };
+  const muteOutputGain = (context) => {
+    if (!outputNode) {
+      return;
+    }
+    const gainValue = 0;
+    if (outputNode.gain.setValueAtTime) {
+      outputNode.gain.setValueAtTime(gainValue, context?.currentTime ?? 0);
+      return;
+    }
+    outputNode.gain.value = gainValue;
+  };
+  const maybeResolveInterrupt = () => {
+    if (interruptStartedAt === null || sourceNodes.size > 0) {
+      return;
+    }
+    resolveInterrupt(Date.now() - interruptStartedAt);
+  };
+  const ensureAudioContext = async () => {
+    if (audioContext) {
+      return audioContext;
+    }
+    if (options.createAudioContext) {
+      audioContext = options.createAudioContext();
+    } else {
+      const AudioContextCtor = getAudioContextCtor();
+      if (!AudioContextCtor) {
+        throw new Error("Assistant audio playback requires AudioContext support.");
+      }
+      audioContext = new AudioContextCtor;
+    }
+    if (audioContext.createGain) {
+      outputNode = audioContext.createGain();
+      outputNode.connect?.(audioContext.destination);
+    }
+    queueEndTime = audioContext.currentTime;
+    return audioContext;
+  };
+  const scheduleChunk = async (chunk) => {
+    const context = await ensureAudioContext();
+    const buffer = decodePCM16LEChunk(context, chunk);
+    const node = context.createBufferSource();
+    node.buffer = buffer;
+    node.connect(outputNode ?? context.destination);
+    node.onended = () => {
+      sourceNodes.delete(node);
+      node.disconnect?.();
+      setState({
+        activeSourceCount: sourceNodes.size,
+        isPlaying: sourceNodes.size > 0 && state.isActive
+      });
+      maybeResolveInterrupt();
+    };
+    const startAt = Math.max(context.currentTime + lookaheadSeconds, queueEndTime);
+    queueEndTime = startAt + buffer.duration;
+    sourceNodes.add(node);
+    setState({
+      activeSourceCount: sourceNodes.size,
+      isPlaying: true
+    });
+    node.start(startAt);
+  };
+  const stopQueuedPlayback = (options2) => {
+    for (const node of [...sourceNodes]) {
+      node.stop?.();
+    }
+    queueEndTime = audioContext ? audioContext.currentTime : 0;
+    if (options2?.forceClear) {
+      for (const node of sourceNodes) {
+        node.disconnect?.();
+      }
+      sourceNodes.clear();
+      maybeResolveInterrupt();
+    }
+  };
+  const sync = async () => {
+    if (!state.isActive) {
+      return;
+    }
+    const nextChunks = source.assistantAudio.slice(state.processedChunkCount);
+    if (nextChunks.length === 0) {
+      return;
+    }
+    try {
+      clearError();
+      for (const chunk of nextChunks) {
+        await scheduleChunk(chunk);
+      }
+      setState({
+        processedChunkCount: source.assistantAudio.length,
+        queuedChunkCount: state.queuedChunkCount + nextChunks.length
+      });
+    } catch (error) {
+      setState({
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  };
+  const queueSync = () => {
+    syncPromise = syncPromise.then(() => sync(), () => sync());
+    return syncPromise;
+  };
+  const unsubscribeSource = source.subscribe(() => {
+    if (options.autoStart && !state.isActive && source.assistantAudio.length > 0) {
+      player.start();
+      return;
+    }
+    if (state.isActive) {
+      queueSync();
+    }
+  });
+  const player = {
+    close: async () => {
+      unsubscribeSource();
+      stopQueuedPlayback({ forceClear: true });
+      clearInterruptTimer();
+      resolveInterruptPromise?.();
+      resolveInterruptPromise = null;
+      interruptPromise = null;
+      interruptStartedAt = null;
+      if (audioContext && audioContext.state !== "closed") {
+        await audioContext.close();
+      }
+      audioContext = null;
+      outputNode?.disconnect?.();
+      outputNode = null;
+      queueEndTime = 0;
+      setState({
+        activeSourceCount: 0,
+        isActive: false,
+        isPlaying: false
+      });
+    },
+    get activeSourceCount() {
+      return state.activeSourceCount;
+    },
+    get error() {
+      return state.error;
+    },
+    getSnapshot: () => state,
+    get isActive() {
+      return state.isActive;
+    },
+    get isPlaying() {
+      return state.isPlaying;
+    },
+    interrupt: async () => {
+      const startedAt = Date.now();
+      const context = await ensureAudioContext();
+      interruptStartedAt = startedAt;
+      muteOutputGain(context);
+      const playbackStopLatencyMs = Date.now() - startedAt + estimateOutputStopLatencyMs(context);
+      setState({
+        isActive: false,
+        isPlaying: sourceNodes.size > 0,
+        lastPlaybackStopLatencyMs: playbackStopLatencyMs
+      });
+      if (sourceNodes.size === 0) {
+        resolveInterrupt(playbackStopLatencyMs);
+        return;
+      }
+      if (!interruptPromise) {
+        interruptPromise = new Promise((resolve) => {
+          resolveInterruptPromise = resolve;
+        });
+      }
+      clearInterruptTimer();
+      interruptFallbackTimer = setTimeout(() => {
+        for (const node of sourceNodes) {
+          node.disconnect?.();
+        }
+        sourceNodes.clear();
+        resolveInterrupt(Date.now() - startedAt);
+      }, 250);
+      stopQueuedPlayback();
+      await interruptPromise;
+    },
+    get lastInterruptLatencyMs() {
+      return state.lastInterruptLatencyMs;
+    },
+    get lastPlaybackStopLatencyMs() {
+      return state.lastPlaybackStopLatencyMs;
+    },
+    pause: async () => {
+      if (!audioContext) {
+        setState({
+          activeSourceCount: 0,
+          isActive: false,
+          isPlaying: false
+        });
+        return;
+      }
+      await audioContext.suspend();
+      setState({
+        activeSourceCount: sourceNodes.size,
+        isActive: false,
+        isPlaying: false
+      });
+    },
+    get processedChunkCount() {
+      return state.processedChunkCount;
+    },
+    get queuedChunkCount() {
+      return state.queuedChunkCount;
+    },
+    start: async () => {
+      try {
+        clearError();
+        const context = await ensureAudioContext();
+        restoreOutputGain(context);
+        if (context.state === "suspended") {
+          await context.resume();
+        }
+        setState({
+          activeSourceCount: sourceNodes.size,
+          isActive: true,
+          isPlaying: context.state === "running"
+        });
+        await queueSync();
+      } catch (error) {
+        setState({
+          error: error instanceof Error ? error.message : String(error),
+          isActive: false,
+          isPlaying: false
+        });
+        throw error;
+      }
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    }
+  };
+  return player;
+};
+
+// src/client/bargeInMonitor.ts
+var DEFAULT_THRESHOLD_MS = 250;
+var createEventId = () => `barge-in:${Date.now()}:${crypto.randomUUID?.() ?? Math.random().toString(36).slice(2)}`;
+var summarize = (events, thresholdMs) => {
+  const stopped = events.filter((event) => event.status === "stopped");
+  const latencies = stopped.map((event) => event.latencyMs).filter((value) => typeof value === "number");
+  const failed = stopped.filter((event) => typeof event.latencyMs === "number" && event.latencyMs > thresholdMs).length;
+  const passed = stopped.length - failed;
+  return {
+    averageLatencyMs: latencies.length > 0 ? Math.round(latencies.reduce((total, value) => total + value, 0) / latencies.length) : undefined,
+    events: [...events],
+    failed,
+    lastEvent: events.at(-1),
+    passed,
+    status: events.length === 0 ? "empty" : failed > 0 ? "fail" : stopped.length === 0 ? "warn" : "pass",
+    thresholdMs,
+    total: stopped.length
+  };
+};
+var createVoiceBargeInMonitor = (options = {}) => {
+  const listeners = new Set;
+  const thresholdMs = options.thresholdMs ?? DEFAULT_THRESHOLD_MS;
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const events = [];
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const postEvent = (event) => {
+    if (!options.path || typeof fetchImpl !== "function") {
+      return;
+    }
+    fetchImpl(options.path, {
+      body: JSON.stringify(event),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    }).catch(() => {});
+  };
+  const record = (status, input) => {
+    const event = {
+      at: Date.now(),
+      id: createEventId(),
+      latencyMs: input.latencyMs,
+      playbackStopLatencyMs: input.playbackStopLatencyMs,
+      reason: input.reason,
+      sessionId: input.sessionId,
+      status,
+      thresholdMs
+    };
+    events.push(event);
+    postEvent(event);
+    emit();
+    return event;
+  };
+  return {
+    getSnapshot: () => summarize(events, thresholdMs),
+    recordRequested: (input) => record("requested", input),
+    recordSkipped: (input) => record("skipped", input),
+    recordStopped: (input) => record("stopped", input),
+    subscribe: (subscriber) => {
+      listeners.add(subscriber);
+      return () => {
+        listeners.delete(subscriber);
+      };
+    }
+  };
+};
+
+// src/client/duplex.ts
+var DEFAULT_INTERRUPT_THRESHOLD = 0.08;
+var shouldInterruptForLevel = (level, options = {}) => (options.enabled ?? true) && level >= (options.interruptThreshold ?? DEFAULT_INTERRUPT_THRESHOLD);
+var bindVoiceBargeIn = (controller, player, options = {}) => {
+  let lastPartial = controller.partial;
+  const interruptIfPlaying = (reason) => {
+    if (!player.isPlaying || options.enabled === false) {
+      options.monitor?.recordSkipped({
+        reason,
+        sessionId: controller.sessionId
+      });
+      return;
+    }
+    options.monitor?.recordRequested({
+      reason,
+      sessionId: controller.sessionId
+    });
+    player.interrupt().then(() => {
+      options.monitor?.recordStopped({
+        latencyMs: player.lastInterruptLatencyMs,
+        playbackStopLatencyMs: player.lastPlaybackStopLatencyMs,
+        reason,
+        sessionId: controller.sessionId
+      });
+    });
+  };
+  const unsubscribe = controller.subscribe(() => {
+    if (options.interruptOnPartial === false) {
+      lastPartial = controller.partial;
+      return;
+    }
+    if (!lastPartial && controller.partial) {
+      interruptIfPlaying("partial-transcript");
+    }
+    lastPartial = controller.partial;
+  });
+  return {
+    close: () => {
+      unsubscribe();
+    },
+    handleLevel: (level) => {
+      if (shouldInterruptForLevel(level, options)) {
+        interruptIfPlaying("input-level");
+      }
+    },
+    sendAudio: (audio) => {
+      interruptIfPlaying("manual-audio");
+      controller.sendAudio(audio);
+    }
+  };
+};
+
 // src/client/htmxBootstrap.ts
 var VOICE_WAVE_POINTS = 48;
 var VOICE_WAVE_WIDTH = 320;
@@ -1126,7 +1990,7 @@ var DEFAULT_GUIDED_PROMPTS = [
   "Now describe what you are trying to do or test.",
   "Finish with any detail that feels blocked, risky, or unclear."
 ];
-var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var clamp = (value, min, max2) => Math.min(max2, Math.max(min, value));
 var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var readErrorField = (value, key) => {
   const candidate = value[key];
@@ -1160,6 +2024,17 @@ var formatErrorMessage = (error) => {
   }
   return "Unexpected error";
 };
+var formatReconnectState = (reconnect) => {
+  const pieces = [reconnect.status];
+  if (reconnect.attempts > 0 || reconnect.maxAttempts > 0) {
+    pieces.push(`${reconnect.attempts}/${reconnect.maxAttempts} attempts`);
+  }
+  if (reconnect.nextAttemptAt) {
+    const waitMs = Math.max(0, reconnect.nextAttemptAt - Date.now());
+    pieces.push(`retry in ${Math.ceil(waitMs / 100) / 10}s`);
+  }
+  return pieces.join(" · ");
+};
 var createInitialVoiceWaveLevels = (count = VOICE_WAVE_POINTS) => Array.from({ length: count }, () => 0);
 var pushVoiceWaveLevel = (levels, nextLevel, count = VOICE_WAVE_POINTS) => {
   const next = levels.slice(-(count - 1));
@@ -1216,6 +2091,20 @@ var parsePromptList = (value) => {
   } catch {}
   return DEFAULT_GUIDED_PROMPTS;
 };
+var parseOptionalNumber = (value) => {
+  if (!value) {
+    return;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+};
+var resolveElement2 = (root, selector, ctor) => {
+  if (!selector) {
+    return null;
+  }
+  const value = document.querySelector(selector);
+  return value instanceof ctor ? value : null;
+};
 var requireElement = (root, selector, ctor, name) => {
   const value = selector ? document.querySelector(selector) : null;
   if (value instanceof ctor) {
@@ -1266,11 +2155,20 @@ var initVoiceHTMXRoot = (root) => {
   const guidedPrompts = parsePromptList(root.dataset.voiceGuidedPrompts);
   const guidedLabel = root.dataset.voiceGuidedLabel ?? DEFAULT_GUIDED_LABEL;
   const generalLabel = root.dataset.voiceGeneralLabel ?? DEFAULT_GENERAL_LABEL;
+  const reconnectReportPath = root.dataset.voiceReconnectReportPath;
+  const bargeInPath = root.dataset.voiceBargeInPath;
+  const bargeInMonitor = bargeInPath ? createVoiceBargeInMonitor({
+    path: bargeInPath,
+    thresholdMs: parseOptionalNumber(root.dataset.voiceBargeInThresholdMs)
+  }) : null;
+  const bargeInRecentWindowMs = parseOptionalNumber(root.dataset.voiceBargeInRecentWindowMs) ?? 4000;
+  const bargeInSpeechThreshold = parseOptionalNumber(root.dataset.voiceBargeInSpeechThreshold) ?? 0.04;
   const syncElement = requireElement(document, root.dataset.voiceSync, HTMLElement, "voice-htmx-sync");
   const connectionMetric = requireElement(root, root.dataset.voiceConnection, HTMLElement, "metric-connection");
   const errorStatus = requireElement(root, root.dataset.voiceError, HTMLElement, "status-error");
   const microphoneStatus = requireElement(root, root.dataset.voiceMicrophone, HTMLElement, "status-mic");
   const promptStatus = requireElement(root, root.dataset.voicePrompt, HTMLElement, "status-prompt");
+  const reconnectStatus = resolveElement2(root, root.dataset.voiceReconnect, HTMLElement);
   const chatList = requireElement(root, root.dataset.voiceChat, HTMLElement, "chat-list");
   const startGuidedButton = requireElement(root, root.dataset.voiceStartGuided, HTMLButtonElement, "start-guided");
   const startGeneralButton = requireElement(root, root.dataset.voiceStartGeneral, HTMLButtonElement, "start-general");
@@ -1279,35 +2177,70 @@ var initVoiceHTMXRoot = (root) => {
   const voiceMonitorCopy = requireElement(root, root.dataset.voiceMonitorCopy, HTMLElement, "voice-monitor-copy");
   const voiceWaveGlow = requireElement(root, root.dataset.voiceWaveGlow, SVGPathElement, "voice-wave-glow");
   const voiceWavePath = requireElement(root, root.dataset.voiceWavePath, SVGPathElement, "voice-wave-path");
+  let activeMode = null;
+  let hasStartedModes = {
+    general: false,
+    guided: false
+  };
+  let isCapturing = false;
+  let micError = null;
+  let waveLevels = createInitialVoiceWaveLevels();
+  let guidedBargeInBinding = null;
+  let generalBargeInBinding = null;
   const guidedVoice = createVoiceController(guidedPath, {
     capture: {
+      onAudio: (audio, sendAudio) => {
+        if (guidedBargeInBinding) {
+          guidedBargeInBinding.sendAudio(audio);
+          return;
+        }
+        sendAudio(audio);
+      },
       onLevel: (level) => {
+        guidedBargeInBinding?.handleLevel(level);
         waveLevels = pushVoiceWaveLevel(waveLevels, level);
         renderWave();
       }
     },
+    connection: {
+      reconnectReportPath
+    },
     preset: "guided-intake"
   });
   const generalVoice = createVoiceController(generalPath, {
     capture: {
+      onAudio: (audio, sendAudio) => {
+        if (generalBargeInBinding) {
+          generalBargeInBinding.sendAudio(audio);
+          return;
+        }
+        sendAudio(audio);
+      },
       onLevel: (level) => {
+        generalBargeInBinding?.handleLevel(level);
         waveLevels = pushVoiceWaveLevel(waveLevels, level);
         renderWave();
       }
     },
+    connection: {
+      reconnectReportPath
+    },
     preset: "dictation"
   });
   const stopGuidedBinding = guidedVoice.bindHTMX({ element: syncElement });
   const stopGeneralBinding = generalVoice.bindHTMX({ element: syncElement });
-  let activeMode = null;
-  let hasStartedModes = {
-    general: false,
-    guided: false
-  };
-  let isCapturing = false;
-  let micError = null;
-  let waveLevels = createInitialVoiceWaveLevels();
+  const guidedAudioPlayer = createVoiceAudioPlayer(guidedVoice);
+  const generalAudioPlayer = createVoiceAudioPlayer(generalVoice);
+  guidedBargeInBinding = bindVoiceBargeIn(guidedVoice, guidedAudioPlayer, {
+    interruptThreshold: bargeInSpeechThreshold,
+    monitor: bargeInMonitor ?? undefined
+  });
+  generalBargeInBinding = bindVoiceBargeIn(generalVoice, generalAudioPlayer, {
+    interruptThreshold: bargeInSpeechThreshold,
+    monitor: bargeInMonitor ?? undefined
+  });
   const currentVoice = () => activeMode === "general" ? generalVoice : guidedVoice;
+  const currentAudioPlayer = () => activeMode === "general" ? generalAudioPlayer : guidedAudioPlayer;
   const renderWave = () => {
     const path = createVoiceWavePath(waveLevels);
     voiceWaveGlow.setAttribute("d", path);
@@ -1322,6 +2255,9 @@ var initVoiceHTMXRoot = (root) => {
     const status = voice.status;
     connectionMetric.textContent = voice.isConnected ? "Connected" : "Waiting";
     errorStatus.textContent = micError || voice.error || "None";
+    if (reconnectStatus) {
+      reconnectStatus.textContent = formatReconnectState(voice.reconnect);
+    }
     microphoneStatus.textContent = isCapturing ? DEFAULT_MIC_LIVE : DEFAULT_MIC_IDLE;
     promptStatus.textContent = resolvePromptMessage({
       guidedPrompts,
@@ -1385,8 +2321,18 @@ var initVoiceHTMXRoot = (root) => {
       render();
     }
   };
-  guidedVoice.subscribe(render);
-  generalVoice.subscribe(render);
+  guidedVoice.subscribe(() => {
+    if (guidedVoice.assistantAudio.length > 0) {
+      guidedAudioPlayer.start().catch(() => {});
+    }
+    render();
+  });
+  generalVoice.subscribe(() => {
+    if (generalVoice.assistantAudio.length > 0) {
+      generalAudioPlayer.start().catch(() => {});
+    }
+    render();
+  });
   startGuidedButton.addEventListener("click", () => {
     startMode("guided");
   });
@@ -1396,9 +2342,16 @@ var initVoiceHTMXRoot = (root) => {
   stopButton.addEventListener("click", () => {
     stopMic();
   });
+  root.addEventListener("absolute-voice-simulate-disconnect", () => {
+    currentVoice().simulateDisconnect();
+  });
   window.addEventListener("beforeunload", () => {
     guidedVoice.stopRecording();
     generalVoice.stopRecording();
+    guidedBargeInBinding?.close();
+    generalBargeInBinding?.close();
+    guidedAudioPlayer.close();
+    generalAudioPlayer.close();
     stopGuidedBinding();
     stopGeneralBinding();
     guidedVoice.close();