@alexkroman1/aai 1.4.2 → 1.4.4

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @alexkroman1/aai@1.4.2 build /home/runner/work/agent/agent/packages/aai
+> @alexkroman1/aai@1.4.4 build /home/runner/work/agent/agent/packages/aai
 > tsdown && tsc -p tsconfig.build.json
 
 ℹ tsdown v0.21.7 powered by rolldown v1.0.0-rc.12
@@ -8,7 +8,7 @@
 ℹ target: node22
 ℹ tsconfig: tsconfig.json
 ℹ Build start
-ℹ dist/host/runtime-barrel.js       75.92 kB │ gzip: 22.48 kB
+ℹ dist/host/runtime-barrel.js       76.29 kB │ gzip: 22.68 kB
 ℹ dist/sdk/protocol.js               4.75 kB │ gzip:  1.76 kB
 ℹ dist/index.js                      2.88 kB │ gzip:  1.24 kB
 ℹ dist/sdk/manifest-barrel.js        0.36 kB │ gzip:  0.20 kB
@@ -22,5 +22,5 @@
 ℹ dist/assemblyai-Cxg9eobY.js        0.53 kB │ gzip:  0.35 kB
 ℹ dist/anthropic-BrUCPKUc.js         0.23 kB │ gzip:  0.18 kB
 ℹ dist/cartesia-DwDk2tEu.js          0.22 kB │ gzip:  0.17 kB
-ℹ 14 files, total: 100.74 kB
-✔ Build complete in 48ms
+ℹ 14 files, total: 101.11 kB
+✔ Build complete in 41ms

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @alexkroman1/aai
 
+## 1.4.4
+
+### Patch Changes
+
+- 74341a4: fix(aai): dedup duplicate S2S reply.done and speech.stopped events to prevent client-side cascades in the voice session wire protocol
+
+## 1.4.3
+
+### Patch Changes
+
+- 62d5a99: Fix pipeline mode: play greeting, emit a single agent_transcript per turn, open TTS at the client's playback sample rate, stop the Cartesia adapter from eagerly rotating its context (which was silently dropping in-flight audio chunks), and skip the wire `context.cancel()` when the context is already final on Cartesia's side (avoids a benign 400 that was killing the session).
+
 ## 1.4.2
 
 ### Patch Changes

package/dist/host/runtime-barrel.js

@@ -1200,7 +1200,7 @@ function openCartesia(opts) {
 				},
 				cancel() {
 					if (closed) return;
-					context.cancel().catch(ignoreRejection);
+					if (!doneEmitted) context.cancel().catch(ignoreRejection);
 					emitDoneOnce();
 					rotatePending = true;
 				},
@@ -1326,17 +1326,23 @@ function parseS2sMessage(obj) {
 	const result = S2sMessageSchema.safeParse(obj);
 	return result.success ? result.data : void 0;
 }
-function dispatchS2sMessage(emitter, msg) {
+function dispatchS2sMessage(emitter, msg, state) {
 	switch (msg.type) {
 		case "session.ready":
 			emitter.emit("ready", { sessionId: msg.session_id });
 			break;
 		case "session.updated": break;
 		case "input.speech.started":
-			emitter.emit("event", { type: "speech_started" });
+			if (!state.speechActive) {
+				state.speechActive = true;
+				emitter.emit("event", { type: "speech_started" });
+			}
 			break;
 		case "input.speech.stopped":
-			emitter.emit("event", { type: "speech_stopped" });
+			if (state.speechActive) {
+				state.speechActive = false;
+				emitter.emit("event", { type: "speech_stopped" });
+			}
 			break;
 		case "transcript.user":
 			emitter.emit("event", {
@@ -1382,6 +1388,7 @@ function connectS2s(opts) {
 		log.info("S2S connecting", { url: config.wssUrl });
 		const ws = createWebSocket(config.wssUrl, { headers: { Authorization: `Bearer ${apiKey}` } });
 		const emitter = createNanoEvents();
+		const dispatchState = { speechActive: false };
 		let opened = false;
 		function send(msg) {
 			if (ws.readyState !== 1) {
@@ -1478,7 +1485,7 @@ function connectS2s(opts) {
 				log.warn(`S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`);
 				return;
 			}
-			dispatchS2sMessage(emitter, parsed);
+			dispatchS2sMessage(emitter, parsed, dispatchState);
 		}
 		ws.addEventListener("message", handleS2sMessage);
 		ws.addEventListener("close", (ev) => {
@@ -1616,6 +1623,10 @@ function handleReplyCancelled(ctx) {
 }
 function handleReplyDone(ctx) {
 	const doneReplyId = ctx.reply.currentReplyId;
+	if (doneReplyId === null) {
+		ctx.log.debug("Dropping duplicate reply.done (no active reply)");
+		return;
+	}
 	const sendPending = () => {
 		if (ctx.reply.currentReplyId !== doneReplyId) {
 			ctx.reply.pendingTools = [];
@@ -1632,6 +1643,7 @@ function handleReplyDone(ctx) {
 			});
 			ctx.client.playAudioDone();
 			ctx.client.event({ type: "reply_done" });
+			ctx.reply.currentReplyId = null;
 		}
 	};
 	if (ctx.turnPromise !== null) ctx.turnPromise.then(sendPending);

package/host/providers/tts/cartesia.test.ts

@@ -217,4 +217,45 @@ describe("cartesia TTS adapter", () => {
     controller.abort();
     await session.close();
   });
+
+  test("cancel() after done is a no-op on the wire (avoids Cartesia's 'context ID does not exist' 400)", async () => {
+    const { session, controller } = await openSession();
+    const turn1 = session._currentContextId();
+
+    session.sendText("hello");
+    session.flush();
+    await flush();
+
+    // Cartesia finishes synthesizing and emits `done` for the flushed context.
+    const ws = session._ws as unknown as { _fire(event: string, payload: unknown): void };
+    ws._fire("done", { context_id: turn1 });
+
+    // A late cancel (e.g. client `cancel` event after the turn completed
+    // normally) must not re-send `context.cancel()` — doing so would trip
+    // Cartesia's 400 and kill the session via onTtsError → terminate.
+    session.cancel();
+    await flush();
+
+    const cancels = sends.filter((s) => s.kind === "cancel");
+    expect(cancels).toEqual([]);
+
+    controller.abort();
+    await session.close();
+  });
+
+  test("double cancel() only sends one wire cancel", async () => {
+    const { session, controller } = await openSession();
+    const turn1 = session._currentContextId();
+
+    session.sendText("hello");
+    session.cancel();
+    session.cancel();
+    await flush();
+
+    const cancels = sends.filter((s) => s.kind === "cancel");
+    expect(cancels).toEqual([{ kind: "cancel", contextId: turn1 }]);
+
+    controller.abort();
+    await session.close();
+  });
 });

package/host/providers/tts/cartesia.ts

@@ -213,7 +213,15 @@ export function openCartesia(opts: CartesiaOptions): TtsOpener {
         },
         cancel() {
           if (closed) return;
-          void context.cancel().catch(ignoreRejection);
+          // Skip the wire cancel if the context is already final on
+          // Cartesia's side (natural `done` after flush, or a prior
+          // cancel). Cartesia responds to cancel on a retired context
+          // with a 400 "context ID does not exist", which our error
+          // listener surfaces as `tts_stream_error` and the pipeline
+          // treats as fatal — killing the session for a benign race.
+          if (!doneEmitted) {
+            void context.cancel().catch(ignoreRejection);
+          }
           // Emit synchronously: barge-in advances the orchestrator's
           // state machine on `done`, and delaying it would audibly
           // stall subsequent turns. Cartesia stops producing audio

package/host/s2s.test.ts

@@ -219,10 +219,25 @@ describe("connectS2s", () => {
     const handler = vi.fn();
     handle.on("event", handler);
 
+    // Prime VAD state — speech_stopped is only forwarded after a speech_started.
+    raw.emit("message", Buffer.from(JSON.stringify({ type: "input.speech.started" })));
     raw.emit("message", Buffer.from(JSON.stringify({ type: "input.speech.stopped" })));
 
-    expect(handler).toHaveBeenCalledOnce();
-    expect(handler.mock.calls[0]?.[0]).toEqual({ type: "speech_stopped" });
+    expect(handler).toHaveBeenCalledTimes(2);
+    expect(handler.mock.calls[0]?.[0]).toEqual({ type: "speech_started" });
+    expect(handler.mock.calls[1]?.[0]).toEqual({ type: "speech_stopped" });
+  });
+
+  test("duplicate input.speech.stopped is suppressed", async () => {
+    const { raw, handle } = await setupHandle();
+    const handler = vi.fn();
+    handle.on("event", handler);
+
+    raw.emit("message", Buffer.from(JSON.stringify({ type: "input.speech.started" })));
+    raw.emit("message", Buffer.from(JSON.stringify({ type: "input.speech.stopped" })));
+    raw.emit("message", Buffer.from(JSON.stringify({ type: "input.speech.stopped" })));
+
+    expect(handler.mock.calls.filter((c) => c[0].type === "speech_stopped")).toHaveLength(1);
   });
 
   test("transcript.user dispatches 'event' with user_transcript", async () => {

package/host/s2s.ts

@@ -79,7 +79,18 @@ function parseS2sMessage(obj: Record<string, unknown>): S2sServerMessage | undef
  */
 export type S2sEvent = ClientEvent & { _interrupted?: boolean };
 
-function dispatchS2sMessage(emitter: Emitter<S2sEvents>, msg: S2sServerMessage): void {
+/**
+ * Per-connection dispatch state. Used to dedup events that the upstream S2S
+ * service may emit more than once for a single logical turn (e.g. repeated
+ * `input.speech.stopped` after the VAD flips).
+ */
+type DispatchState = { speechActive: boolean };
+
+function dispatchS2sMessage(
+  emitter: Emitter<S2sEvents>,
+  msg: S2sServerMessage,
+  state: DispatchState,
+): void {
   switch (msg.type) {
     case "session.ready":
       emitter.emit("ready", { sessionId: msg.session_id });
@@ -87,10 +98,16 @@ function dispatchS2sMessage(emitter: Emitter<S2sEvents>, msg: S2sServerMessage):
     case "session.updated":
       break;
     case "input.speech.started":
-      emitter.emit("event", { type: "speech_started" });
+      if (!state.speechActive) {
+        state.speechActive = true;
+        emitter.emit("event", { type: "speech_started" });
+      }
       break;
     case "input.speech.stopped":
-      emitter.emit("event", { type: "speech_stopped" });
+      if (state.speechActive) {
+        state.speechActive = false;
+        emitter.emit("event", { type: "speech_stopped" });
+      }
       break;
     case "transcript.user":
       emitter.emit("event", { type: "user_transcript", text: msg.text });
@@ -188,6 +205,7 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
     });
 
     const emitter = createNanoEvents<S2sEvents>();
+    const dispatchState: DispatchState = { speechActive: false };
     let opened = false;
 
     function send(msg: { type: string; [key: string]: unknown }): void {
@@ -291,7 +309,7 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
         );
         return;
       }
-      dispatchS2sMessage(emitter, parsed);
+      dispatchS2sMessage(emitter, parsed, dispatchState);
     }
 
     ws.addEventListener("message", handleS2sMessage);

package/host/session.test.ts

@@ -168,12 +168,29 @@ describe("createS2sSession", () => {
     const { session, client, mockHandle } = setup();
     await session.start();
 
+    mockHandle._fire("replyStarted", { replyId: "r1" });
     mockHandle._fire("event", { type: "reply_done" });
 
     expect(client.audioDoneCount).toBe(1);
     expect(client.events).toContainEvent("reply_done");
   });
 
+  test("duplicate reply_done is suppressed after reply completes", async () => {
+    const { session, client, mockHandle } = setup();
+    await session.start();
+
+    mockHandle._fire("replyStarted", { replyId: "r1" });
+    mockHandle._fire("event", { type: "reply_done" });
+    mockHandle._fire("event", { type: "reply_done" });
+
+    const replyDones = client.events.filter(
+      (e): e is { type: string } =>
+        typeof e === "object" && e !== null && "type" in e && e.type === "reply_done",
+    );
+    expect(replyDones).toHaveLength(1);
+    expect(client.audioDoneCount).toBe(1);
+  });
+
   test("cancelled event emits cancelled", async () => {
     const { session, client, mockHandle } = setup();
     await session.start();

package/host/session.ts

@@ -181,6 +181,12 @@ function handleReplyCancelled(ctx: S2sSessionCtx): void {
 
 function handleReplyDone(ctx: S2sSessionCtx): void {
   const doneReplyId = ctx.reply.currentReplyId;
+  // Dedup duplicate reply.done events from the S2S service: once the reply
+  // has been fully dispatched (or was never started), currentReplyId is null.
+  if (doneReplyId === null) {
+    ctx.log.debug("Dropping duplicate reply.done (no active reply)");
+    return;
+  }
   const sendPending = () => {
     if (ctx.reply.currentReplyId !== doneReplyId) {
       ctx.reply.pendingTools = [];
@@ -196,6 +202,8 @@ function handleReplyDone(ctx: S2sSessionCtx): void {
       }
       ctx.client.playAudioDone();
       ctx.client.event({ type: "reply_done" });
+      // Mark reply as finished so any repeated reply.done is dropped above.
+      ctx.reply.currentReplyId = null;
     }
   };
   if (ctx.turnPromise !== null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "type": "module",
   "exports": {
     ".": {