@alexkroman1/aai 1.7.0 → 1.8.0

package/sdk/providers/s2s/openai-realtime.ts

@@ -0,0 +1,36 @@
+// Copyright 2025 the AAI authors. MIT license.
+/** OpenAI Realtime S2S descriptor — host transport resolves at session start. */
+
+import type { S2sProvider } from "../../providers.ts";
+
+export const OPENAI_REALTIME_KIND = "openai-realtime" as const;
+
+export type OpenaiRealtimeVoice =
+  | "alloy"
+  | "ash"
+  | "ballad"
+  | "cedar"
+  | "coral"
+  | "echo"
+  | "marin"
+  | "sage"
+  | "shimmer"
+  | "verse";
+
+export type OpenaiRealtimeOptions = {
+  /** Realtime model identifier. Default applied by the host (currently `"gpt-realtime-2"`). */
+  model?: string;
+  /** TTS voice. Default applied by the host (currently `"alloy"`). */
+  voice?: OpenaiRealtimeVoice;
+  /** Override the WebSocket base URL (testing/proxy). */
+  url?: string;
+};
+
+export type OpenaiRealtimeProvider = S2sProvider & {
+  readonly kind: typeof OPENAI_REALTIME_KIND;
+  readonly options: OpenaiRealtimeOptions;
+};
+
+export function openaiRealtime(opts: OpenaiRealtimeOptions = {}): OpenaiRealtimeProvider {
+  return { kind: OPENAI_REALTIME_KIND, options: { ...opts } };
+}

package/sdk/providers/s2s-barrel.ts

@@ -0,0 +1,12 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * `@alexkroman1/aai/s2s` subpath barrel.
+ *
+ * Re-exports S2S descriptor factories. Importing this barrel does not
+ * pull in any provider SDK — the host resolver handles that at session
+ * start.
+ */
+
+export type { S2sProvider } from "../providers.ts";
+// biome-ignore lint/performance/noReExportAll: subpath barrel
+export * from "./s2s/openai-realtime.ts";

package/sdk/providers/tts/rime.ts

@@ -29,7 +29,7 @@ export interface RimeOptions {
    * Rime model ID. Defaults to `"mistv2"` (Rime's most compatible model).
    * Common values: `"mistv2"`, `"arcana"`.
    */
-  model?: "mistv2" | "arcana" | string;
+  model?: string;
   /**
    * Spoken language. Uses ISO 639-3 (three-letter codes).
    * Defaults to `"eng"` (English).

package/sdk/providers.ts

@@ -48,6 +48,9 @@ export type LlmProvider = ProviderDescriptor<string, Record<string, unknown>>;
 /** Descriptor for a TTS provider. Returned by factories like `cartesia(...)`. */
 export type TtsProvider = ProviderDescriptor<string, Record<string, unknown>>;
 
+/** Descriptor for an S2S provider. Returned by factories like `openaiRealtime(...)`. */
+export type S2sProvider = ProviderDescriptor<string, Record<string, unknown>>;
+
 /** Descriptor for a KV backend. Returned by factories like `redisKv()`. */
 export type KvProvider = ProviderDescriptor<string, Record<string, unknown>>;
 
@@ -67,14 +70,30 @@ export type SessionMode = "s2s" | "pipeline";
  * Enforce the all-or-nothing provider rule and return the derived mode.
  *
  * Pipeline mode requires STT, LLM, and TTS all set; S2S mode requires
- * none of them. Anything in-between is a configuration error.
+ * none of them. Anything in-between is a configuration error. An optional
+ * `s2s` descriptor selects a non-default S2S provider — it must not be
+ * combined with any pipeline field.
  */
-export function assertProviderTriple(stt: unknown, llm: unknown, tts: unknown): SessionMode {
-  const count = (stt != null ? 1 : 0) + (llm != null ? 1 : 0) + (tts != null ? 1 : 0);
-  if (count !== 0 && count !== 3) {
+export function assertProviderTriple(
+  stt: unknown,
+  llm: unknown,
+  tts: unknown,
+  s2s?: unknown,
+): SessionMode {
+  const hasStt = stt != null;
+  const hasLlm = llm != null;
+  const hasTts = tts != null;
+  const hasS2s = s2s != null;
+  const anyPipeline = hasStt || hasLlm || hasTts;
+  const allSet = hasStt && hasLlm && hasTts;
+  const noneSetPipeline = !anyPipeline;
+  if (hasS2s && anyPipeline) {
+    throw new Error("s2s and the stt/llm/tts pipeline cannot be set together");
+  }
+  if (!(allSet || noneSetPipeline)) {
     throw new Error("stt, llm, and tts must be set together");
   }
-  return count === 3 ? "pipeline" : "s2s";
+  return allSet ? "pipeline" : "s2s";
 }
 
 // -------- STT openable (host-only) ------------------------------------------

package/sdk/schema-alignment.test.ts

@@ -1,20 +1,10 @@
 // Copyright 2025 the AAI authors. MIT license.
-/**
- * Schema–type alignment tests.
- *
- * These tests verify that Zod schemas and their derived TypeScript types
- * stay in sync, and that schemas correctly reject invalid data. When a
- * new field is added to a type but not its schema (or vice-versa), these
- * tests break — preventing silent API drift.
- */
 import { describe, expect, expectTypeOf, test } from "vitest";
 import type { z } from "zod";
 import { type AgentConfig, AgentConfigSchema, ToolSchemaSchema } from "./_internal-types.ts";
 import { type ReadyConfig, ReadyConfigSchema } from "./protocol.ts";
 import { type BuiltinTool, BuiltinToolSchema, type ToolChoice, ToolChoiceSchema } from "./types.ts";
 
-// ── AgentConfigSchema ────────────────────────────────────────────────────
-
 describe("AgentConfigSchema", () => {
   const valid: AgentConfig = {
     name: "test-agent",
@@ -37,22 +27,13 @@ describe("AgentConfigSchema", () => {
     expect(AgentConfigSchema.parse(full)).toEqual(full);
   });
 
-  test("rejects empty name", () => {
-    expect(AgentConfigSchema.safeParse({ ...valid, name: "" }).success).toBe(false);
-  });
-
-  test("rejects non-integer maxSteps", () => {
-    expect(AgentConfigSchema.safeParse({ ...valid, maxSteps: 2.5 }).success).toBe(false);
-  });
-
-  test("rejects negative maxSteps", () => {
-    expect(AgentConfigSchema.safeParse({ ...valid, maxSteps: -1 }).success).toBe(false);
-  });
-
-  test("rejects invalid builtinTools", () => {
-    expect(AgentConfigSchema.safeParse({ ...valid, builtinTools: ["not_a_tool"] }).success).toBe(
-      false,
-    );
+  test.each([
+    ["empty name", { name: "" }],
+    ["non-integer maxSteps", { maxSteps: 2.5 }],
+    ["negative maxSteps", { maxSteps: -1 }],
+    ["invalid builtinTools", { builtinTools: ["not_a_tool"] }],
+  ])("rejects %s", (_label, override) => {
+    expect(AgentConfigSchema.safeParse({ ...valid, ...override }).success).toBe(false);
   });
 
   test("type derived from schema matches AgentConfig", () => {
@@ -60,9 +41,9 @@ describe("AgentConfigSchema", () => {
   });
 });
 
-// ── ToolSchemaSchema ─────────────────────────────────────────────────────
-
 describe("ToolSchemaSchema", () => {
+  const base = { type: "function" as const, name: "n", description: "d", parameters: {} };
+
   test("accepts valid tool schema", () => {
     const valid = {
       type: "function" as const,
@@ -73,47 +54,28 @@ describe("ToolSchemaSchema", () => {
     expect(ToolSchemaSchema.parse(valid)).toEqual(valid);
   });
 
-  test("rejects empty name", () => {
-    expect(
-      ToolSchemaSchema.safeParse({
-        type: "function",
-        name: "",
-        description: "d",
-        parameters: {},
-      }).success,
-    ).toBe(false);
-  });
-
-  test("rejects empty description", () => {
-    expect(
-      ToolSchemaSchema.safeParse({
-        type: "function",
-        name: "n",
-        description: "",
-        parameters: {},
-      }).success,
-    ).toBe(false);
+  test.each([
+    ["empty name", { name: "" }],
+    ["empty description", { description: "" }],
+  ])("rejects %s", (_label, override) => {
+    expect(ToolSchemaSchema.safeParse({ ...base, ...override }).success).toBe(false);
   });
 
   test("ToolSchema is assignable from schema inference", () => {
-    // ToolSchema uses JSONSchema7 for parameters which is more specific than
-    // the runtime schema's Record<string, unknown>. Verify the direction:
-    // a parsed result should be assignable to ToolSchema (narrow → wide).
+    // ToolSchema uses JSONSchema7 for parameters (narrower than the runtime
+    // Record<string, unknown>); verify a parsed result satisfies the wider shape.
     const parsed = ToolSchemaSchema.parse({
       type: "function",
       name: "test",
       description: "test",
       parameters: { type: "object" },
     });
-    // Runtime check: shape matches
     expect(parsed).toHaveProperty("name");
     expect(parsed).toHaveProperty("description");
     expect(parsed).toHaveProperty("parameters");
   });
 });
 
-// ── ReadyConfigSchema ────────────────────────────────────────────────────
-
 describe("ReadyConfigSchema", () => {
   const valid: ReadyConfig = {
     audioFormat: "pcm16",
@@ -125,12 +87,11 @@ describe("ReadyConfigSchema", () => {
     expect(ReadyConfigSchema.parse(valid)).toEqual(valid);
   });
 
-  test("rejects unknown audio format", () => {
-    expect(ReadyConfigSchema.safeParse({ ...valid, audioFormat: "mp3" }).success).toBe(false);
-  });
-
-  test("rejects non-positive sampleRate", () => {
-    expect(ReadyConfigSchema.safeParse({ ...valid, sampleRate: 0 }).success).toBe(false);
+  test.each([
+    ["unknown audio format", { audioFormat: "mp3" }],
+    ["non-positive sampleRate", { sampleRate: 0 }],
+  ])("rejects %s", (_label, override) => {
+    expect(ReadyConfigSchema.safeParse({ ...valid, ...override }).success).toBe(false);
   });
 
   test("type derived from schema matches ReadyConfig", () => {
@@ -138,13 +99,8 @@ describe("ReadyConfigSchema", () => {
   });
 });
 
-// ── BuiltinTool / ToolChoice drift guards ────────────────────────────────
-
 describe("type ↔ schema alignment", () => {
   test("BuiltinToolSchema values match BuiltinTool union", () => {
-    // Schema values are the source of truth; if the type adds a member
-    // without updating the schema (or vice versa), TypeScript will error
-    // on the drift guards in types.ts. This test documents the enum values.
     expect(BuiltinToolSchema.options).toMatchInlineSnapshot(`
       [
         "web_search",
@@ -163,15 +119,11 @@ describe("type ↔ schema alignment", () => {
     expectTypeOf<z.infer<typeof ToolChoiceSchema>>().toEqualTypeOf<ToolChoice>();
   });
 
-  test("ToolChoiceSchema accepts all ToolChoice variants", () => {
-    const variants: ToolChoice[] = ["auto", "required"];
-    for (const v of variants) {
-      expect(ToolChoiceSchema.safeParse(v).success).toBe(true);
-    }
+  test.each<ToolChoice>(["auto", "required"])("ToolChoiceSchema accepts %s", (v) => {
+    expect(ToolChoiceSchema.safeParse(v).success).toBe(true);
   });
 
-  test("ToolChoiceSchema rejects invalid variants", () => {
-    expect(ToolChoiceSchema.safeParse("invalid").success).toBe(false);
-    expect(ToolChoiceSchema.safeParse("none").success).toBe(false);
+  test.each(["invalid", "none"])("ToolChoiceSchema rejects %s", (v) => {
+    expect(ToolChoiceSchema.safeParse(v).success).toBe(false);
   });
 });

package/sdk/schema-shapes.test.ts

@@ -1,17 +1,4 @@
 // Copyright 2025 the AAI authors. MIT license.
-/**
- * Schema shape snapshot tests for public Zod schemas.
- *
- * These tests snapshot the field names of public schemas exported from
- * `@alexkroman1/aai/protocol` and `@alexkroman1/aai/manifest`. A breaking
- * snapshot signals a wire-format change (field additions, removals, or renames)
- * that may require a changeset and protocol-version bump.
- *
- * For discriminated unions (ClientEventSchema, ServerMessageSchema,
- * ClientMessageSchema), each option's shape keys are keyed by its
- * discriminator value. For object schemas (AgentConfigSchema,
- * ToolSchemaSchema), the top-level shape keys are snapshotted directly.
- */
 import { describe, expect, test } from "vitest";
 import { AgentConfigSchema, ToolSchemaSchema } from "./_internal-types.ts";
 import {
@@ -24,22 +11,12 @@ import {
   ServerMessageSchema,
 } from "./protocol.ts";
 
-// ── Helpers ──────────────────────────────────────────────────────────────
-
 type ZodObjectLike = { shape: Record<string, unknown> };
 
-/**
- * Extract shape keys (field names) from a ZodObject-like schema.
- */
 function shapeKeys(schema: ZodObjectLike): string[] {
   return Object.keys(schema.shape).sort();
 }
 
-/**
- * Extract a map of { discriminatorValue → sorted shape keys } from a
- * ZodDiscriminatedUnion. The discriminator literal may be a single value
- * or an array (Zod v4 stores it as `.values`).
- */
 function discriminatedUnionShapes(schema: {
   options: Array<{ shape: Record<string, unknown> }>;
 }): Record<string, string[]> {
@@ -48,9 +25,8 @@ function discriminatedUnionShapes(schema: {
     const typeSchema = option.shape?.type as
       | { _def?: { value?: string; values?: string[] } }
       | undefined;
-    const def = typeSchema?._def;
     // Zod v4 uses `.values` (array); Zod v3 uses `.value` (scalar)
-    const raw = def?.values ?? def?.value;
+    const raw = typeSchema?._def?.values ?? typeSchema?._def?.value;
     const discriminatorValue = Array.isArray(raw) ? raw[0] : raw;
     const key = String(discriminatorValue ?? "unknown");
     result[key] = Object.keys(option.shape).sort();
@@ -58,8 +34,6 @@ function discriminatedUnionShapes(schema: {
   return result;
 }
 
-// ── Protocol schemas ─────────────────────────────────────────────────────
-
 describe("protocol schema shapes", () => {
   test("ClientEventSchema option shapes", () => {
     expect(discriminatedUnionShapes(ClientEventSchema)).toMatchSnapshot();
@@ -90,8 +64,6 @@ describe("protocol schema shapes", () => {
   });
 });
 
-// ── Manifest schemas ──────────────────────────────────────────────────────
-
 describe("manifest schema shapes", () => {
   test("AgentConfigSchema shape", () => {
     expect(shapeKeys(AgentConfigSchema)).toMatchSnapshot();

package/sdk/system-prompt.test.ts

@@ -8,7 +8,6 @@ import { DEFAULT_SYSTEM_PROMPT } from "./types.ts";
 describe("buildSystemPrompt", () => {
   beforeEach(() => {
     vi.useFakeTimers();
-    // Pin to Wednesday, January 15, 2025
     vi.setSystemTime(new Date("2025-01-15T12:00:00Z"));
   });
 

package/sdk/system-prompt.ts

@@ -6,14 +6,17 @@
 import type { AgentConfig } from "./_internal-types.ts";
 import { DEFAULT_SYSTEM_PROMPT } from "./types.ts";
 
-function getFormattedDate(): string {
-  return new Date().toLocaleDateString("en-US", {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric",
-  });
-}
+const DATE_FORMAT_OPTIONS: Intl.DateTimeFormatOptions = {
+  weekday: "long",
+  year: "numeric",
+  month: "long",
+  day: "numeric",
+};
+
+const TOOL_PREAMBLE =
+  "\n\nWhen you decide to use a tool, ALWAYS say a brief natural phrase BEFORE the tool call " +
+  '(e.g. "Let me look that up" or "One moment while I check"). ' +
+  "This fills silence while the tool executes. Keep preambles to one short sentence.";
 
 const VOICE_RULES =
   "\n\nCRITICAL OUTPUT RULES — you MUST follow these for EVERY response:\n" +
@@ -44,24 +47,19 @@ export function buildSystemPrompt(
   config: AgentConfig,
   opts: { hasTools: boolean; voice?: boolean; toolGuidance?: readonly string[] | undefined },
 ): string {
-  const { hasTools } = opts;
-  const agentInstructions =
-    config.systemPrompt && config.systemPrompt !== DEFAULT_SYSTEM_PROMPT
-      ? `\n\nAgent-Specific Instructions:\n${config.systemPrompt}`
-      : "";
-
-  const toolPreamble = hasTools
-    ? "\n\nWhen you decide to use a tool, ALWAYS say a brief natural phrase BEFORE the tool call " +
-      '(e.g. "Let me look that up" or "One moment while I check"). ' +
-      "This fills silence while the tool executes. Keep preambles to one short sentence."
+  const hasCustomPrompt = config.systemPrompt && config.systemPrompt !== DEFAULT_SYSTEM_PROMPT;
+  const agentInstructions = hasCustomPrompt
+    ? `\n\nAgent-Specific Instructions:\n${config.systemPrompt}`
     : "";
 
+  const toolPreamble = opts.hasTools ? TOOL_PREAMBLE : "";
+
   const guidance =
     opts.toolGuidance && opts.toolGuidance.length > 0
       ? `\n\nBuilt-in Tool Usage:\n${opts.toolGuidance.join("\n")}`
       : "";
 
-  const today = getFormattedDate();
+  const today = new Date().toLocaleDateString("en-US", DATE_FORMAT_OPTIONS);
 
   return (
     DEFAULT_SYSTEM_PROMPT +

package/sdk/types-inference.test.ts

@@ -1,16 +1,14 @@
 // Copyright 2025 the AAI authors. MIT license.
-/**
- * Type-level tests for AgentDef and ToolDef type inference.
- *
- * These use vitest's expectTypeOf to verify that TypeScript correctly
- * infers parameter types, state types, and context types without
- * any runtime assertions. A failing type test means a type refactor
- * broke inference for consumers.
- */
 import { describe, expectTypeOf, test } from "vitest";
 import { z } from "zod";
 import type { AgentDef, Message, ToolContext, ToolDef } from "./types.ts";
 
+const baseAgent = {
+  systemPrompt: "Be helpful.",
+  greeting: "Hello!",
+  maxSteps: 5,
+} as const;
+
 describe("ToolDef type inference", () => {
   test("infers parameter types in execute args", () => {
     const _t: ToolDef<z.ZodObject<{ name: z.ZodString; count: z.ZodNumber }>> = {
@@ -19,7 +17,6 @@ describe("ToolDef type inference", () => {
       execute: (args) => args,
     };
 
-    // The execute function should receive typed args
     type Args = Parameters<typeof _t.execute>[0];
     expectTypeOf<Args>().toEqualTypeOf<{ name: string; count: number }>();
   });
@@ -31,7 +28,6 @@ describe("ToolDef type inference", () => {
     };
 
     type Args = Parameters<typeof _t.execute>[0];
-    // Without parameters, args is inferred from the base ZodObject
     expectTypeOf<Args>().toBeObject();
   });
 
@@ -57,26 +53,16 @@ describe("ToolDef type inference", () => {
 
 describe("AgentDef type inference", () => {
   test("satisfies AgentDef type", () => {
-    const agent: AgentDef = {
-      name: "test",
-      systemPrompt: "Be helpful.",
-      greeting: "Hello!",
-      maxSteps: 5,
-      tools: {},
-    };
+    const agent: AgentDef = { ...baseAgent, name: "test", tools: {} };
     expectTypeOf(agent).toMatchTypeOf<AgentDef>();
   });
 
   test("typed state flows through to tools", () => {
     type MyState = { counter: number; name: string };
 
-    // This should compile without errors — state type flows
-    // through to tool execute context
     const _agent: AgentDef<MyState> = {
+      ...baseAgent,
       name: "typed-state",
-      systemPrompt: "Be helpful.",
-      greeting: "Hello!",
-      maxSteps: 5,
       state: () => ({ counter: 0, name: "test" }),
       tools: {
         inc: {
@@ -96,25 +82,13 @@ describe("AgentDef type inference", () => {
       execute: ({ name }: { name: string }) => `Hello, ${name}!`,
     };
 
-    const agent: AgentDef = {
-      name: "with-tool",
-      systemPrompt: "Be helpful.",
-      greeting: "Hello!",
-      maxSteps: 5,
-      tools: { greet },
-    };
+    const agent: AgentDef = { ...baseAgent, name: "with-tool", tools: { greet } };
 
     expectTypeOf(agent.tools).toHaveProperty("greet");
   });
 
   test("required fields are present", () => {
-    const agent: AgentDef = {
-      name: "defaults",
-      systemPrompt: "Be helpful.",
-      greeting: "Hello!",
-      maxSteps: 5,
-      tools: {},
-    };
+    const agent: AgentDef = { ...baseAgent, name: "defaults", tools: {} };
     expectTypeOf(agent.systemPrompt).toBeString();
     expectTypeOf(agent.greeting).toBeString();
     expectTypeOf(agent.tools).toBeObject();

package/sdk/types.ts

@@ -8,6 +8,7 @@ import type { Kv } from "./kv.ts";
 import type {
   KvProvider,
   LlmProvider,
+  S2sProvider,
   SttProvider,
   TtsProvider,
   VectorProvider,
@@ -242,6 +243,12 @@ export type AgentDef<S = Record<string, unknown>> = {
    * 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/ws-upgrade.test.ts

@@ -5,44 +5,45 @@ import { parseWsUpgradeParams } from "./ws-upgrade.ts";
 
 describe("parseWsUpgradeParams", () => {
   test("returns defaults for URL with no query params", () => {
-    const result = parseWsUpgradeParams("/websocket");
-    expect(result).toEqual({ resumeFrom: undefined, skipGreeting: false });
+    expect(parseWsUpgradeParams("/websocket")).toEqual({
+      resumeFrom: undefined,
+      skipGreeting: false,
+    });
   });
 
   test("extracts sessionId and sets skipGreeting", () => {
-    const result = parseWsUpgradeParams("/ws?sessionId=abc-123");
-    expect(result.resumeFrom).toBe("abc-123");
-    expect(result.skipGreeting).toBe(true);
+    expect(parseWsUpgradeParams("/ws?sessionId=abc-123")).toEqual({
+      resumeFrom: "abc-123",
+      skipGreeting: true,
+    });
   });
 
   test("sets skipGreeting when resume param is present", () => {
-    const result = parseWsUpgradeParams("/ws?resume=1");
-    expect(result.resumeFrom).toBeUndefined();
-    expect(result.skipGreeting).toBe(true);
+    expect(parseWsUpgradeParams("/ws?resume=1")).toEqual({
+      resumeFrom: undefined,
+      skipGreeting: true,
+    });
   });
 
   test("sessionId takes precedence for resumeFrom", () => {
-    const result = parseWsUpgradeParams("/ws?resume=1&sessionId=sess-42");
-    expect(result.resumeFrom).toBe("sess-42");
-    expect(result.skipGreeting).toBe(true);
-  });
-
-  test("handles URL with no query string", () => {
-    const result = parseWsUpgradeParams("/websocket");
-    expect(result.resumeFrom).toBeUndefined();
-    expect(result.skipGreeting).toBe(false);
+    expect(parseWsUpgradeParams("/ws?resume=1&sessionId=sess-42")).toEqual({
+      resumeFrom: "sess-42",
+      skipGreeting: true,
+    });
   });
 
   test("handles full URL with query params", () => {
-    const result = parseWsUpgradeParams("ws://localhost:3000/websocket?sessionId=s1");
-    expect(result.resumeFrom).toBe("s1");
-    expect(result.skipGreeting).toBe(true);
+    expect(parseWsUpgradeParams("ws://localhost:3000/websocket?sessionId=s1")).toEqual({
+      resumeFrom: "s1",
+      skipGreeting: true,
+    });
   });
 
   test("handles empty sessionId", () => {
-    const result = parseWsUpgradeParams("/ws?sessionId=");
     // Empty string from URLSearchParams.get is truthy for ?? check
-    expect(result.resumeFrom).toBe("");
-    expect(result.skipGreeting).toBe(true);
+    expect(parseWsUpgradeParams("/ws?sessionId=")).toEqual({
+      resumeFrom: "",
+      skipGreeting: true,
+    });
   });
 });

package/sdk/ws-upgrade.ts

@@ -5,9 +5,8 @@ export function parseWsUpgradeParams(rawUrl: string): {
   resumeFrom?: string;
   skipGreeting: boolean;
 } {
-  const search = rawUrl.includes("?") ? (rawUrl.split("?")[1] ?? "") : "";
-  const params = new URLSearchParams(search);
+  const params = new URLSearchParams(rawUrl.split("?")[1] ?? "");
   const resumeFrom = params.get("sessionId") ?? undefined;
-  const skipGreeting = params.has("resume") || resumeFrom !== undefined;
+  const skipGreeting = resumeFrom !== undefined || params.has("resume");
   return resumeFrom !== undefined ? { resumeFrom, skipGreeting } : { skipGreeting };
 }

package/tsdown.config.ts

@@ -2,17 +2,14 @@ import { readFileSync } from "node:fs";
 import { defineConfig } from "tsdown";
 
 // Derive build entries from package.json exports so they can never drift.
-const pkg = JSON.parse(readFileSync("package.json", "utf-8"));
-const entry = [
-  ...new Set(
-    Object.values(pkg.exports as Record<string, Record<string, string>>)
-      .filter(
-        (v): v is { "@dev/source": string } =>
-          typeof v === "object" && typeof v["@dev/source"] === "string",
-      )
-      .map((v) => v["@dev/source"].replace(/^\.\//, "")),
-  ),
-];
+const pkg = JSON.parse(readFileSync("package.json", "utf-8")) as {
+  exports: Record<string, Record<string, string>>;
+};
+const sources = Object.values(pkg.exports)
+  .map((v) => v?.["@dev/source"])
+  .filter((s): s is string => typeof s === "string")
+  .map((s) => s.replace(/^\.\//, ""));
+const entry = [...new Set(sources)];
 
 export default defineConfig({
   entry,