@alexkroman1/aai 1.4.4 → 1.4.5

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @alexkroman1/aai@1.4.4 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       76.29 kB │ gzip: 22.68 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: 101.11 kB
-✔ Build complete in 41ms
+ℹ 14 files, total: 102.30 kB
+✔ Build complete in 49ms

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @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

package/dist/host/runtime-barrel.js

@@ -1326,7 +1326,7 @@ function parseS2sMessage(obj) {
 	const result = S2sMessageSchema.safeParse(obj);
 	return result.success ? result.data : void 0;
 }
-function dispatchS2sMessage(emitter, msg, state) {
+function dispatchS2sMessage(emitter, msg, state, dispatchCtx) {
 	switch (msg.type) {
 		case "session.ready":
 			emitter.emit("ready", { sessionId: msg.session_id });
@@ -1369,6 +1369,10 @@ function dispatchS2sMessage(emitter, msg, state) {
 			});
 			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;
@@ -1383,12 +1387,16 @@ function dispatchS2sMessage(emitter, msg, state) {
 	}
 }
 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) {
@@ -1468,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) {
@@ -1485,7 +1494,7 @@ function connectS2s(opts) {
 				log.warn(`S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`);
 				return;
 			}
-			dispatchS2sMessage(emitter, parsed, dispatchState);
+			dispatchS2sMessage(emitter, parsed, dispatchState, dispatchCtx);
 		}
 		ws.addEventListener("message", handleS2sMessage);
 		ws.addEventListener("close", (ev) => {
@@ -1621,12 +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 = [];
@@ -1644,9 +1663,16 @@ 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) {
@@ -1669,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
 		});
@@ -1749,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

@@ -402,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

@@ -86,10 +86,18 @@ export type S2sEvent = ClientEvent & { _interrupted?: boolean };
  */
 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":
@@ -131,6 +139,13 @@ function dispatchS2sMessage(
       });
       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 {
@@ -192,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 });
@@ -206,6 +227,7 @@ 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 {
@@ -287,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}`);
     }
 
@@ -309,7 +334,7 @@ export function connectS2s(opts: ConnectS2sOptions): Promise<S2sHandle> {
         );
         return;
       }
-      dispatchS2sMessage(emitter, parsed, dispatchState);
+      dispatchS2sMessage(emitter, parsed, dispatchState, dispatchCtx);
     }
 
     ws.addEventListener("message", handleS2sMessage);

package/host/session.test.ts

@@ -191,6 +191,55 @@ describe("createS2sSession", () => {
     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,7 +179,17 @@ 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.
@@ -187,6 +197,7 @@ function handleReplyDone(ctx: S2sSessionCtx): void {
     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 = [];
@@ -204,10 +215,19 @@ function handleReplyDone(ctx: S2sSessionCtx): void {
       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();
   }
@@ -229,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();
   });
@@ -319,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.4",
+  "version": "1.4.5",
   "type": "module",
   "exports": {
     ".": {