@alexkroman1/aai 1.7.1 → 1.8.0

package/sdk/define.test.ts

@@ -59,21 +59,22 @@ describe("agent()", () => {
     expect(def.builtinTools).toEqual(["web_search"]);
   });
 
-  test("preserves stt/llm/tts providers on the returned def", () => {
+  function pipelineAgent() {
     const stt = assemblyAI({ model: "u3pro-rt" });
     const tts = cartesia({ voice: "v" });
     const llm = anthropic({ model: "claude-haiku-4-5" });
-    const def = agent({ name: "t", systemPrompt: "p", stt, llm, tts });
+    return { stt, llm, tts, def: agent({ name: "t", systemPrompt: "p", stt, llm, tts }) };
+  }
+
+  test("preserves stt/llm/tts providers on the returned def", () => {
+    const { stt, llm, tts, def } = pipelineAgent();
     expect(def.stt).toBe(stt);
     expect(def.llm).toBe(llm);
     expect(def.tts).toBe(tts);
   });
 
   test("stt/llm/tts flow through parseManifest to mode 'pipeline'", () => {
-    const stt = assemblyAI({ model: "u3pro-rt" });
-    const tts = cartesia({ voice: "v" });
-    const llm = anthropic({ model: "claude-haiku-4-5" });
-    const def = agent({ name: "t", systemPrompt: "p", stt, llm, tts });
+    const { stt, llm, tts, def } = pipelineAgent();
     const parsed = parseManifest(def);
     expect(parsed.mode).toBe("pipeline");
     expect(parsed.stt).toStrictEqual(stt);

package/sdk/define.ts

@@ -1,12 +1,10 @@
 // Copyright 2025 the AAI authors. MIT license.
-/**
- * Helper functions for defining agents and tools with full type inference.
- */
 
 import type { z } from "zod";
 import type {
   KvProvider,
   LlmProvider,
+  S2sProvider,
   SttProvider,
   TtsProvider,
   VectorProvider,
@@ -104,6 +102,12 @@ export function agent(def: {
    * enable pipeline mode.
    */
   tts?: TtsProvider;
+  /**
+   * Pluggable S2S provider descriptor. When set, overrides the implicit
+   * AssemblyAI default. Mutually exclusive with the `stt`/`llm`/`tts`
+   * pipeline triple.
+   */
+  s2s?: S2sProvider;
   /** Pluggable KV backend. Falls back to platform default when omitted. */
   kv?: KvProvider;
   /** Pluggable Vector backend. Falls back to platform default when omitted. */

package/sdk/exports.test.ts

@@ -1,6 +1,6 @@
 // Copyright 2025 the AAI authors. MIT license.
 /**
- * Export surface snapshot tests for all four aai subpath exports.
+ * Export surface snapshot tests for all five aai subpath exports.
  *
  * These tests catch accidental export additions or removals. If a snapshot
  * breaks, it signals a potentially breaking API change that should be
@@ -28,4 +28,9 @@ describe("export surface stability", () => {
     const mod = await import("@alexkroman1/aai/runtime");
     expect(Object.keys(mod).sort()).toMatchSnapshot();
   });
+
+  test("@alexkroman1/aai/s2s export", async () => {
+    const mod = await import("@alexkroman1/aai/s2s");
+    expect(Object.keys(mod).sort()).toMatchSnapshot();
+  });
 });

package/sdk/kv.ts

@@ -1,60 +1,36 @@
 // Copyright 2025 the AAI authors. MIT license.
-/**
- * Key-value storage interface and shared utilities.
- */
 
 /**
  * Async key-value store interface used by agents.
  *
- * Agents access the KV store via `ToolContext.kv`. Values are JSON-serialized and stored as
- * strings with an optional TTL.
+ * Agents access the KV store via `ToolContext.kv`. Values are JSON-serialized
+ * and stored as strings with an optional TTL.
  *
  * @example
  * ```ts
- * // Inside a tool execute function:
- * const myTool = {
- *   description: "Save and retrieve data",
- *   execute: async (_args: unknown, ctx: { kv: Kv }) => {
- *     await ctx.kv.set("user:name", "Alice", { expireIn: 60_000 });
- *     const name = await ctx.kv.get<string>("user:name");
- *     return name; // "Alice"
- *   },
- * };
+ * await ctx.kv.set("user:name", "Alice", { expireIn: 60_000 });
+ * const name = await ctx.kv.get<string>("user:name"); // "Alice"
  * ```
  *
  * @public
  */
 export type Kv = {
-  /**
-   * Get a value by key, or `null` if not found.
-   *
-   * @typeParam T - The expected type of the stored value.
-   * @param key - The key to look up.
-   * @returns The deserialized value, or `null` if the key does not exist
-   *   or has expired.
-   */
+  /** Get a value by key. Returns `null` if missing or expired. */
   get<T = unknown>(key: string): Promise<T | null>;
   /**
-   * Set a value, optionally with a TTL in milliseconds.
+   * Set a value, optionally with a TTL.
    *
-   * @param key - The key to store the value under.
-   * @param value - The value to store. Must be JSON-serializable.
-   * @param options - Optional settings. `expireIn` sets the time-to-live in **milliseconds**
-   *   (e.g. `60_000` for 1 minute). The entry is automatically removed after this duration.
-   * @throws Throws an Error if the serialized value exceeds 65,536 bytes.
+   * @param options.expireIn - Time-to-live in **milliseconds** (e.g. `60_000`
+   *   for 1 minute). The entry is automatically removed after this duration.
+   * @throws If the serialized value exceeds 65,536 bytes.
    */
   set(key: string, value: unknown, options?: { expireIn?: number }): Promise<void>;
-  /**
-   * Delete one or more keys.
-   *
-   * @param keys - A single key or array of keys to delete. No-op for keys that do not exist.
-   */
+  /** Delete one or more keys. No-op for keys that do not exist. */
   delete(keys: string | string[]): Promise<void>;
   /**
-   * Close the KV store, releasing any resources (intervals, database handles).
-   *
-   * After calling `close()`, the store must not be used. This is a no-op
-   * for implementations that hold no resources (e.g. in-memory stores).
+   * Release any held resources (intervals, database handles). After calling,
+   * the store must not be used. No-op for stateless implementations (e.g.
+   * in-memory stores).
    */
   close?(): void;
 };

package/sdk/manifest.test-d.ts

@@ -1,6 +1,7 @@
 // Copyright 2025 the AAI authors. MIT license.
 import { expectTypeOf, test } from "vitest";
 import type { Manifest } from "./manifest.ts";
+import type { S2sProvider } from "./providers.ts";
 
 test("Manifest.stt/llm/tts are optional", () => {
   expectTypeOf<Manifest["stt"]>().toBeNullable();
@@ -8,6 +9,10 @@ test("Manifest.stt/llm/tts are optional", () => {
   expectTypeOf<Manifest["tts"]>().toBeNullable();
 });
 
+test("Manifest.s2s is optional and typed as S2sProvider", () => {
+  expectTypeOf<Manifest["s2s"]>().toEqualTypeOf<S2sProvider | undefined>();
+});
+
 test("parseManifest return includes mode", () => {
   type Parsed = ReturnType<typeof import("./manifest.ts").parseManifest>;
   expectTypeOf<Parsed["mode"]>().toEqualTypeOf<"s2s" | "pipeline">();

package/sdk/manifest.test.ts

@@ -9,6 +9,7 @@ import { anthropic } from "./providers/llm/anthropic.ts";
 import { assemblyAI } from "./providers/stt/assemblyai.ts";
 import { cartesia } from "./providers/tts/cartesia.ts";
 import { pinecone } from "./providers/vector/pinecone.ts";
+import { assertProviderTriple } from "./providers.ts";
 
 describe("parseManifest", () => {
   test("minimal manifest requires only name", () => {
@@ -102,15 +103,16 @@ describe("parseManifest", () => {
   });
 });
 
-// ── Property-based tests ─────────────────────────────────────────────────
-
 describe("property: parseManifest", () => {
+  const optString = fc.option(fc.string(), { nil: undefined });
+  const optMaxSteps = fc.option(fc.integer({ min: 1, max: 100 }), { nil: undefined });
+
   test("valid manifests always parse", () => {
     const validManifestArb = fc.record({
       name: fc.string({ minLength: 1 }),
-      systemPrompt: fc.option(fc.string(), { nil: undefined }),
-      greeting: fc.option(fc.string(), { nil: undefined }),
-      maxSteps: fc.option(fc.integer({ min: 1, max: 100 }), { nil: undefined }),
+      systemPrompt: optString,
+      greeting: optString,
+      maxSteps: optMaxSteps,
       toolChoice: fc.option(fc.constantFrom("auto" as const, "required" as const), {
         nil: undefined,
       }),
@@ -127,11 +129,10 @@ describe("property: parseManifest", () => {
   });
 
   test("missing name throws", () => {
-    // Generate objects that never have a `name` field
     const noNameArb = fc.record({
-      systemPrompt: fc.option(fc.string(), { nil: undefined }),
-      greeting: fc.option(fc.string(), { nil: undefined }),
-      maxSteps: fc.option(fc.integer({ min: 1, max: 100 }), { nil: undefined }),
+      systemPrompt: optString,
+      greeting: optString,
+      maxSteps: optMaxSteps,
     });
 
     fc.assert(
@@ -229,3 +230,54 @@ describe("parseManifest — mode classification", () => {
     ).toThrow(/stt, llm, and tts must be set together/);
   });
 });
+
+describe("parseManifest s2s", () => {
+  test("parseManifest accepts s2s descriptor", () => {
+    const m = parseManifest({
+      name: "x",
+      s2s: { kind: "openai-realtime", options: { model: "gpt-realtime" } },
+    });
+    expect(m.s2s).toEqual({
+      kind: "openai-realtime",
+      options: { model: "gpt-realtime" },
+    });
+    expect(m.mode).toBe("s2s");
+  });
+
+  test("parseManifest rejects s2s combined with pipeline triple", () => {
+    expect(() =>
+      parseManifest({
+        name: "x",
+        s2s: { kind: "openai-realtime", options: {} },
+        stt: { kind: "assemblyai", options: {} },
+        llm: { kind: "openai", options: {} },
+        tts: { kind: "cartesia", options: {} },
+      }),
+    ).toThrow(/s2s.*pipeline|cannot.*together/i);
+  });
+});
+
+describe("assertProviderTriple with s2s", () => {
+  test("returns 's2s' when s2s descriptor is set and pipeline triple is empty", () => {
+    const s2s = { kind: "openai-realtime", options: {} };
+    expect(assertProviderTriple(undefined, undefined, undefined, s2s)).toBe("s2s");
+  });
+
+  test("returns 's2s' when nothing is set (default fallback)", () => {
+    expect(assertProviderTriple(undefined, undefined, undefined, undefined)).toBe("s2s");
+  });
+
+  test("returns 'pipeline' when triple is set and s2s is not", () => {
+    const stt = { kind: "x", options: {} };
+    expect(assertProviderTriple(stt, stt, stt, undefined)).toBe("pipeline");
+  });
+
+  test("rejects setting s2s alongside any pipeline field", () => {
+    const d = { kind: "x", options: {} };
+    expect(() => assertProviderTriple(d, undefined, undefined, d)).toThrow(
+      /s2s.*pipeline|cannot.*together/i,
+    );
+    expect(() => assertProviderTriple(undefined, d, undefined, d)).toThrow();
+    expect(() => assertProviderTriple(undefined, undefined, d, d)).toThrow();
+  });
+});

package/sdk/manifest.ts

@@ -12,6 +12,7 @@ import {
   assertProviderTriple,
   type KvProvider,
   type LlmProvider,
+  type S2sProvider,
   type SessionMode,
   type SttProvider,
   type TtsProvider,
@@ -70,13 +71,19 @@ export type Manifest = {
    * enable pipeline mode.
    */
   tts?: TtsProvider | undefined;
+  /**
+   * Pluggable S2S provider descriptor. When set, overrides the implicit
+   * AssemblyAI default. Mutually exclusive with the `stt`/`llm`/`tts`
+   * pipeline triple.
+   */
+  s2s?: S2sProvider | undefined;
   /** Pluggable KV backend descriptor. Falls back to platform default when omitted. */
   kv?: KvProvider | undefined;
   /** Pluggable Vector backend descriptor. Falls back to platform default when omitted. */
   vector?: VectorProvider | undefined;
   /**
    * Session mode derived from provider fields:
-   * - `"s2s"` (default): AssemblyAI Streaming Speech-to-Speech path (no stt/llm/tts set).
+   * - `"s2s"`: speech-to-speech path (default when no stt/llm/tts set, or when `s2s` is set).
    * - `"pipeline"`: pluggable STT → LLM → TTS path (stt + llm + tts all set).
    */
   mode: SessionMode;
@@ -127,6 +134,7 @@ const ManifestSchema = z.object({
   stt: ProviderDescriptorSchema.optional(),
   llm: ProviderDescriptorSchema.optional(),
   tts: ProviderDescriptorSchema.optional(),
+  s2s: ProviderDescriptorSchema.optional(),
   kv: ProviderDescriptorSchema.optional(),
   vector: ProviderDescriptorSchema.optional(),
 });
@@ -142,24 +150,16 @@ const ManifestSchema = z.object({
  */
 export function parseManifest(input: unknown): Manifest {
   const parsed = ManifestSchema.parse(input);
-  const mode = assertProviderTriple(parsed.stt, parsed.llm, parsed.tts);
+  const mode = assertProviderTriple(parsed.stt, parsed.llm, parsed.tts, parsed.s2s);
   return {
-    name: parsed.name,
+    ...parsed,
     systemPrompt: parsed.systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
     greeting: parsed.greeting ?? DEFAULT_GREETING,
-    sttPrompt: parsed.sttPrompt,
     builtinTools: parsed.builtinTools ?? [],
     maxSteps: parsed.maxSteps ?? 5,
     toolChoice: parsed.toolChoice ?? "auto",
-    idleTimeoutMs: parsed.idleTimeoutMs,
-    theme: parsed.theme,
     tools: parsed.tools ?? {},
     allowedHosts: parsed.allowedHosts ?? [],
-    stt: parsed.stt,
-    llm: parsed.llm,
-    tts: parsed.tts,
-    kv: parsed.kv,
-    vector: parsed.vector,
     mode,
   };
 }

package/sdk/protocol-compat.test.ts

@@ -9,6 +9,7 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "vitest";
+import type { ZodTypeAny } from "zod";
 import {
   DEFAULT_STT_SAMPLE_RATE,
   DEFAULT_TTS_SAMPLE_RATE,
@@ -21,20 +22,7 @@ import {
   SessionErrorCodeSchema,
 } from "./protocol.ts";
 
-// ── Load fixtures ─────────────────────────────────────────────────────────
-
 const FIXTURE_DIR = join(import.meta.dirname, "compat-fixtures");
-// Only load compat fixtures that have the expected schema-compat structure
-// (ServerMessage, ClientMessage, KvRequest, constants). Wire-format fixtures
-// like wire-v1.json use a different shape and are tested by wire.test.ts.
-const fixtureFiles = readdirSync(FIXTURE_DIR)
-  .filter((f) => f.endsWith(".json"))
-  .filter((f) => {
-    const raw = readFileSync(join(FIXTURE_DIR, f), "utf-8");
-    const parsed = JSON.parse(raw) as Record<string, unknown>;
-    return "ServerMessage" in parsed && "ClientMessage" in parsed;
-  })
-  .sort();
 
 type Fixture = {
   version: number;
@@ -53,6 +41,16 @@ function loadFixture(filename: string): Fixture {
   return JSON.parse(readFileSync(join(FIXTURE_DIR, filename), "utf-8"));
 }
 
+// Wire-format fixtures (e.g. wire-v1.json) use a different shape and live in
+// wire.test.ts; filter them out by checking for the schema-compat structure.
+const fixtureFiles = readdirSync(FIXTURE_DIR)
+  .filter((f) => f.endsWith(".json"))
+  .filter((f) => {
+    const parsed = loadFixture(f) as unknown as Record<string, unknown>;
+    return "ServerMessage" in parsed && "ClientMessage" in parsed;
+  })
+  .sort();
+
 function compatError(fixture: string, schema: string, msg: unknown, zodError: string): string {
   return [
     `PROTOCOL COMPATIBILITY BREAK (${fixture}, ${schema}):`,
@@ -68,104 +66,74 @@ function compatError(fixture: string, schema: string, msg: unknown, zodError: st
   ].join("\n");
 }
 
-/**
- * Check if a discriminated union schema accepts a given discriminant value
- * by testing whether a minimal object with that value passes the first
- * discriminant check (the full parse may fail, but the type/op is recognized).
- */
-function schemaAcceptsType(
-  schema: typeof ServerMessageSchema | typeof ClientMessageSchema,
-  type: string,
-): boolean {
-  // Parse a minimal object with just the discriminant. If the discriminant
-  // is unrecognized, the error includes "invalid_union_discriminator" or
-  // similar. Any other failure (missing fields) means the variant exists.
-  const result = schema.safeParse({ type });
-  if (result.success) return true;
-  // Check error messages — the Zod issue code for discriminated union
-  // mismatches varies across versions, so we check the message text.
-  return !result.error.issues.some((i) => i.message.includes("Invalid discriminator"));
-}
-
-function kvSchemaAcceptsOp(op: string): boolean {
-  const result = KvRequestSchema.safeParse({ op });
+// A minimal-discriminant parse fails either with "Invalid discriminator" (variant
+// removed) or with missing-field errors (variant exists). The Zod issue code for
+// discriminated-union mismatches varies across versions, so match on message text.
+function schemaAcceptsDiscriminant(schema: ZodTypeAny, value: Record<string, unknown>): boolean {
+  const result = schema.safeParse(value);
   if (result.success) return true;
   return !result.error.issues.some((i) => i.message.includes("Invalid discriminator"));
 }
 
-// ── Tests ─────────────────────────────────────────────────────────────────
+type CompatGroup = {
+  label: string;
+  schema: ZodTypeAny;
+  messages: Record<string, unknown>[];
+  discriminant: "type" | "op";
+};
 
 describe.each(fixtureFiles)("compat fixture: %s", (filename) => {
   const fixture = loadFixture(filename);
 
-  // ── Backward compat: every fixture message must still parse ──────
-
-  describe("ServerMessage backward compat", () => {
-    test.each(
-      fixture.ServerMessage.map((m, i) => [`${(m as { type: string }).type}#${i}`, m]),
-    )("%s parses against current schema", (_label, msg) => {
-      const result = ServerMessageSchema.safeParse(msg);
-      if (!result.success) {
-        throw new Error(compatError(filename, "ServerMessage", msg, result.error.message));
-      }
-    });
-  });
-
-  describe("ClientMessage backward compat", () => {
-    test.each(
-      fixture.ClientMessage.map((m, i) => [`${(m as { type: string }).type}#${i}`, m]),
-    )("%s parses against current schema", (_label, msg) => {
-      const result = ClientMessageSchema.safeParse(msg);
-      if (!result.success) {
-        throw new Error(compatError(filename, "ClientMessage", msg, result.error.message));
-      }
+  const groups: CompatGroup[] = [
+    {
+      label: "ServerMessage",
+      schema: ServerMessageSchema,
+      messages: fixture.ServerMessage,
+      discriminant: "type",
+    },
+    {
+      label: "ClientMessage",
+      schema: ClientMessageSchema,
+      messages: fixture.ClientMessage,
+      discriminant: "type",
+    },
+    {
+      label: "KvRequest",
+      schema: KvRequestSchema,
+      messages: fixture.KvRequest,
+      discriminant: "op",
+    },
+  ];
+
+  for (const { label, schema, messages, discriminant } of groups) {
+    describe(`${label} backward compat`, () => {
+      test.each(
+        messages.map((m, i) => [`${m[discriminant] as string}#${i}`, m]),
+      )("%s parses against current schema", (_label, msg) => {
+        const result = schema.safeParse(msg);
+        if (!result.success) {
+          throw new Error(compatError(filename, label, msg, result.error.message));
+        }
+      });
     });
-  });
-
-  describe("KvRequest backward compat", () => {
-    test.each(
-      fixture.KvRequest.map((m, i) => [`${(m as { op: string }).op}#${i}`, m]),
-    )("%s parses against current schema", (_label, msg) => {
-      const result = KvRequestSchema.safeParse(msg);
-      if (!result.success) {
-        throw new Error(compatError(filename, "KvRequest", msg, result.error.message));
-      }
-    });
-  });
-
-  // ── Variant coverage: no types/ops removed ──────────────────────
+  }
 
   describe("variant coverage", () => {
-    test("no ServerMessage types removed", () => {
-      const fixtureTypes = new Set(fixture.ServerMessage.map((m) => (m as { type: string }).type));
-      for (const t of fixtureTypes) {
-        expect(
-          schemaAcceptsType(ServerMessageSchema, t),
-          `ServerMessage variant "${t}" was removed`,
-        ).toBe(true);
-      }
-    });
-
-    test("no ClientMessage types removed", () => {
-      const fixtureTypes = new Set(fixture.ClientMessage.map((m) => (m as { type: string }).type));
-      for (const t of fixtureTypes) {
-        expect(
-          schemaAcceptsType(ClientMessageSchema, t),
-          `ClientMessage variant "${t}" was removed`,
-        ).toBe(true);
-      }
-    });
-
-    test("no KvRequest ops removed", () => {
-      const fixtureOps = new Set(fixture.KvRequest.map((m) => (m as { op: string }).op));
-      for (const op of fixtureOps) {
-        expect(kvSchemaAcceptsOp(op), `KvRequest op "${op}" was removed`).toBe(true);
-      }
-    });
+    for (const { label, schema, messages, discriminant } of groups) {
+      const noun = discriminant === "type" ? "variant" : "op";
+      test(`no ${label} ${noun}s removed`, () => {
+        const seen = new Set(messages.map((m) => m[discriminant] as string));
+        for (const value of seen) {
+          expect(
+            schemaAcceptsDiscriminant(schema, { [discriminant]: value }),
+            `${label} ${noun} "${value}" was removed`,
+          ).toBe(true);
+        }
+      });
+    }
   });
 
-  // ── Constants stability ─────────────────────────────────────────
-
   describe("constants stability", () => {
     test("DEFAULT_STT_SAMPLE_RATE unchanged", () => {
       expect(DEFAULT_STT_SAMPLE_RATE).toBe(fixture.constants.DEFAULT_STT_SAMPLE_RATE);

package/sdk/protocol-snapshot.test.ts

@@ -21,8 +21,6 @@ import {
   VectorRequestSchema,
 } from "./protocol.ts";
 
-// ── Constants ────────────────────────────────────────────────────────────
-
 describe("protocol constants", () => {
   test("sample rates", () => {
     expect(DEFAULT_STT_SAMPLE_RATE).toMatchInlineSnapshot("16000");
@@ -49,8 +47,6 @@ describe("protocol constants", () => {
   });
 });
 
-// ── Server → Client events (ClientEventSchema) ──────────────────────────
-
 describe("server→client event wire format", () => {
   const valid: [string, ClientEvent][] = [
     ["speech_started", { type: "speech_started" }],
@@ -77,8 +73,7 @@ describe("server→client event wire format", () => {
   ];
 
   test.each(valid)("%s parses successfully", (_label, event) => {
-    const result = ClientEventSchema.safeParse(event);
-    expect(result.success).toBe(true);
+    expect(ClientEventSchema.safeParse(event).success).toBe(true);
   });
 
   test("rejects unknown event type", () => {
@@ -108,8 +103,6 @@ describe("server→client event wire format", () => {
   });
 });
 
-// ── Client → Server messages (ClientMessageSchema) ──────────────────────
-
 describe("client→server message wire format", () => {
   const valid: [string, ClientMessage][] = [
     ["audio_ready", { type: "audio_ready" }],
@@ -128,8 +121,7 @@ describe("client→server message wire format", () => {
   ];
 
   test.each(valid)("%s parses successfully", (_label, msg) => {
-    const result = ClientMessageSchema.safeParse(msg);
-    expect(result.success).toBe(true);
+    expect(ClientMessageSchema.safeParse(msg).success).toBe(true);
   });
 
   test("rejects unknown message type", () => {
@@ -154,8 +146,6 @@ describe("client→server message wire format", () => {
   });
 });
 
-// ── ServerMessage union (type check) ────────────────────────────────────
-
 describe("ServerMessage type covers all variants", () => {
   test("config message shape", () => {
     const msg: ServerMessage = {
@@ -178,8 +168,6 @@ describe("ServerMessage type covers all variants", () => {
   });
 });
 
-// ── KvRequestSchema ─────────────────────────────────────────────────────
-
 describe("KvRequest wire format", () => {
   const valid = [
     ["get", { op: "get", key: "k1" }],
@@ -201,8 +189,6 @@ describe("KvRequest wire format", () => {
   });
 });
 
-// ── VectorRequestSchema ─────────────────────────────────────────────────
-
 describe("VectorRequest wire format", () => {
   const valid = [
     ["upsert", { op: "upsert", id: "doc-1", text: "hello" }],

package/sdk/protocol.test.ts

@@ -70,17 +70,19 @@ describe("KvRequestSchema", () => {
   });
 });
 
+const ERROR_CODES = [
+  "stt",
+  "llm",
+  "tts",
+  "tool",
+  "protocol",
+  "connection",
+  "audio",
+  "internal",
+] as const;
+
 describe("SessionErrorCodeSchema", () => {
-  test.each([
-    "stt",
-    "llm",
-    "tts",
-    "tool",
-    "protocol",
-    "connection",
-    "audio",
-    "internal",
-  ])("accepts valid code: %s", (code) => {
+  test.each(ERROR_CODES)("accepts valid code: %s", (code) => {
     expect(SessionErrorCodeSchema.safeParse(code).success).toBe(true);
   });
 
@@ -173,17 +175,6 @@ describe("property: lenientParse", () => {
   });
 
   test("valid ClientEvents round-trip through parse", () => {
-    const errorCodes = [
-      "stt",
-      "llm",
-      "tts",
-      "tool",
-      "protocol",
-      "connection",
-      "audio",
-      "internal",
-    ] as const;
-
     const speechStartedArb = fc.constant({ type: "speech_started" as const });
 
     const userTranscriptArb = fc.record({
@@ -193,7 +184,7 @@ describe("property: lenientParse", () => {
 
     const errorEventArb = fc.record({
       type: fc.constant("error" as const),
-      code: fc.constantFrom(...errorCodes),
+      code: fc.constantFrom(...ERROR_CODES),
       message: fc.string(),
     });