getpatter 0.6.2 → 0.6.4

package/dist/{chunk-CL2U3YET.mjs → chunk-BO227NTF.mjs}

@@ -47,6 +47,45 @@ var OpenAIRealtimeVADType = {
   SERVER_VAD: "server_vad",
   SEMANTIC_VAD: "semantic_vad"
 };
+function validateRealtimeTurnDetection(td) {
+  if (td === void 0) return;
+  if (td.type !== void 0 && td.type !== "server_vad" && td.type !== "semantic_vad") {
+    throw new Error(
+      `RealtimeTurnDetection.type must be 'server_vad' or 'semantic_vad', got ${JSON.stringify(td.type)}`
+    );
+  }
+  if (td.eagerness !== void 0 && td.eagerness !== "low" && td.eagerness !== "medium" && td.eagerness !== "high" && td.eagerness !== "auto") {
+    throw new Error(
+      `RealtimeTurnDetection.eagerness must be one of low|medium|high|auto, got ${JSON.stringify(td.eagerness)}`
+    );
+  }
+  if (td.eagerness !== void 0 && td.type !== "semantic_vad") {
+    throw new Error(
+      "RealtimeTurnDetection.eagerness is only valid when type='semantic_vad'"
+    );
+  }
+}
+function buildTurnDetection(td, opts) {
+  validateRealtimeTurnDetection(td);
+  let detection;
+  if (td?.type === "semantic_vad") {
+    detection = { type: "semantic_vad" };
+    if (td.eagerness !== void 0) detection.eagerness = td.eagerness;
+  } else {
+    detection = {
+      type: td?.type ?? opts.defaultType,
+      threshold: td?.threshold ?? 0.5,
+      prefix_padding_ms: td?.prefixPaddingMs ?? 300,
+      silence_duration_ms: td?.silenceDurationMs ?? opts.defaultSilenceMs
+    };
+  }
+  if (opts.includeResponseGating) {
+    const serverManaged = !(opts.gateResponseOnTranscript ?? false);
+    detection.create_response = serverManaged;
+    detection.interrupt_response = serverManaged;
+  }
+  return detection;
+}
 var OpenAIRealtimeAdapter = class {
   constructor(apiKey, model = OpenAIRealtimeModel.GPT_REALTIME_MINI, voice = OpenAIVoice.ALLOY, instructions = "", tools, audioFormat = OpenAIRealtimeAudioFormat.G711_ULAW, options = {}) {
     this.apiKey = apiKey;
@@ -56,6 +95,7 @@ var OpenAIRealtimeAdapter = class {
     this.tools = tools;
     this.audioFormat = audioFormat;
     this.options = options;
+    this.gateResponseOnTranscript = options.gateResponseOnTranscript ?? false;
   }
   apiKey;
   model;
@@ -85,6 +125,23 @@ var OpenAIRealtimeAdapter = class {
   // could have produced, which is what the user actually heard.
   currentResponseFirstAudioAt = null;
   options;
+  // When true, the stream handler waits for the Whisper ``transcript_input``
+  // event before requesting the model response (legacy behavior). When false
+  // (default) the response is requested on ``speech_stopped`` and the
+  // transcript is display-only. Read by the stream handler via
+  // ``getGateResponseOnTranscript()``.
+  gateResponseOnTranscript;
+  /**
+   * Whether the stream handler should gate the model response on the Whisper
+   * transcript (legacy) or fire it on `speech_stopped` (default, decoupled).
+   *
+   * `false` (default) — the response is requested on `speech_stopped`,
+   * independently of Whisper. `true` — the response is requested only after
+   * `transcript_input` passes the hallucination filter.
+   */
+  getGateResponseOnTranscript() {
+    return this.gateResponseOnTranscript;
+  }
   /**
    * Build the production session.update body. Mirrors the body sent
    * inside `connect()` so warmup can apply identical configuration to
@@ -96,16 +153,26 @@ var OpenAIRealtimeAdapter = class {
       output_audio_format: this.audioFormat,
       voice: this.voice,
       instructions: this.instructions || "You are a helpful voice assistant. Be concise.",
-      turn_detection: {
-        type: this.options.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
-        threshold: 0.5,
-        prefix_padding_ms: 300,
-        silence_duration_ms: this.options.silenceDurationMs ?? 300
-      },
+      // v1 turn_detection carries NO create_response / interrupt_response
+      // keys. The v1 server defaults (`create_response: true`,
+      // `interrupt_response: true`) ARE the server-managed behaviour we want by
+      // default, so omitting them is equivalent to sending `true` — gating
+      // disabled here. `gateResponseOnTranscript` is still threaded through for
+      // symmetry with the GA builder, but has no wire effect while
+      // includeResponseGating is false.
+      turn_detection: buildTurnDetection(this.options.turnDetection, {
+        defaultType: this.options.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
+        defaultSilenceMs: this.options.silenceDurationMs ?? 300,
+        includeResponseGating: false,
+        gateResponseOnTranscript: this.gateResponseOnTranscript
+      }),
       input_audio_transcription: {
         model: this.options.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
       }
     };
+    if (this.options.noiseReduction !== void 0) {
+      config.input_audio_noise_reduction = { type: this.options.noiseReduction };
+    }
     if (this.options.temperature !== void 0) config.temperature = this.options.temperature;
     if (this.options.maxResponseOutputTokens !== void 0) {
       config.max_response_output_tokens = this.options.maxResponseOutputTokens;
@@ -369,6 +436,10 @@ var OpenAIRealtimeAdapter = class {
       };
       const timer = setTimeout(() => {
         cleanup();
+        try {
+          ws.close();
+        } catch {
+        }
         reject(new Error("OpenAI Realtime park connect timeout"));
       }, 8e3);
       ws.on("message", onMessage);
@@ -463,20 +534,33 @@ var OpenAIRealtimeAdapter = class {
       dispatch("error", { type: "socket_error", message: err?.message ?? String(err) });
     });
   }
-  /** Truncate the in-flight assistant turn and cancel the active response.
+  /** Truncate the in-flight assistant turn's playback offset on the server.
+   *
+   * Sends ONLY ``conversation.item.truncate`` — no ``response.cancel``. This
+   * is the half of barge-in handling that a WebSocket transport MUST always
+   * perform: per OpenAI's docs, the GA server auto-truncates on barge-in only
+   * over WebRTC / SIP; on the WebSocket transport the client is responsible
+   * for telling the server how much of the assistant turn was actually heard.
+   * In server-managed mode (``interrupt_response: true``) the server already
+   * cancels the response itself, so issuing ``response.cancel`` here would be
+   * redundant / rejected — call this method, not {@link cancelResponse}.
    *
    * ``audio_end_ms`` MUST reflect what the caller actually heard, not what
    * the server generated. OpenAI streams audio at 5-10x real-time, so the
    * byte-derived counter overstates playback whenever the consumer cleared
-   * its playout buffer (e.g. ``send_clear``) before the audio reached the
+   * its playout buffer (e.g. ``sendClear``) before the audio reached the
    * speaker. We bound the truncate point by wall-clock time since the first
    * chunk of this response — that's the physical maximum a 1x real-time
    * playback could have produced. Without this cap, OpenAI keeps the full
    * generated assistant text on the transcript, and the model replays /
    * resumes from it on the next turn — manifesting as re-greetings and
    * mid-sentence fragments after a barge-in storm.
+   *
+   * No-op when no response is in flight, keeping it idempotent across stale
+   * callers. Resets per-response tracking so post-truncate late frames and
+   * the next response start clean.
    */
-  cancelResponse() {
+  truncate() {
     if (!this.ws) return;
     if (!this.currentResponseItemId) {
       return;
@@ -496,11 +580,31 @@ var OpenAIRealtimeAdapter = class {
     } catch (err) {
       getLogger().debug?.(`conversation.item.truncate failed: ${String(err)}`);
     }
-    this.ws.send(JSON.stringify({ type: "response.cancel" }));
     this.currentResponseItemId = null;
     this.currentResponseAudioMs = 0;
     this.currentResponseFirstAudioAt = null;
   }
+  /** Truncate the in-flight assistant turn AND cancel the active response.
+   *
+   * Sends BOTH ``conversation.item.truncate`` (the played-offset bookkeeping)
+   * AND ``response.cancel``. Use this on the LEGACY client-managed barge-in
+   * path (``gateResponseOnTranscript`` true → ``interrupt_response: false``,
+   * so the server does NOT cancel for us) and for explicit cancels driven by
+   * Patter (e.g. on transfer / hangup). In server-managed mode call
+   * {@link truncate} instead — the server already cancels the response, and an
+   * extra ``response.cancel`` would be redundant / rejected.
+   *
+   * Truncation bounding semantics are identical to {@link truncate}; see its
+   * doc comment for the ``audio_end_ms`` wall-clock cap rationale.
+   */
+  cancelResponse() {
+    if (!this.ws) return;
+    if (!this.currentResponseItemId) {
+      return;
+    }
+    this.truncate();
+    this.ws.send(JSON.stringify({ type: "response.cancel" }));
+  }
   /** Inject a user text turn and request a new response. */
   async sendText(text) {
     this.ws?.send(JSON.stringify({
@@ -545,6 +649,32 @@ var OpenAIRealtimeAdapter = class {
       }
     }));
   }
+  /**
+   * Speak a short reassurance filler WITHOUT injecting a `role:user` turn.
+   *
+   * Same no-fake-turn shape as {@link sendFirstMessage}: a bare
+   * `response.create` carrying explicit `instructions`, so the filler is the
+   * assistant's own in-band audio. The reassurance scheduler in the
+   * stream-handler routes here instead of {@link sendText} — which would emit
+   * a `conversation.item.create` with `role:'user'` and falsely show the
+   * caller saying "One moment." in the transcript. Fillers must not imply
+   * success or failure.
+   *
+   * Uses `modalities: ['audio', 'text']` (v1-beta shape). The GA subclass
+   * {@link OpenAIRealtime2Adapter} overrides this with `output_modalities`
+   * and re-injects `audio.output.voice` so the GA endpoint does not reject
+   * the request. Mirrors Python `OpenAIRealtimeAdapter.send_reassurance` in
+   * `providers/openai_realtime.py`.
+   */
+  async sendReassurance(text) {
+    this.ws?.send(JSON.stringify({
+      type: "response.create",
+      response: {
+        modalities: ["audio", "text"],
+        instructions: `Say exactly this and nothing else: "${text}"`
+      }
+    }));
+  }
   /** Submit a tool/function-call result and request the next response. */
   async sendFunctionResult(callId, result) {
     this.ws?.send(JSON.stringify({
@@ -727,7 +857,12 @@ var StatefulResampler = class {
    * Resets all state after flushing.
    */
   flush() {
-    this.carry.flush();
+    const carryTail = this.carry.flush();
+    if (carryTail.length > 0) {
+      getLogger().warn(
+        "[patter] StatefulResampler.flush: trailing odd byte discarded \u2014 upstream produced odd-length PCM stream"
+      );
+    }
     if (this.srcRate === 16e3 && this.dstRate === 8e3 && this.firPendingSample !== null) {
       const s = this.firPendingSample;
       const tmp = Buffer.alloc(4);
@@ -1012,44 +1147,46 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
   buildGASessionConfig() {
     const opts = this.options;
     const fmt = { type: "audio/pcm", rate: 24e3 };
+    const audioInput = {
+      format: fmt,
+      transcription: {
+        model: opts.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
+      },
+      // Response creation + barge-in cancellation (issue #154 — hand
+      // turn-taking to the server by default):
+      //  - DEFAULT (`gateResponseOnTranscript` false → SERVER-MANAGED):
+      //    `create_response: true` lets the SERVER auto-create the response
+      //    when it commits the user's audio buffer
+      //    (`input_audio_buffer.committed`). `interrupt_response: true` lets the
+      //    SERVER cancel the in-flight response on its own VAD `speech_started`.
+      //    The e2e model replies immediately, in parallel with the Whisper
+      //    transcript — no transcript wait (~500 ms reclaimed), no client-side
+      //    race. On a WebSocket transport the client STILL must clear the
+      //    carrier buffer (`sendClear`) and `conversation.item.truncate` the
+      //    played offset on barge-in (the server only auto-truncates on
+      //    WebRTC/SIP), but it does NOT send `response.cancel`. Whisper is
+      //    display-only — it can never trigger / gate / cancel the response.
+      //  - LEGACY (`gateResponseOnTranscript` true → CLIENT-MANAGED opt-out):
+      //    `create_response: false` + `interrupt_response: false` so the stream
+      //    handler drives `response.create` (after the hallucination filter)
+      //    and `response.cancel` (on barge-in) itself. Escape hatch for no-AEC
+      //    PSTN self-interruption. Both keys are tied to the same switch inside
+      //    `buildTurnDetection`.
+      turn_detection: buildTurnDetection(opts.turnDetection, {
+        defaultType: opts.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
+        defaultSilenceMs: opts.silenceDurationMs ?? 300,
+        includeResponseGating: true,
+        gateResponseOnTranscript: this.getGateResponseOnTranscript()
+      })
+    };
+    if (opts.noiseReduction !== void 0) {
+      audioInput.noise_reduction = { type: opts.noiseReduction };
+    }
     const config = {
       type: "realtime",
       output_modalities: opts.modalities ?? ["audio"],
       audio: {
-        input: {
-          format: fmt,
-          transcription: {
-            model: opts.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
-          },
-          // VAD threshold raised back to the OpenAI default (0.5) on
-          // 2026-05-22. The earlier 0.1 tuning (motivated by the
-          // upsampled telephony-band loss in high frequencies) made the
-          // server VAD trigger on the carrier-loopback echo of the
-          // agent's OWN outbound audio in PSTN no-AEC scenarios.
-          // Combined with the default ``turn_detection.create_response:
-          // true``, every phantom ``speech_started`` ended a turn early
-          // and auto-created a new response that the agent immediately
-          // spoke over, leading to a runaway loop where the first
-          // message was repeatedly cut and re-generated.
-          turn_detection: {
-            type: opts.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
-            threshold: 0.5,
-            prefix_padding_ms: 300,
-            silence_duration_ms: opts.silenceDurationMs ?? 500,
-            // Defer ``response.create`` to the application: when OpenAI's
-            // server VAD commits an ``input_audio_buffer.committed`` segment
-            // that turns out to be a Whisper hallucination on silence/echo,
-            // auto-creating a response would generate a phantom turn (the
-            // model reads the hallucinated text as user input). Patter
-            // triggers ``response.create`` explicitly in the Realtime
-            // stream-handler AFTER validating ``transcript_input`` against
-            // the hallucination filter. Pair with ``interrupt_response:
-            // false`` so server VAD also leaves in-flight responses alone —
-            // barge-in is gated client-side.
-            create_response: false,
-            interrupt_response: false
-          }
-        },
+        input: audioInput,
         output: {
           format: fmt,
           voice: this.voice
@@ -1102,14 +1239,7 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
           if (t && t in GA_TO_V1_EVENT_NAMES) {
             const newType = GA_TO_V1_EVENT_NAMES[t];
             if (t === "response.output_audio.delta" && typeof parsed.delta === "string") {
-              const mulaw = this.transcodeOutboundPcm24ToMulaw8Buffer(parsed.delta);
-              const FRAME_BYTES = 160;
-              if (mulaw.length === 0) return;
-              for (let off = 0; off < mulaw.length; off += FRAME_BYTES) {
-                const slice = mulaw.subarray(off, Math.min(off + FRAME_BYTES, mulaw.length));
-                const frame = { ...parsed, type: newType, delta: slice.toString("base64") };
-                handler(Buffer.from(JSON.stringify(frame)), ...rest);
-              }
+              this.translateGaAudioDelta(parsed, handler, rest);
               return;
             }
             parsed.type = newType;
@@ -1138,6 +1268,7 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
           sessionCreated = true;
           ws.send(JSON.stringify({ type: "session.update", session: this.buildGASessionConfig() }));
         } else if (msg.type === "session.updated") {
+          this.warnIfOutputFormatUnexpected(msg);
           cleanup();
           resolve();
         } else if (msg.type === "error") {
@@ -1243,6 +1374,10 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
       };
       const timer = setTimeout(() => {
         cleanup();
+        try {
+          ws.close();
+        } catch {
+        }
         reject(new Error("OpenAI Realtime 2 park connect timeout"));
       }, 8e3);
       ws.on("message", onMessage);
@@ -1290,8 +1425,12 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
           const parsed = JSON.parse(text);
           const t = parsed.type;
           if (t && Object.prototype.hasOwnProperty.call(GA_TO_V1_EVENT_NAMES, t)) {
+            if (t === "response.output_audio.delta" && typeof parsed.delta === "string") {
+              this.translateGaAudioDelta(parsed, handler, rest);
+              return;
+            }
             parsed.type = GA_TO_V1_EVENT_NAMES[t];
-            handler(JSON.stringify(parsed), ...rest);
+            handler(Buffer.from(JSON.stringify(parsed)), ...rest);
             return;
           }
         } catch {
@@ -1376,6 +1515,55 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
     }
     return out;
   }
+  /**
+   * Log-only safety net for issue #154. The GA server echoes the *effective*
+   * session config in `session.updated`; we request `audio/pcm` @ 24 kHz and
+   * transcode PCM24→mulaw8 ourselves (see
+   * `transcodeOutboundPcm24ToMulaw8Buffer`). If a future GA schema change ever
+   * made the server return a different output format, that transcode — which
+   * assumes PCM16-LE @ 24 kHz — would silently corrupt audio, exactly the
+   * v1-beta failure mode #154 fixed. Warn so the drift surfaces in logs instead
+   * of as static. Never gates audio.
+   */
+  warnIfOutputFormatUnexpected(msg) {
+    const fmt = msg?.session?.audio?.output?.format;
+    if (!fmt || typeof fmt !== "object") return;
+    if (fmt.type !== "audio/pcm" || fmt.rate != null && fmt.rate !== 24e3) {
+      getLogger().warn(
+        `OpenAI Realtime 2: server-echoed output format ${JSON.stringify(fmt)} differs from the requested audio/pcm@24000 \u2014 the outbound PCM24\u2192mulaw8 transcode assumes PCM16-LE 24 kHz, so carrier audio may be garbled (issue #154). Informational only; audio is not gated on this.`
+      );
+    }
+  }
+  /**
+   * Shared audio-delta translation helper. Transcodes a GA
+   * `response.output_audio.delta` payload (base64 PCM-16-LE 24 kHz)
+   * into mulaw 8 kHz and splits the result into 160-byte (20 ms) frames,
+   * dispatching one synthetic `response.audio.delta` event per frame.
+   *
+   * Called from BOTH the `connect()` shim and the `adoptWebSocket()` shim
+   * so that warm-path (prewarm/adopted) calls receive identical transcoding
+   * to cold-path calls. Without this, adopted sockets forwarded raw PCM-24
+   * to Twilio/Telnyx, producing garbled or silent audio on every warm call.
+   *
+   * @param parsed  - The parsed GA event object (type already checked to be
+   *                  `response.output_audio.delta` with a string `delta`).
+   * @param handler - The downstream message listener to dispatch each frame to.
+   * @param rest    - Extra arguments forwarded from the original `message` event.
+   * @returns `true` if frames were dispatched (caller should return early),
+   *          `false` if the resampler is still warming up (zero output bytes).
+   */
+  translateGaAudioDelta(parsed, handler, rest) {
+    const newType = GA_TO_V1_EVENT_NAMES["response.output_audio.delta"];
+    const mulaw = this.transcodeOutboundPcm24ToMulaw8Buffer(parsed.delta);
+    const FRAME_BYTES = 160;
+    if (mulaw.length === 0) return false;
+    for (let off = 0; off < mulaw.length; off += FRAME_BYTES) {
+      const slice = mulaw.subarray(off, Math.min(off + FRAME_BYTES, mulaw.length));
+      const frame = { ...parsed, type: newType, delta: slice.toString("base64") };
+      handler(Buffer.from(JSON.stringify(frame)), ...rest);
+    }
+    return true;
+  }
   /**
    * Base64 PCM-16-LE 24 kHz → Base64 mulaw 8 kHz. Used by the WS
    * translation shim on each `response.output_audio.delta`. The stateful
@@ -1405,6 +1593,34 @@ var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
     }
     this.ws?.send(JSON.stringify({ type: "response.create", response: responseBody }));
   }
+  /**
+   * Speak a short reassurance filler WITHOUT injecting a `role:user` turn.
+   *
+   * GA-shape sibling of {@link sendFirstMessage} (and override of the base v1
+   * {@link OpenAIRealtimeAdapter.sendReassurance}): a bare `response.create`
+   * carrying explicit `instructions` so the filler is the assistant's own
+   * in-band audio. No `conversation.item.create` with `role:"user"` is
+   * emitted, so the transcript shows no phantom caller line. The GA endpoint
+   * rejects `response.modalities` and does not inherit `audio.output.voice`
+   * for an explicit `response.create`, so — exactly as in
+   * {@link sendFirstMessage} — we send `output_modalities` and re-inject the
+   * voice. Fillers must not imply success or failure.
+   *
+   * Mirrors Python `OpenAIRealtime2Adapter.send_reassurance` in
+   * `providers/openai_realtime_2.py`.
+   */
+  async sendReassurance(text) {
+    if (!this.ws) return;
+    const responseBody = {
+      output_modalities: ["audio"],
+      audio: { output: { voice: this.voice } },
+      instructions: `Say exactly this and nothing else: "${text}"`
+    };
+    if (this.options.reasoningEffort !== void 0) {
+      responseBody.reasoning = { effort: this.options.reasoningEffort };
+    }
+    this.ws.send(JSON.stringify({ type: "response.create", response: responseBody }));
+  }
 };
 
 export {
@@ -1413,6 +1629,7 @@ export {
   OpenAIVoice,
   OpenAITranscriptionModel,
   OpenAIRealtimeVADType,
+  validateRealtimeTurnDetection,
   OpenAIRealtimeAdapter,
   mulawToPcm16,
   pcm16ToMulaw,

package/dist/cli.js

@@ -185,14 +185,49 @@ var MetricsStore = class extends import_events.EventEmitter {
     } else {
       for (let i = this.calls.length - 1; i >= 0; i--) {
         if (this.calls[i].call_id === callId) {
-          this.calls[i].status = status;
-          Object.assign(this.calls[i], extra);
+          this.calls[i] = { ...this.calls[i], status, ...extra };
           break;
         }
       }
     }
     this.publish("call_status", { call_id: callId, status, ...extra });
   }
+  /**
+   * Record a single transcript line (user/assistant) as it becomes known.
+   *
+   * FIX-5 (issue #154): the live forward path for the dashboard transcript.
+   * The Realtime stream handler calls this the moment each line is known — the
+   * user line right after the hallucination filter accepts it, the assistant
+   * line when its turn flushes — keyed by the monotonic ``turnIndex`` reserved
+   * at turn-open (``reserveTurnIndex``). Each line is appended to the active
+   * call's ``transcript`` array and broadcast over SSE as a ``transcript_line``
+   * event so the dashboard can render lines as they arrive and re-sort by
+   * ``(turnIndex, user<assistant)`` — making a late-arriving user line land
+   * ABOVE its agent line. ``recordTurn`` de-dups against the lines pushed here
+   * by ``(turnIndex, role)`` so the metrics path never double-pushes the same
+   * text. Parity with Python ``record_transcript_line``.
+   */
+  recordTranscriptLine(data) {
+    const callId = data.call_id || "";
+    const { role, text, turnIndex } = data;
+    if (!callId || role !== "user" && role !== "assistant" || !text) return;
+    const active = this.activeCalls.get(callId);
+    if (active) {
+      if (!active.transcript) active.transcript = [];
+      active.transcript.push({
+        role,
+        text,
+        timestamp: Date.now() / 1e3,
+        turnIndex
+      });
+    }
+    this.publish("transcript_line", {
+      call_id: callId,
+      turnIndex,
+      role,
+      text
+    });
+  }
   /** Append a single conversation turn to an active call and broadcast it via SSE. */
   recordTurn(data) {
     const callId = data.call_id || "";
@@ -207,14 +242,19 @@ var MetricsStore = class extends import_events.EventEmitter {
       const userText = typeof turnRecord.user_text === "string" ? turnRecord.user_text : "";
       const agentText = typeof turnRecord.agent_text === "string" ? turnRecord.agent_text : "";
       const ts = typeof turnRecord.timestamp === "number" ? turnRecord.timestamp : Date.now() / 1e3;
-      if (userText.length > 0) {
-        active.transcript.push({ role: "user", text: userText, timestamp: ts });
+      const turnIndex = typeof turnRecord.turn_index === "number" ? turnRecord.turn_index : void 0;
+      const alreadyLive = (role) => turnIndex !== void 0 && (active.transcript ?? []).some(
+        (e) => e.turnIndex === turnIndex && e.role === role
+      );
+      if (userText.length > 0 && !alreadyLive("user")) {
+        active.transcript.push({ role: "user", text: userText, timestamp: ts, turnIndex });
       }
-      if (agentText.length > 0 && agentText !== "[interrupted]") {
+      if (agentText.length > 0 && agentText !== "[interrupted]" && !alreadyLive("assistant")) {
         active.transcript.push({
           role: "assistant",
           text: agentText,
-          timestamp: ts
+          timestamp: ts,
+          turnIndex
         });
       }
     }
@@ -287,7 +327,7 @@ var MetricsStore = class extends import_events.EventEmitter {
   getCall(callId) {
     if (this.deletedCallIds.has(callId)) return null;
     for (let i = this.calls.length - 1; i >= 0; i--) {
-      if (this.calls[i].call_id === callId) return this.calls[i];
+      if (this.calls[i].call_id === callId) return { ...this.calls[i] };
     }
     return null;
   }
@@ -329,7 +369,9 @@ var MetricsStore = class extends import_events.EventEmitter {
     }
     if (accepted.length === 0) return [];
     accepted.sort();
-    this.persistDeletedIds();
+    this.persistDeletedIds().catch(
+      (err) => getLogger().debug(`MetricsStore.deleteCalls: persistDeletedIds failed: ${String(err)}`)
+    );
     this.publish("calls_deleted", { call_ids: accepted });
     return accepted;
   }
@@ -341,19 +383,19 @@ var MetricsStore = class extends import_events.EventEmitter {
   getDeletedCallIds() {
     return Array.from(this.deletedCallIds).sort();
   }
-  /** Atomically persist the deleted-ids set to disk. Best-effort. */
-  persistDeletedIds() {
+  /** Atomically persist the deleted-ids set to disk. Best-effort async. */
+  async persistDeletedIds() {
     if (this.deletedIdsPath === null) return;
     try {
       const dir = path2.dirname(this.deletedIdsPath);
-      fs2.mkdirSync(dir, { recursive: true });
+      await fs2.promises.mkdir(dir, { recursive: true });
       const tmp = this.deletedIdsPath + ".tmp";
       const payload = {
         version: 1,
         deleted_call_ids: Array.from(this.deletedCallIds).sort()
       };
-      fs2.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
-      fs2.renameSync(tmp, this.deletedIdsPath);
+      await fs2.promises.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+      await fs2.promises.rename(tmp, this.deletedIdsPath);
     } catch (err) {
       getLogger().debug(
         `MetricsStore.persistDeletedIds: ${String(err)}`
@@ -362,7 +404,8 @@ var MetricsStore = class extends import_events.EventEmitter {
   }
   /** Look up an active call by id (returns undefined if not active or unknown). */
   getActive(callId) {
-    return this.activeCalls.get(callId);
+    const rec = this.activeCalls.get(callId);
+    return rec !== void 0 ? { ...rec } : void 0;
   }
   /** Return all currently active (not yet ended) calls. */
   getActiveCalls() {
@@ -607,8 +650,8 @@ function loadTranscriptJsonl(filePath) {
       } catch {
         continue;
       }
-      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) : NaN;
-      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp * 1e3 : NaN;
+      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) / 1e3 : NaN;
+      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp : NaN;
       const timestamp = Number.isFinite(tsIso) ? tsIso : Number.isFinite(tsNumeric) ? tsNumeric : 0;
       const userText = typeof row.user_text === "string" ? row.user_text : "";
       const agentText = typeof row.agent_text === "string" ? row.agent_text : "";
@@ -759,8 +802,8 @@ function mountDashboard(app, store, token = "") {
     res.type("text/html").send(DASHBOARD_HTML);
   });
   app.get("/api/dashboard/calls", auth, (req, res) => {
-    const limit = Math.min(parseInt(req.query.limit || "50", 10) || 50, 1e3);
-    const offset = parseInt(req.query.offset || "0", 10) || 0;
+    const limit = Math.min(Math.max(0, parseInt(req.query.limit || "50", 10) || 50), 1e3);
+    const offset = Math.max(0, parseInt(req.query.offset || "0", 10) || 0);
     res.json(store.getCalls(limit, offset));
   });
   app.get("/api/dashboard/calls/:callId", auth, (req, res) => {
@@ -850,8 +893,8 @@ data: ${data}
 function mountApi(app, store, token = "") {
   const auth = makeAuthMiddleware(token);
   app.get("/api/v1/calls", auth, (req, res) => {
-    const limit = Math.min(parseInt(req.query.limit || "50", 10) || 50, 1e3);
-    const offset = parseInt(req.query.offset || "0", 10) || 0;
+    const limit = Math.min(Math.max(0, parseInt(req.query.limit || "50", 10) || 50), 1e3);
+    const offset = Math.max(0, parseInt(req.query.offset || "0", 10) || 0);
     const calls = store.getCalls(limit, offset);
     res.json({
       data: calls,