@alexkroman1/aai 1.4.5 → 1.5.0

package/host/session-ctx.ts

@@ -1,134 +0,0 @@
-// Copyright 2025 the AAI authors. MIT license.
-/** Session context builder — extracted from session.ts. */
-
-import type { AgentConfig, ExecuteTool } from "../sdk/_internal-types.ts";
-import { DEFAULT_MAX_HISTORY } from "../sdk/constants.ts";
-import type { ClientSink } from "../sdk/protocol.ts";
-import type { Message } from "../sdk/types.ts";
-import { toolError } from "../sdk/utils.ts";
-import type { Logger } from "./runtime-config.ts";
-import type { S2sHandle } from "./s2s.ts";
-
-type PendingTool = { callId: string; result: string };
-
-/** Per-reply mutable state — reset on beginReply/cancelReply. */
-export type ReplyState = {
-  pendingTools: PendingTool[];
-  toolCallCount: number;
-  currentReplyId: string | null;
-};
-
-/** Immutable dependencies injected at session creation. */
-export type SessionDeps = {
-  readonly id: string;
-  readonly agent: string;
-  readonly client: ClientSink;
-  readonly agentConfig: AgentConfig;
-  readonly executeTool: ExecuteTool;
-  readonly log: Logger;
-  readonly maxHistory: number;
-};
-
-/**
- * Transport-agnostic session context shared by S2S and pipeline sessions.
- *
- * Owns reply lifecycle, conversation history (with sliding-window truncation),
- * and per-turn tool-call step enforcement. Transport-specific fields (e.g.
- * `s2s` for S2S, `stt`/`tts` for the pipeline) live on the extending types.
- *
- * Split into three layers:
- * - {@link SessionDeps} — immutable dependencies (set once)
- * - {@link ReplyState} via `reply` — per-reply mutable state (reset on beginReply/cancelReply)
- * - Remaining fields — conversation and lifecycle methods
- */
-export type BaseSessionCtx = SessionDeps & {
-  reply: ReplyState;
-  turnPromise: Promise<void> | null;
-  conversationMessages: Message[];
-
-  consumeToolCallStep(name: string, replyId: string | null): string | null;
-  pushMessages(...msgs: Message[]): void;
-  beginReply(replyId: string): void;
-  cancelReply(): void;
-  chainTurn(p: Promise<void>): void;
-};
-
-/**
- * S2S session context — {@link BaseSessionCtx} plus the S2S WebSocket handle.
- */
-export type S2sSessionCtx = BaseSessionCtx & {
-  s2s: S2sHandle | null;
-};
-
-export function _buildBaseCtx(opts: {
-  id: string;
-  agent: string;
-  client: ClientSink;
-  agentConfig: AgentConfig;
-  executeTool: ExecuteTool;
-  log: Logger;
-  maxHistory?: number | undefined;
-}): BaseSessionCtx {
-  const { agentConfig, log } = opts;
-  const maxHistory = opts.maxHistory ?? DEFAULT_MAX_HISTORY;
-  const ctx: BaseSessionCtx = {
-    ...opts,
-    reply: { pendingTools: [], toolCallCount: 0, currentReplyId: null },
-    turnPromise: null,
-    conversationMessages: [],
-    maxHistory,
-    consumeToolCallStep(_name, replyId) {
-      // Guard 1: reject tool calls from interrupted/stale replies
-      if (replyId === null || replyId !== ctx.reply.currentReplyId) {
-        return toolError("Reply was interrupted. Discarding stale tool call.");
-      }
-      // Guard 2: enforce maxSteps (default 5, set in manifest.ts) to prevent
-      // runaway tool-call loops within a single LLM reply
-      const maxSteps = agentConfig.maxSteps;
-      ctx.reply.toolCallCount++;
-      if (maxSteps !== undefined && ctx.reply.toolCallCount > maxSteps) {
-        log.info("maxSteps exceeded, refusing tool call", {
-          toolCallCount: ctx.reply.toolCallCount,
-          maxSteps,
-        });
-        return toolError("Maximum tool steps reached. Please respond to the user now.");
-      }
-      return null;
-    },
-    pushMessages(...msgs: Message[]) {
-      ctx.conversationMessages.push(...msgs);
-      if (maxHistory > 0 && ctx.conversationMessages.length > maxHistory) {
-        ctx.conversationMessages.splice(0, ctx.conversationMessages.length - maxHistory);
-      }
-    },
-    beginReply(replyId: string) {
-      ctx.reply = { pendingTools: [], toolCallCount: 0, currentReplyId: replyId };
-      ctx.turnPromise = null;
-    },
-    cancelReply() {
-      ctx.reply = { pendingTools: [], toolCallCount: 0, currentReplyId: null };
-    },
-    chainTurn(p: Promise<void>) {
-      ctx.turnPromise = (ctx.turnPromise ?? Promise.resolve()).then(() => p);
-    },
-  };
-  return ctx;
-}
-
-export function buildCtx(opts: {
-  id: string;
-  agent: string;
-  client: ClientSink;
-  agentConfig: AgentConfig;
-  executeTool: ExecuteTool;
-  log: Logger;
-  maxHistory?: number | undefined;
-}): S2sSessionCtx {
-  // Mutate the base ctx in place rather than spreading into a new object —
-  // the helper methods close over the base ctx reference, so spreading would
-  // leave them writing to an orphan object (e.g. `beginReply` would mutate
-  // the base `reply`, not the spread copy's `reply`).
-  const base = _buildBaseCtx(opts) as S2sSessionCtx;
-  base.s2s = null;
-  return base;
-}

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

@@ -1,128 +0,0 @@
-import { afterEach, describe, expect, test, vi } from "vitest";
-import {
-  flush,
-  loadFixture,
-  makeClient,
-  makeMockHandle,
-  makeSessionOpts,
-  replayFixtureMessages,
-} from "./_test-utils.ts";
-import { _internals, createS2sSession, type S2sSessionOptions } from "./session.ts";
-
-// ─── Session-level fixture replay tests ─────────────────────────────────────
-//
-// These replay real AssemblyAI S2S messages (recorded with Kokoro TTS audio)
-// through the full session orchestration layer — the same setupListeners /
-// handleToolCall / handleReplyDone code path that production uses.
-
-describe("fixture replay through session", () => {
-  let connectSpy: ReturnType<typeof vi.spyOn>;
-
-  function setupReplay(overrides?: Partial<S2sSessionOptions>) {
-    const mockHandle = makeMockHandle();
-    connectSpy = vi.spyOn(_internals, "connectS2s").mockResolvedValue(mockHandle);
-    const client = makeClient();
-    const opts = makeSessionOpts({ client, ...overrides });
-    const session = createS2sSession(opts);
-    return { session, client, mockHandle, opts };
-  }
-
-  afterEach(() => {
-    connectSpy?.mockRestore();
-  });
-
-  test("greeting session: client receives speech events and chat messages", async () => {
-    const { session, client, mockHandle } = setupReplay();
-    await session.start();
-
-    const messages = loadFixture("greeting-session-sequence.json");
-    replayFixtureMessages(mockHandle, messages);
-
-    // Client should have received speech_started/stopped for the greeting
-    const types = client.events.map((e) => (e as { type: string }).type);
-    expect(types).toContain("agent_transcript"); // final agent transcript
-    expect(types).toContain("reply_done"); // reply completed
-  });
-
-  test("simple question: user transcript builds conversation history", async () => {
-    const { session, client, mockHandle } = setupReplay();
-    await session.start();
-
-    const messages = loadFixture("simple-question-sequence.json");
-    replayFixtureMessages(mockHandle, messages);
-    await flush();
-
-    // Client should see both greeting and answer as agent_transcript events
-    const chatEvents = client.events.filter(
-      (e) => (e as { type: string }).type === "agent_transcript",
-    );
-    expect(chatEvents.length).toBe(2); // greeting + answer
-  });
-
-  test("tool call: session executes tool, buffers result, sends after replyDone", async () => {
-    const executeTool = vi.fn(async () =>
-      JSON.stringify({ city: "San Francisco", temperature: "72°F", condition: "sunny" }),
-    );
-
-    const { session, client, mockHandle } = setupReplay({ executeTool });
-    await session.start();
-
-    const messages = loadFixture("tool-call-sequence.json");
-    replayFixtureMessages(mockHandle, messages);
-
-    // Wait for tool execution to complete
-    await vi.waitFor(() => expect(executeTool).toHaveBeenCalled());
-    await session.waitForTurn();
-
-    // Tool was called with the right name and args
-    expect(executeTool).toHaveBeenCalledWith(
-      "get_weather",
-      expect.objectContaining({ city: "San Francisco" }),
-      expect.any(String), // session ID
-      expect.any(Array), // messages
-    );
-
-    // Client received tool_call and tool_call_done events
-    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());
-  });
-
-  test("tool call: conversation messages accumulate correctly", async () => {
-    const executeTool = vi.fn(async () => JSON.stringify({ result: "ok" }));
-    const { session, mockHandle } = setupReplay({ executeTool });
-    await session.start();
-
-    const messages = loadFixture("tool-call-sequence.json");
-    replayFixtureMessages(mockHandle, messages);
-    await vi.waitFor(() => expect(executeTool).toHaveBeenCalled());
-    await session.waitForTurn();
-
-    // The conversation messages passed to executeTool should include
-    // the user's transcript (from STT recognition of Kokoro audio)
-    const call = executeTool.mock.calls[0] as unknown as [
-      string,
-      unknown,
-      string,
-      { role: string; content: string }[],
-    ];
-    const userMsg = call[3]?.find((m) => m.role === "user");
-    expect(userMsg?.content.toLowerCase()).toContain("weather");
-  });
-
-  test("user speech recognition events reach the client", async () => {
-    const { session, client, mockHandle } = setupReplay();
-    await session.start();
-
-    const messages = loadFixture("user-speech-recognition.json");
-    replayFixtureMessages(mockHandle, messages);
-    await flush();
-
-    const types = client.events.map((e) => (e as { type: string }).type);
-    expect(types).toContain("speech_started");
-    expect(types).toContain("speech_stopped");
-    expect(types).toContain("user_transcript"); // triggers orchestration
-  });
-});