@alexkroman1/aai 1.4.3 → 1.4.5

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @alexkroman1/aai@1.4.3 build /home/runner/work/agent/agent/packages/aai
+> @alexkroman1/aai@1.4.5 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.94 kB │ gzip: 22.51 kB
+ℹ dist/host/runtime-barrel.js       77.48 kB │ gzip: 23.08 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.76 kB
-✔ Build complete in 45ms
+ℹ 14 files, total: 102.30 kB
+✔ Build complete in 49ms

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @alexkroman1/aai
 
+## 1.4.5
+
+### Patch Changes
+
+- 07dc8fb: Log raw reply.done arrivals from the S2S service (sid, status) and warn when the S2S socket closes while a reply is still active, so silent drops are visible server-side.
+- 2ca5d1f: Instrument slow reply_done dispatches with warn-level logs (session id, duration, hadTurnPromise) to help diagnose event-loop starvation under load.
+
+## 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

package/dist/host/runtime-barrel.js

@@ -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, dispatchCtx) {
 	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", {
@@ -1363,6 +1369,10 @@ function dispatchS2sMessage(emitter, msg) {
 			});
 			break;
 		case "reply.done":
+			dispatchCtx.log.info("S2S << reply.done", {
+				...dispatchCtx.sid !== void 0 ? { sid: dispatchCtx.sid } : {},
+				status: msg.status ?? "completed"
+			});
 			if (msg.status === "interrupted") emitter.emit("event", { type: "cancelled" });
 			else emitter.emit("event", { type: "reply_done" });
 			break;
@@ -1377,11 +1387,16 @@ function dispatchS2sMessage(emitter, msg) {
 	}
 }
 function connectS2s(opts) {
-	const { apiKey, config, createWebSocket, logger: log = consoleLogger } = opts;
+	const { apiKey, config, createWebSocket, logger: log = consoleLogger, sid } = opts;
 	return new Promise((resolve, reject) => {
 		log.info("S2S connecting", { url: config.wssUrl });
 		const ws = createWebSocket(config.wssUrl, { headers: { Authorization: `Bearer ${apiKey}` } });
 		const emitter = createNanoEvents();
+		const dispatchState = { speechActive: false };
+		const dispatchCtx = sid !== void 0 ? {
+			log,
+			sid
+		} : { log };
 		let opened = false;
 		function send(msg) {
 			if (ws.readyState !== 1) {
@@ -1461,6 +1476,7 @@ function connectS2s(opts) {
 		}
 		function logIncoming(obj) {
 			if (obj.type === "reply.audio" || obj.type === "input.audio") return;
+			if (obj.type === "reply.done") return;
 			log.info(`S2S << ${obj.type}`);
 		}
 		function handleS2sMessage(ev) {
@@ -1478,7 +1494,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, dispatchCtx);
 		}
 		ws.addEventListener("message", handleS2sMessage);
 		ws.addEventListener("close", (ev) => {
@@ -1614,8 +1630,22 @@ function handleReplyCancelled(ctx) {
 	ctx.cancelReply();
 	ctx.client.event({ type: "cancelled" });
 }
+/**
+* Warn when the entry-to-emit time for a reply_done dispatch exceeds this.
+* Tool-less sessions should be sub-millisecond; sessions with pending tools
+* will legitimately spend time awaiting ctx.turnPromise. We log both (with
+* `hadTurnPromise`) so event-loop starvation is distinguishable from
+* genuine tool-call latency.
+*/
+const REPLY_DONE_SLOW_THRESHOLD_MS = 50;
 function handleReplyDone(ctx) {
+	const startMs = Date.now();
 	const doneReplyId = ctx.reply.currentReplyId;
+	if (doneReplyId === null) {
+		ctx.log.debug("Dropping duplicate reply.done (no active reply)");
+		return;
+	}
+	const hadTurnPromise = ctx.turnPromise !== null;
 	const sendPending = () => {
 		if (ctx.reply.currentReplyId !== doneReplyId) {
 			ctx.reply.pendingTools = [];
@@ -1632,9 +1662,17 @@ function handleReplyDone(ctx) {
 			});
 			ctx.client.playAudioDone();
 			ctx.client.event({ type: "reply_done" });
+			ctx.reply.currentReplyId = null;
+			const durationMs = Date.now() - startMs;
+			if (durationMs >= REPLY_DONE_SLOW_THRESHOLD_MS) ctx.log.warn("slow reply_done dispatch", {
+				sid: ctx.id,
+				agent: ctx.agent,
+				durationMs,
+				hadTurnPromise
+			});
 		}
 	};
-	if (ctx.turnPromise !== null) ctx.turnPromise.then(sendPending);
+	if (hadTurnPromise) ctx.turnPromise?.then(sendPending);
 	else sendPending();
 }
 function setupListeners(ctx, handle) {
@@ -1657,7 +1695,15 @@ function setupListeners(ctx, handle) {
 		handle.close();
 	});
 	handle.on("close", (code, reason) => {
-		ctx.log.info("S2S closed", {
+		const activeReplyId = ctx.reply.currentReplyId;
+		if (activeReplyId !== null) ctx.log.warn("S2S closed with active reply", {
+			sid: ctx.id,
+			agent: ctx.agent,
+			activeReplyId,
+			code,
+			reason
+		});
+		else ctx.log.info("S2S closed", {
 			code,
 			reason
 		});
@@ -1737,7 +1783,8 @@ function createS2sSession(opts) {
 				apiKey,
 				config: s2sConfig,
 				createWebSocket,
-				logger: log
+				logger: log,
+				sid: id
 			});
 			if (sessionAbort.signal.aborted || generation !== connectGeneration) {
 				handle.close();

package/dist/host/s2s.d.ts

@@ -77,5 +77,11 @@ export type ConnectS2sOptions = {
     config: S2SConfig;
     createWebSocket: CreateS2sWebSocket;
     logger?: Logger;
+    /**
+     * Session id attached to diagnostic log lines (e.g. raw `reply.done`
+     * arrivals from the S2S service). Optional; logs omit the field when
+     * not provided.
+     */
+    sid?: string;
 };
 export declare function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle>;

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 () => {
@@ -387,6 +402,26 @@ describe("connectS2s", () => {
     expect(handler.mock.calls[0]?.[0]).toEqual({ type: "cancelled" });
   });
 
+  test("reply.done arrival is logged with sid and status", async () => {
+    const { raw, createWebSocket, logger } = createTestS2s();
+    const infoSpy = vi.fn();
+    logger.info = infoSpy;
+    const handle = await connectS2s({
+      apiKey: "test-key",
+      config: s2sConfig,
+      createWebSocket,
+      logger,
+      sid: "sess-abc",
+    });
+    handle.on("event", vi.fn());
+
+    raw.emit("message", Buffer.from(JSON.stringify({ type: "reply.done", status: "completed" })));
+
+    const arrivalCall = infoSpy.mock.calls.find((c) => c[0] === "S2S << reply.done");
+    expect(arrivalCall).toBeDefined();
+    expect(arrivalCall?.[1]).toEqual({ sid: "sess-abc", status: "completed" });
+  });
+
   test("session.error with session_not_found dispatches 'sessionExpired'", async () => {
     const { raw, handle } = await setupHandle();
     const handler = vi.fn();

package/host/s2s.ts

@@ -79,7 +79,26 @@ 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 };
+
+type DispatchContext = {
+  /** Logger used for diagnostic `S2S <<` arrival logs. */
+  log: Logger;
+  /** Session id threaded through diagnostic logs; omitted when undefined. */
+  sid?: string;
+};
+
+function dispatchS2sMessage(
+  emitter: Emitter<S2sEvents>,
+  msg: S2sServerMessage,
+  state: DispatchState,
+  dispatchCtx: DispatchContext,
+): void {
   switch (msg.type) {
     case "session.ready":
       emitter.emit("ready", { sessionId: msg.session_id });
@@ -87,10 +106,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 });
@@ -114,6 +139,13 @@ function dispatchS2sMessage(emitter: Emitter<S2sEvents>, msg: S2sServerMessage):
       });
       break;
     case "reply.done":
+      // Log every raw reply.done arrival from the S2S service — one line per
+      // event, before any client-facing dedup — so we can cross-check which
+      // stalled sessions actually received reply.done for their turn.
+      dispatchCtx.log.info("S2S << reply.done", {
+        ...(dispatchCtx.sid !== undefined ? { sid: dispatchCtx.sid } : {}),
+        status: msg.status ?? "completed",
+      });
       if (msg.status === "interrupted") {
         emitter.emit("event", { type: "cancelled" });
       } else {
@@ -175,10 +207,16 @@ export type ConnectS2sOptions = {
   config: S2SConfig;
   createWebSocket: CreateS2sWebSocket;
   logger?: Logger;
+  /**
+   * Session id attached to diagnostic log lines (e.g. raw `reply.done`
+   * arrivals from the S2S service). Optional; logs omit the field when
+   * not provided.
+   */
+  sid?: string;
 };
 
 export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
-  const { apiKey, config, createWebSocket, logger: log = consoleLogger } = opts;
+  const { apiKey, config, createWebSocket, logger: log = consoleLogger, sid } = opts;
 
   return new Promise((resolve, reject) => {
     log.info("S2S connecting", { url: config.wssUrl });
@@ -188,6 +226,8 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
     });
 
     const emitter = createNanoEvents<S2sEvents>();
+    const dispatchState: DispatchState = { speechActive: false };
+    const dispatchCtx: DispatchContext = sid !== undefined ? { log, sid } : { log };
     let opened = false;
 
     function send(msg: { type: string; [key: string]: unknown }): void {
@@ -269,6 +309,9 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
     function logIncoming(obj: { type?: unknown }): void {
       // reply.audio and input.audio are ~95% of traffic — skip logging.
       if (obj.type === "reply.audio" || obj.type === "input.audio") return;
+      // reply.done gets a richer log (sid + status) inside dispatchS2sMessage;
+      // skip the generic line here to avoid a duplicate.
+      if (obj.type === "reply.done") return;
       log.info(`S2S << ${obj.type}`);
     }
 
@@ -291,7 +334,7 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
         );
         return;
       }
-      dispatchS2sMessage(emitter, parsed);
+      dispatchS2sMessage(emitter, parsed, dispatchState, dispatchCtx);
     }
 
     ws.addEventListener("message", handleS2sMessage);

package/host/session.test.ts

@@ -168,12 +168,78 @@ 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("S2S close with active reply logs a warn", async () => {
+    const warn = vi.fn();
+    const info = vi.fn();
+    const logger = { debug: vi.fn(), info, warn, error: vi.fn() };
+    const { session, mockHandle } = setup({ logger });
+    await session.start();
+
+    // reply started but not yet done → currentReplyId is non-null
+    mockHandle._fire("replyStarted", { replyId: "r-active" });
+    mockHandle._fire("close", 1006, "abnormal");
+
+    expect(warn).toHaveBeenCalledWith(
+      "S2S closed with active reply",
+      expect.objectContaining({ activeReplyId: "r-active", code: 1006, reason: "abnormal" }),
+    );
+  });
+
+  test("S2S clean close (no active reply) logs at info, not warn", async () => {
+    const warn = vi.fn();
+    const info = vi.fn();
+    const logger = { debug: vi.fn(), info, warn, error: vi.fn() };
+    const { session, mockHandle } = setup({ logger });
+    await session.start();
+
+    mockHandle._fire("replyStarted", { replyId: "r1" });
+    mockHandle._fire("event", { type: "reply_done" });
+    mockHandle._fire("close", 1000, "ok");
+
+    expect(warn).not.toHaveBeenCalledWith("S2S closed with active reply", expect.any(Object));
+    expect(info).toHaveBeenCalledWith("S2S closed", expect.objectContaining({ code: 1000 }));
+  });
+
+  test("fast reply_done dispatch does not warn", async () => {
+    const warn = vi.fn();
+    const logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn,
+      error: vi.fn(),
+    };
+    const { session, mockHandle } = setup({ logger });
+    await session.start();
+
+    mockHandle._fire("replyStarted", { replyId: "r1" });
+    mockHandle._fire("event", { type: "reply_done" });
+
+    expect(warn).not.toHaveBeenCalledWith("slow reply_done dispatch", expect.any(Object));
+  });
+
   test("cancelled event emits cancelled", async () => {
     const { session, client, mockHandle } = setup();
     await session.start();

package/host/session.ts

@@ -179,8 +179,25 @@ function handleReplyCancelled(ctx: S2sSessionCtx): void {
   ctx.client.event({ type: "cancelled" });
 }
 
+/**
+ * Warn when the entry-to-emit time for a reply_done dispatch exceeds this.
+ * Tool-less sessions should be sub-millisecond; sessions with pending tools
+ * will legitimately spend time awaiting ctx.turnPromise. We log both (with
+ * `hadTurnPromise`) so event-loop starvation is distinguishable from
+ * genuine tool-call latency.
+ */
+const REPLY_DONE_SLOW_THRESHOLD_MS = 50;
+
 function handleReplyDone(ctx: S2sSessionCtx): void {
+  const startMs = Date.now();
   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 hadTurnPromise = ctx.turnPromise !== null;
   const sendPending = () => {
     if (ctx.reply.currentReplyId !== doneReplyId) {
       ctx.reply.pendingTools = [];
@@ -196,10 +213,21 @@ 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;
+      const durationMs = Date.now() - startMs;
+      if (durationMs >= REPLY_DONE_SLOW_THRESHOLD_MS) {
+        ctx.log.warn("slow reply_done dispatch", {
+          sid: ctx.id,
+          agent: ctx.agent,
+          durationMs,
+          hadTurnPromise,
+        });
+      }
     }
   };
-  if (ctx.turnPromise !== null) {
-    void ctx.turnPromise.then(sendPending);
+  if (hadTurnPromise) {
+    void ctx.turnPromise?.then(sendPending);
   } else {
     sendPending();
   }
@@ -221,7 +249,20 @@ function setupListeners(ctx: S2sSessionCtx, handle: S2sHandle): void {
     handle.close();
   });
   handle.on("close", (code, reason) => {
-    ctx.log.info("S2S closed", { code, reason });
+    const activeReplyId = ctx.reply.currentReplyId;
+    if (activeReplyId !== null) {
+      // Silent drop — S2S socket closed while the server was still owed a
+      // reply. Client stays in waitingForReply=true until a session timeout.
+      ctx.log.warn("S2S closed with active reply", {
+        sid: ctx.id,
+        agent: ctx.agent,
+        activeReplyId,
+        code,
+        reason,
+      });
+    } else {
+      ctx.log.info("S2S closed", { code, reason });
+    }
     ctx.s2s = null;
     ctx.cancelReply();
   });
@@ -311,6 +352,7 @@ export function createS2sSession(opts: S2sSessionOptions): Session {
         config: s2sConfig,
         createWebSocket,
         logger: log,
+        sid: id,
       });
       if (sessionAbort.signal.aborted || generation !== connectGeneration) {
         handle.close();

package/package.json

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