@alexkroman1/aai 1.0.6 → 1.1.0

package/host/session-ctx.test.ts

@@ -0,0 +1,387 @@
+// Copyright 2025 the AAI authors. MIT license.
+
+import { describe, expect, it, vi } from "vitest";
+import { DEFAULT_MAX_HISTORY } from "../sdk/constants.ts";
+import type { Message } from "../sdk/types.ts";
+import { toolError } from "../sdk/utils.ts";
+import { flush, makeClient, makeConfig, silentLogger } from "./_test-utils.ts";
+import { buildCtx } from "./session-ctx.ts";
+
+function makeBuildCtxOpts(overrides?: Record<string, unknown>) {
+  return {
+    id: "session-1",
+    agent: "test-agent",
+    client: makeClient(),
+    agentConfig: makeConfig({ maxSteps: 3 }),
+    executeTool: vi.fn(async () => "ok"),
+    log: silentLogger,
+    ...overrides,
+  };
+}
+
+describe("buildCtx", () => {
+  it("returns ctx with the correct session id", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ id: "my-session" }));
+    expect(ctx.id).toBe("my-session");
+  });
+
+  it("returns ctx with the correct agent name", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ agent: "my-agent" }));
+    expect(ctx.agent).toBe("my-agent");
+  });
+
+  it("initializes with empty conversation messages", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    expect(ctx.conversationMessages).toEqual([]);
+  });
+
+  it("initializes with null s2s handle", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    expect(ctx.s2s).toBeNull();
+  });
+
+  it("initializes with null turnPromise", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    expect(ctx.turnPromise).toBeNull();
+  });
+
+  it("initializes reply state with empty pendingTools, zero toolCallCount, and null replyId", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    expect(ctx.reply).toEqual({
+      pendingTools: [],
+      toolCallCount: 0,
+      currentReplyId: null,
+    });
+  });
+
+  it("defaults maxHistory to DEFAULT_MAX_HISTORY when not provided", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    expect(ctx.maxHistory).toBe(DEFAULT_MAX_HISTORY);
+  });
+
+  it("uses custom maxHistory when provided", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ maxHistory: 50 }));
+    expect(ctx.maxHistory).toBe(50);
+  });
+
+  it("passes through the agentConfig, executeTool, and log dependencies", () => {
+    const config = makeConfig({ maxSteps: 7 });
+    const executeTool = vi.fn(async () => "done");
+    const ctx = buildCtx(makeBuildCtxOpts({ agentConfig: config, executeTool }));
+    expect(ctx.agentConfig).toBe(config);
+    expect(ctx.executeTool).toBe(executeTool);
+    expect(ctx.log).toBe(silentLogger);
+  });
+});
+
+describe("consumeToolCallStep", () => {
+  it("returns null (success) when tool call is within maxSteps", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.beginReply("reply-1");
+    const result = ctx.consumeToolCallStep("my-tool", "reply-1");
+    expect(result).toBeNull();
+  });
+
+  it("increments toolCallCount on each call", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.beginReply("reply-1");
+
+    ctx.consumeToolCallStep("tool-a", "reply-1");
+    expect(ctx.reply.toolCallCount).toBe(1);
+
+    ctx.consumeToolCallStep("tool-b", "reply-1");
+    expect(ctx.reply.toolCallCount).toBe(2);
+  });
+
+  it("allows exactly maxSteps tool calls", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ agentConfig: makeConfig({ maxSteps: 2 }) }));
+    ctx.beginReply("reply-1");
+
+    expect(ctx.consumeToolCallStep("tool-1", "reply-1")).toBeNull();
+    expect(ctx.consumeToolCallStep("tool-2", "reply-1")).toBeNull();
+  });
+
+  it("rejects when tool call count exceeds maxSteps", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ agentConfig: makeConfig({ maxSteps: 2 }) }));
+    ctx.beginReply("reply-1");
+
+    ctx.consumeToolCallStep("tool-1", "reply-1");
+    ctx.consumeToolCallStep("tool-2", "reply-1");
+    const result = ctx.consumeToolCallStep("tool-3", "reply-1");
+    expect(result).toBe(toolError("Maximum tool steps reached. Please respond to the user now."));
+  });
+
+  it("logs when maxSteps is exceeded", () => {
+    const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const ctx = buildCtx(makeBuildCtxOpts({ agentConfig: makeConfig({ maxSteps: 1 }), log }));
+    ctx.beginReply("reply-1");
+
+    ctx.consumeToolCallStep("tool-1", "reply-1"); // ok
+    ctx.consumeToolCallStep("tool-2", "reply-1"); // exceeds
+
+    expect(log.info).toHaveBeenCalledWith("maxSteps exceeded, refusing tool call", {
+      toolCallCount: 2,
+      maxSteps: 1,
+    });
+  });
+
+  it("rejects with stale replyId (mismatched)", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.beginReply("reply-1");
+
+    const result = ctx.consumeToolCallStep("my-tool", "stale-reply");
+    expect(result).toBe(toolError("Reply was interrupted. Discarding stale tool call."));
+  });
+
+  it("rejects when replyId is null", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.beginReply("reply-1");
+
+    const result = ctx.consumeToolCallStep("my-tool", null);
+    expect(result).toBe(toolError("Reply was interrupted. Discarding stale tool call."));
+  });
+
+  it("rejects when no reply has been started (currentReplyId is null)", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    // No beginReply — currentReplyId stays null
+    const result = ctx.consumeToolCallStep("my-tool", "some-reply");
+    expect(result).toBe(toolError("Reply was interrupted. Discarding stale tool call."));
+  });
+
+  it("allows unlimited tool calls when maxSteps is undefined", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ agentConfig: makeConfig() }));
+    ctx.beginReply("reply-1");
+
+    // makeConfig() without maxSteps leaves it undefined
+    for (let i = 0; i < 100; i++) {
+      expect(ctx.consumeToolCallStep(`tool-${i}`, "reply-1")).toBeNull();
+    }
+  });
+});
+
+describe("pushMessages", () => {
+  it("appends messages to conversationMessages", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    const msg1: Message = { role: "user", content: "hello" };
+    const msg2: Message = { role: "assistant", content: "hi" };
+
+    ctx.pushMessages(msg1);
+    expect(ctx.conversationMessages).toEqual([msg1]);
+
+    ctx.pushMessages(msg2);
+    expect(ctx.conversationMessages).toEqual([msg1, msg2]);
+  });
+
+  it("accepts multiple messages at once", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    const msg1: Message = { role: "user", content: "a" };
+    const msg2: Message = { role: "assistant", content: "b" };
+    const msg3: Message = { role: "tool", content: "c" };
+
+    ctx.pushMessages(msg1, msg2, msg3);
+    expect(ctx.conversationMessages).toEqual([msg1, msg2, msg3]);
+  });
+
+  it("trims to maxHistory keeping the most recent messages", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ maxHistory: 3 }));
+
+    ctx.pushMessages(
+      { role: "user", content: "1" },
+      { role: "assistant", content: "2" },
+      { role: "user", content: "3" },
+    );
+    expect(ctx.conversationMessages).toHaveLength(3);
+
+    ctx.pushMessages({ role: "assistant", content: "4" });
+    expect(ctx.conversationMessages).toHaveLength(3);
+    expect(ctx.conversationMessages.map((m) => m.content)).toEqual(["2", "3", "4"]);
+  });
+
+  it("trims correctly when pushing multiple messages that exceed maxHistory", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ maxHistory: 2 }));
+
+    ctx.pushMessages(
+      { role: "user", content: "a" },
+      { role: "assistant", content: "b" },
+      { role: "user", content: "c" },
+      { role: "assistant", content: "d" },
+    );
+
+    expect(ctx.conversationMessages).toHaveLength(2);
+    expect(ctx.conversationMessages.map((m) => m.content)).toEqual(["c", "d"]);
+  });
+
+  it("does not trim when maxHistory is 0 (disabled)", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ maxHistory: 0 }));
+
+    for (let i = 0; i < 300; i++) {
+      ctx.pushMessages({ role: "user", content: `msg-${i}` });
+    }
+    expect(ctx.conversationMessages).toHaveLength(300);
+  });
+});
+
+describe("cancelReply", () => {
+  it("resets pendingTools and toolCallCount", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.beginReply("reply-1");
+    ctx.consumeToolCallStep("tool-1", "reply-1");
+    ctx.reply.pendingTools.push({ callId: "c1", result: "r1" });
+
+    expect(ctx.reply.toolCallCount).toBe(1);
+    expect(ctx.reply.pendingTools).toHaveLength(1);
+
+    ctx.cancelReply();
+
+    expect(ctx.reply.toolCallCount).toBe(0);
+    expect(ctx.reply.pendingTools).toEqual([]);
+    expect(ctx.reply.currentReplyId).toBeNull();
+  });
+
+  it("allows a new reply to start fresh after cancel", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ agentConfig: makeConfig({ maxSteps: 1 }) }));
+    ctx.beginReply("reply-1");
+    ctx.consumeToolCallStep("tool-1", "reply-1"); // uses the single step
+
+    ctx.cancelReply();
+    ctx.beginReply("reply-2");
+
+    // Should succeed because toolCallCount was reset
+    const result = ctx.consumeToolCallStep("tool-1", "reply-2");
+    expect(result).toBeNull();
+  });
+});
+
+describe("beginReply", () => {
+  it("resets reply state with the given replyId", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.beginReply("reply-1");
+
+    expect(ctx.reply.currentReplyId).toBe("reply-1");
+    expect(ctx.reply.pendingTools).toEqual([]);
+    expect(ctx.reply.toolCallCount).toBe(0);
+  });
+
+  it("clears turnPromise", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.chainTurn(Promise.resolve());
+    expect(ctx.turnPromise).not.toBeNull();
+
+    ctx.beginReply("reply-1");
+    expect(ctx.turnPromise).toBeNull();
+  });
+
+  it("resets toolCallCount from a previous reply", () => {
+    const ctx = buildCtx(makeBuildCtxOpts({ agentConfig: makeConfig({ maxSteps: 2 }) }));
+    ctx.beginReply("reply-1");
+    ctx.consumeToolCallStep("tool-a", "reply-1");
+    ctx.consumeToolCallStep("tool-b", "reply-1");
+    expect(ctx.reply.toolCallCount).toBe(2);
+
+    ctx.beginReply("reply-2");
+    expect(ctx.reply.toolCallCount).toBe(0);
+
+    // Can now use maxSteps again
+    expect(ctx.consumeToolCallStep("tool-a", "reply-2")).toBeNull();
+    expect(ctx.consumeToolCallStep("tool-b", "reply-2")).toBeNull();
+  });
+
+  it("invalidates tool calls from the previous reply", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    ctx.beginReply("reply-1");
+    ctx.beginReply("reply-2");
+
+    // Tool call using old replyId should be rejected
+    const result = ctx.consumeToolCallStep("my-tool", "reply-1");
+    expect(result).toBe(toolError("Reply was interrupted. Discarding stale tool call."));
+  });
+});
+
+describe("chainTurn", () => {
+  it("sets turnPromise on first call", () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    expect(ctx.turnPromise).toBeNull();
+
+    ctx.chainTurn(Promise.resolve());
+    expect(ctx.turnPromise).not.toBeNull();
+  });
+
+  it("chains promises sequentially", async () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    const order: number[] = [];
+
+    ctx.chainTurn(
+      new Promise<void>((resolve) => {
+        queueMicrotask(() => {
+          order.push(1);
+          resolve();
+        });
+      }),
+    );
+
+    ctx.chainTurn(
+      new Promise<void>((resolve) => {
+        queueMicrotask(() => {
+          order.push(2);
+          resolve();
+        });
+      }),
+    );
+
+    await ctx.turnPromise;
+    await flush();
+    expect(order).toEqual([1, 2]);
+  });
+
+  it("continues the chain even if a prior turn rejects", async () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    const order: string[] = [];
+
+    ctx.chainTurn(
+      new Promise<void>((_, reject) => {
+        queueMicrotask(() => {
+          order.push("fail");
+          reject(new Error("boom"));
+        });
+      }),
+    );
+
+    ctx.chainTurn(
+      new Promise<void>((resolve) => {
+        queueMicrotask(() => {
+          order.push("success");
+          resolve();
+        });
+      }),
+    );
+
+    // The chain uses .then() which means rejection propagates.
+    // We need to catch the final promise to avoid unhandled rejection.
+    try {
+      await ctx.turnPromise;
+    } catch {
+      // expected
+    }
+    await flush();
+
+    expect(order).toContain("fail");
+  });
+
+  it("allows awaiting turnPromise to wait for all chained turns", async () => {
+    const ctx = buildCtx(makeBuildCtxOpts());
+    let completed = false;
+
+    ctx.chainTurn(
+      new Promise<void>((resolve) => {
+        setTimeout(() => {
+          completed = true;
+          resolve();
+        }, 10);
+      }),
+    );
+
+    expect(completed).toBe(false);
+    await ctx.turnPromise;
+    expect(completed).toBe(true);
+  });
+});

package/host/session-fixture-replay.test.ts

@@ -83,16 +83,8 @@ describe("fixture replay through session", () => {
     );
 
     // Client received tool_call and tool_call_done events
-    const toolStart = client.events.find((e) => (e as { type: string }).type === "tool_call") as
-      | { toolName: string; args: Record<string, unknown> }
-      | undefined;
-    expect(toolStart).toBeDefined();
-    expect(toolStart?.toolName).toBe("get_weather");
-
-    const toolDone = client.events.find((e) => (e as { type: string }).type === "tool_call_done") as
-      | { result: string }
-      | undefined;
-    expect(toolDone).toBeDefined();
+    expect(client.events).toContainEvent("tool_call", { toolName: "get_weather" });
+    expect(client.events).toContainEvent("tool_call_done");
 
     // Tool result was sent back to S2S after replyDone
     await vi.waitFor(() => expect(mockHandle.sendToolResult).toHaveBeenCalled());

package/host/session.test.ts

@@ -83,14 +83,14 @@ describe("createS2sSession", () => {
     const { session, client } = setup();
     await session.start();
     session.onCancel();
-    expect(client.events).toContainEqual(expect.objectContaining({ type: "cancelled" }));
+    expect(client.events).toContainEvent("cancelled");
   });
 
   test("onReset clears state and emits reset event", async () => {
     const { session, client, mockHandle } = setup();
     await session.start();
     session.onReset();
-    expect(client.events).toContainEqual(expect.objectContaining({ type: "reset" }));
+    expect(client.events).toContainEvent("reset");
     expect(mockHandle.close).toHaveBeenCalled();
   });
 
@@ -119,10 +119,7 @@ describe("createS2sSession", () => {
     mockHandle._fire("event", { type: "user_transcript", text: "Hello there" });
     await flush();
 
-    expect(client.events).toContainEqual({
-      type: "user_transcript",
-      text: "Hello there",
-    });
+    expect(client.events).toContainEvent("user_transcript", { text: "Hello there" });
   });
 
   test("audio event forwards audio to client", async () => {
@@ -145,10 +142,7 @@ describe("createS2sSession", () => {
       _interrupted: false,
     });
 
-    expect(client.events).toContainEqual({
-      type: "agent_transcript",
-      text: "Full response",
-    });
+    expect(client.events).toContainEvent("agent_transcript", { text: "Full response" });
   });
 
   test("speech_started and speech_stopped events are forwarded", async () => {
@@ -158,8 +152,8 @@ describe("createS2sSession", () => {
     mockHandle._fire("event", { type: "speech_started" });
     mockHandle._fire("event", { type: "speech_stopped" });
 
-    expect(client.events).toContainEqual({ type: "speech_started" });
-    expect(client.events).toContainEqual({ type: "speech_stopped" });
+    expect(client.events).toContainEvent("speech_started");
+    expect(client.events).toContainEvent("speech_stopped");
   });
 
   test("reply_started resets tool call count", async () => {
@@ -177,7 +171,7 @@ describe("createS2sSession", () => {
     mockHandle._fire("event", { type: "reply_done" });
 
     expect(client.audioDoneCount).toBe(1);
-    expect(client.events).toContainEqual({ type: "reply_done" });
+    expect(client.events).toContainEvent("reply_done");
   });
 
   test("cancelled event emits cancelled", async () => {
@@ -186,7 +180,7 @@ describe("createS2sSession", () => {
 
     mockHandle._fire("event", { type: "cancelled" });
 
-    expect(client.events).toContainEqual({ type: "cancelled" });
+    expect(client.events).toContainEvent("cancelled");
   });
 
   test("error event emits error to client and closes handle", async () => {
@@ -195,11 +189,7 @@ describe("createS2sSession", () => {
 
     mockHandle._fire("error", new Error("Something broke"));
 
-    expect(client.events).toContainEqual({
-      type: "error",
-      code: "internal",
-      message: "Something broke",
-    });
+    expect(client.events).toContainEvent("error", { code: "internal", message: "Something broke" });
     expect(mockHandle.close).toHaveBeenCalled();
   });
 
@@ -227,14 +217,12 @@ describe("createS2sSession", () => {
       "session-1",
       expect.any(Array),
     );
-    expect(client.events).toContainEqual({
-      type: "tool_call",
+    expect(client.events).toContainEvent("tool_call", {
       toolCallId: "call-1",
       toolName: "my_tool",
       args: { key: "value" },
     });
-    expect(client.events).toContainEqual({
-      type: "tool_call_done",
+    expect(client.events).toContainEvent("tool_call_done", {
       toolCallId: "call-1",
       result: "tool-output",
     });
@@ -318,13 +306,7 @@ describe("createS2sSession", () => {
 
     await session.start();
 
-    expect(client.events).toContainEqual(
-      expect.objectContaining({
-        type: "error",
-        code: "internal",
-        message: "connect failed",
-      }),
-    );
+    expect(client.events).toContainEvent("error", { code: "internal", message: "connect failed" });
 
     spy.mockRestore();
   });
@@ -503,10 +485,6 @@ describe("createS2sSession", () => {
 
   // ─── Idle timeout tests ──────────────────────────────────────────────
 
-  function hasIdleTimeout(events: unknown[]): boolean {
-    return events.some((e) => (e as Record<string, unknown>).type === "idle_timeout");
-  }
-
   test("idle timeout fires after configured period of inactivity", async () => {
     vi.useFakeTimers();
     const { session, client, mockHandle } = setup({
@@ -519,7 +497,7 @@ describe("createS2sSession", () => {
     });
     await session.start();
     vi.advanceTimersByTime(10_000);
-    expect(hasIdleTimeout(client.events)).toBe(true);
+    expect(client.events).toContainEvent("idle_timeout");
     expect(mockHandle.close).toHaveBeenCalled();
     vi.useRealTimers();
   });
@@ -538,9 +516,9 @@ describe("createS2sSession", () => {
     vi.advanceTimersByTime(8000);
     session.onAudio(new Uint8Array([1, 2, 3]));
     vi.advanceTimersByTime(8000);
-    expect(hasIdleTimeout(client.events)).toBe(false);
+    expect(client.events).not.toContainEvent("idle_timeout");
     vi.advanceTimersByTime(2000);
-    expect(hasIdleTimeout(client.events)).toBe(true);
+    expect(client.events).toContainEvent("idle_timeout");
     vi.useRealTimers();
   });
 
@@ -556,7 +534,7 @@ describe("createS2sSession", () => {
     });
     await session.start();
     vi.advanceTimersByTime(600_000);
-    expect(hasIdleTimeout(client.events)).toBe(false);
+    expect(client.events).not.toContainEvent("idle_timeout");
     vi.useRealTimers();
   });
 
@@ -573,7 +551,7 @@ describe("createS2sSession", () => {
     await session.start();
     await session.stop();
     vi.advanceTimersByTime(20_000);
-    expect(hasIdleTimeout(client.events)).toBe(false);
+    expect(client.events).not.toContainEvent("idle_timeout");
     vi.useRealTimers();
   });
 
@@ -582,9 +560,9 @@ describe("createS2sSession", () => {
     const { session, client } = setup();
     await session.start();
     vi.advanceTimersByTime(240_000);
-    expect(hasIdleTimeout(client.events)).toBe(false);
+    expect(client.events).not.toContainEvent("idle_timeout");
     vi.advanceTimersByTime(60_000);
-    expect(hasIdleTimeout(client.events)).toBe(true);
+    expect(client.events).toContainEvent("idle_timeout");
     vi.useRealTimers();
   });
 });

package/host/tool-executor.test.ts

@@ -121,4 +121,40 @@ describe("executeToolCall", () => {
     expect(result).toBe(JSON.stringify({ error: 'Tool "slow" timed out after 30000ms' }));
     vi.useRealTimers();
   });
+
+  test("ctx.send calls the send callback", async () => {
+    const sends: Array<{ event: string; data: unknown }> = [];
+    const tool: ToolDef = {
+      description: "sends an event",
+      parameters: z.object({}),
+      execute: (_args, ctx) => {
+        ctx.send("game_state", { hp: 10 });
+        return "ok";
+      },
+    };
+    const result = await executeToolCall(
+      "sender",
+      {},
+      {
+        tool,
+        env: {},
+        send: (event, data) => sends.push({ event, data }),
+      },
+    );
+    expect(result).toBe("ok");
+    expect(sends).toEqual([{ event: "game_state", data: { hp: 10 } }]);
+  });
+
+  test("ctx.send is a no-op when no send callback provided", async () => {
+    const tool: ToolDef = {
+      description: "sends an event",
+      parameters: z.object({}),
+      execute: (_args, ctx) => {
+        ctx.send("test", {});
+        return "ok";
+      },
+    };
+    const result = await executeToolCall("sender", {}, { tool, env: {} });
+    expect(result).toBe("ok");
+  });
 });

package/host/tool-executor.ts

@@ -27,6 +27,7 @@ export type ExecuteToolCallOptions = {
   kv?: Kv | undefined;
   messages?: readonly Message[] | undefined;
   logger?: Logger | undefined;
+  send?: ((event: string, data: unknown) => void) | undefined;
 };
 
 function buildToolContext(opts: ExecuteToolCallOptions): ToolContext {
@@ -40,6 +41,9 @@ function buildToolContext(opts: ExecuteToolCallOptions): ToolContext {
     },
     messages: messages ?? [],
     sessionId: sessionId ?? "",
+    send(event: string, data: unknown): void {
+      opts.send?.(event, data);
+    },
   };
 }
 

package/host/ws-handler.ts

@@ -47,6 +47,8 @@ export type WsSessionOptions = {
   onClose?: () => void;
   /** Callback invoked with the session ID after session cleanup. */
   onSessionEnd?: (sessionId: string) => void;
+  /** Callback invoked with the session ID and client sink after session setup. */
+  onSinkCreated?: (sessionId: string, sink: ClientSink) => void;
   /** Logger instance. Defaults to console. */
   logger?: Logger;
   /** Timeout in ms for session.start(). Defaults to 10 000 (10s). */
@@ -184,6 +186,7 @@ export function wireSessionSocket(ws: SessionWebSocket, opts: WsSessionOptions):
     const client = createClientSink(ws, log);
     session = opts.createSession(sessionId, client);
     sessions.set(sessionId, session);
+    opts.onSinkCreated?.(sessionId, client);
 
     // Send config immediately — zero RTT. Include sessionId so the client
     // can reconnect with ?sessionId=<id> to resume a persisted session.

package/package.json

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