@alexkroman1/aai 1.0.6 → 1.2.0

package/sdk/protocol.test.ts

@@ -1,15 +1,18 @@
-import { describe, expect, test } from "vitest";
+import fc from "fast-check";
+import { describe, expect, expectTypeOf, test } from "vitest";
+import { z } from "zod";
 import {
   DEFAULT_STT_SAMPLE_RATE,
   DEFAULT_TTS_SAMPLE_RATE,
   TOOL_EXECUTION_TIMEOUT_MS,
 } from "./constants.ts";
+import type { ClientEvent, ServerMessage } from "./protocol.ts";
 import {
-  AUDIO_FORMAT,
   buildReadyConfig,
   ClientEventSchema,
   ClientMessageSchema,
   KvRequestSchema,
+  lenientParse,
   SessionErrorCodeSchema,
 } from "./protocol.ts";
 
@@ -22,10 +25,6 @@ describe("protocol constants", () => {
     expect(DEFAULT_TTS_SAMPLE_RATE).toBe(24_000);
   });
 
-  test('AUDIO_FORMAT is "pcm16"', () => {
-    expect(AUDIO_FORMAT).toBe("pcm16");
-  });
-
   test("TOOL_EXECUTION_TIMEOUT_MS is 30000", () => {
     expect(TOOL_EXECUTION_TIMEOUT_MS).toBe(30_000);
   });
@@ -91,32 +90,23 @@ describe("SessionErrorCodeSchema", () => {
 
 describe("ClientEventSchema", () => {
   test("accepts speech_started", () => {
-    const result = ClientEventSchema.safeParse({ type: "speech_started" });
-    expect(result.success).toBe(true);
+    expect({ type: "speech_started" }).toBeValidClientEvent();
   });
 
   test("accepts user_transcript", () => {
-    const result = ClientEventSchema.safeParse({
-      type: "user_transcript",
-      text: "hello world",
-    });
-    expect(result.success).toBe(true);
+    expect({ type: "user_transcript", text: "hello world" }).toBeValidClientEvent();
   });
 
   test("accepts error event", () => {
-    const result = ClientEventSchema.safeParse({
+    expect({
       type: "error",
       code: "internal",
       message: "something went wrong",
-    });
-    expect(result.success).toBe(true);
+    }).toBeValidClientEvent();
   });
 
   test("rejects unknown type", () => {
-    const result = ClientEventSchema.safeParse({
-      type: "unknown_event_type",
-    });
-    expect(result.success).toBe(false);
+    expect({ type: "unknown_event_type" }).not.toBeValidClientEvent();
   });
 });
 
@@ -156,7 +146,7 @@ describe("buildReadyConfig", () => {
   test("builds config from sample rates", () => {
     const config = buildReadyConfig({ inputSampleRate: 16_000, outputSampleRate: 24_000 });
     expect(config).toEqual({
-      audioFormat: AUDIO_FORMAT,
+      audioFormat: "pcm16",
       sampleRate: 16_000,
       ttsSampleRate: 24_000,
     });
@@ -168,3 +158,99 @@ describe("buildReadyConfig", () => {
     expect(config.ttsSampleRate).toBe(48_000);
   });
 });
+
+// ── Property-based tests ─────────────────────────────────────────────────
+
+describe("property: lenientParse", () => {
+  test("never throws on arbitrary input", () => {
+    fc.assert(
+      fc.property(fc.anything(), (input) => {
+        const result = lenientParse(ClientEventSchema, input);
+        expect(result).toHaveProperty("ok");
+      }),
+    );
+  });
+
+  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({
+      type: fc.constant("user_transcript" as const),
+      text: fc.string(),
+    });
+
+    const errorEventArb = fc.record({
+      type: fc.constant("error" as const),
+      code: fc.constantFrom(...errorCodes),
+      message: fc.string(),
+    });
+
+    const clientEventArb = fc.oneof(speechStartedArb, userTranscriptArb, errorEventArb);
+
+    fc.assert(
+      fc.property(clientEventArb, (event) => {
+        const result = lenientParse(ClientEventSchema, event);
+        expect(result.ok).toBe(true);
+      }),
+    );
+  });
+
+  test("objects without type field are malformed", () => {
+    const noTypeArb = fc.object().filter((obj) => !("type" in obj));
+
+    fc.assert(
+      fc.property(noTypeArb, (obj) => {
+        const result = lenientParse(ClientEventSchema, obj);
+        expect(result.ok).toBe(false);
+        if (!result.ok) {
+          expect(result.malformed).toBe(true);
+        }
+      }),
+    );
+  });
+});
+
+describe("protocol type contracts", () => {
+  test("ClientEvent narrows on user_transcript discriminant", () => {
+    type UserTranscript = Extract<ClientEvent, { type: "user_transcript" }>;
+    expectTypeOf<UserTranscript>().toHaveProperty("text");
+    expectTypeOf<UserTranscript["text"]>().toBeString();
+  });
+
+  test("ClientEvent narrows on tool_call discriminant", () => {
+    type ToolCall = Extract<ClientEvent, { type: "tool_call" }>;
+    expectTypeOf<ToolCall>().toHaveProperty("toolCallId");
+    expectTypeOf<ToolCall>().toHaveProperty("toolName");
+    expectTypeOf<ToolCall>().toHaveProperty("args");
+  });
+
+  test("ClientEvent narrows on error discriminant", () => {
+    type ErrorEvent = Extract<ClientEvent, { type: "error" }>;
+    expectTypeOf<ErrorEvent>().toHaveProperty("code");
+    expectTypeOf<ErrorEvent>().toHaveProperty("message");
+  });
+
+  test("ServerMessage has type property on all variants", () => {
+    expectTypeOf<ServerMessage>().toHaveProperty("type");
+  });
+
+  test("lenientParse returns ok/error discriminated union", () => {
+    const schema = z.object({ type: z.literal("test"), value: z.number() });
+    type Parsed = z.infer<typeof schema>;
+    const result = lenientParse(schema, {});
+    expectTypeOf(result).toEqualTypeOf<
+      { ok: true; data: Parsed } | { ok: false; malformed: boolean; error: string }
+    >();
+  });
+});

package/sdk/protocol.ts

@@ -14,7 +14,7 @@ import { MAX_TOOL_RESULT_CHARS } from "./constants.ts";
  *
  * All audio frames are 16-bit signed PCM, little-endian, mono.
  */
-export const AUDIO_FORMAT = "pcm16";
+const AUDIO_FORMAT = "pcm16";
 
 /**
  * Minimal envelope schema for two-phase message parsing.
@@ -24,7 +24,7 @@ export const AUDIO_FORMAT = "pcm16";
  * *unrecognised* type (safe to ignore during rolling upgrades) or genuinely
  * malformed (should be warned about).
  */
-export const MessageEnvelopeSchema = z.object({ type: z.string() }).passthrough();
+const MessageEnvelopeSchema = z.object({ type: z.string() }).passthrough();
 
 /**
  * Two-phase message parse: tries the strict schema first, then falls back to
@@ -128,6 +128,11 @@ export const ClientEventSchema = z.discriminatedUnion("type", [
   ev("reset"),
   ev("idle_timeout"),
   z.object({ type: z.literal("error"), code: SessionErrorCodeSchema, message: z.string() }),
+  z.object({
+    type: z.literal("custom_event"),
+    event: z.string().min(1),
+    data: z.unknown(),
+  }),
 ]);
 
 /** Discriminated union of all server→client session events. */
@@ -151,9 +156,6 @@ export interface ClientSink {
 
 // ─── WebSocket message types ────────────────────────────────────────────────
 
-/** Supported audio formats for the wire protocol. */
-export type AudioFormatId = "pcm16";
-
 /** Zod schema for {@link ReadyConfig}. */
 export const ReadyConfigSchema = z.object({
   audioFormat: z.enum(["pcm16"]),
@@ -211,13 +213,3 @@ export function buildReadyConfig(s2sConfig: {
     ttsSampleRate: s2sConfig.outputSampleRate,
   };
 }
-
-// ─── Worker RPC interfaces ─────────────────────────────────────────────────
-
-/** Zod schema for {@link TurnConfig}. */
-export const TurnConfigSchema = z.object({
-  maxSteps: z.number().int().positive().optional(),
-});
-
-/** Combined turn configuration resolved from the worker before a turn starts. */
-export type TurnConfig = z.infer<typeof TurnConfigSchema>;

package/sdk/schema-alignment.test.ts

@@ -10,12 +10,7 @@
 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,
-  type TurnConfig,
-  TurnConfigSchema,
-} from "./protocol.ts";
+import { type ReadyConfig, ReadyConfigSchema } from "./protocol.ts";
 import { type BuiltinTool, BuiltinToolSchema, type ToolChoice, ToolChoiceSchema } from "./types.ts";
 
 // ── AgentConfigSchema ────────────────────────────────────────────────────
@@ -105,27 +100,6 @@ describe("ToolSchemaSchema", () => {
   });
 });
 
-// ── TurnConfigSchema ─────────────────────────────────────────────────────
-
-describe("TurnConfigSchema", () => {
-  test("accepts empty config", () => {
-    expect(TurnConfigSchema.parse({})).toEqual({});
-  });
-
-  test("accepts full config", () => {
-    const full: TurnConfig = { maxSteps: 3 };
-    expect(TurnConfigSchema.parse(full)).toEqual(full);
-  });
-
-  test("rejects non-positive maxSteps", () => {
-    expect(TurnConfigSchema.safeParse({ maxSteps: 0 }).success).toBe(false);
-  });
-
-  test("type derived from schema matches TurnConfig", () => {
-    expectTypeOf<z.infer<typeof TurnConfigSchema>>().toEqualTypeOf<TurnConfig>();
-  });
-});
-
 // ── ReadyConfigSchema ────────────────────────────────────────────────────
 
 describe("ReadyConfigSchema", () => {

package/sdk/schema-shapes.test.ts

@@ -0,0 +1,103 @@
+// 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 {
+  ClientEventSchema,
+  ClientMessageSchema,
+  KvDelSchema,
+  KvGetSchema,
+  KvSetSchema,
+  ReadyConfigSchema,
+  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[]> {
+  const result: Record<string, string[]> = {};
+  for (const option of schema.options) {
+    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 discriminatorValue = Array.isArray(raw) ? raw[0] : raw;
+    const key = String(discriminatorValue ?? "unknown");
+    result[key] = Object.keys(option.shape).sort();
+  }
+  return result;
+}
+
+// ── Protocol schemas ─────────────────────────────────────────────────────
+
+describe("protocol schema shapes", () => {
+  test("ClientEventSchema option shapes", () => {
+    expect(discriminatedUnionShapes(ClientEventSchema)).toMatchSnapshot();
+  });
+
+  test("ServerMessageSchema option shapes", () => {
+    expect(discriminatedUnionShapes(ServerMessageSchema)).toMatchSnapshot();
+  });
+
+  test("ClientMessageSchema option shapes", () => {
+    expect(discriminatedUnionShapes(ClientMessageSchema)).toMatchSnapshot();
+  });
+
+  test("ReadyConfigSchema shape", () => {
+    expect(shapeKeys(ReadyConfigSchema)).toMatchSnapshot();
+  });
+
+  test("KvGetSchema shape", () => {
+    expect(shapeKeys(KvGetSchema)).toMatchSnapshot();
+  });
+
+  test("KvSetSchema shape", () => {
+    expect(shapeKeys(KvSetSchema)).toMatchSnapshot();
+  });
+
+  test("KvDelSchema shape", () => {
+    expect(shapeKeys(KvDelSchema)).toMatchSnapshot();
+  });
+});
+
+// ── Manifest schemas ──────────────────────────────────────────────────────
+
+describe("manifest schema shapes", () => {
+  test("AgentConfigSchema shape", () => {
+    expect(shapeKeys(AgentConfigSchema)).toMatchSnapshot();
+  });
+
+  test("ToolSchemaSchema shape", () => {
+    expect(shapeKeys(ToolSchemaSchema)).toMatchSnapshot();
+  });
+});

package/sdk/tsconfig.json

@@ -8,5 +8,5 @@
     "tsBuildInfoFile": "../../../.tsbuildinfo/aai-sdk.tsbuildinfo"
   },
   "include": ["./**/*.ts"],
-  "exclude": ["**/*.test.ts", "**/*.test-d.ts"]
+  "exclude": ["**/*.test.ts", "**/*.test-d.ts", "**/_test-*.ts"]
 }

package/sdk/types.test.ts

@@ -1,4 +1,7 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, expectTypeOf, test } from "vitest";
+import { z } from "zod";
+import type { AgentDef, Kv, ToolDef } from "../index.ts";
+import { agent, tool } from "../index.ts";
 import { DEFAULT_GREETING, DEFAULT_SYSTEM_PROMPT } from "./types.ts";
 
 describe("constants", () => {
@@ -12,3 +15,55 @@ describe("constants", () => {
     expect(DEFAULT_GREETING.length).toBeGreaterThan(0);
   });
 });
+
+describe("type contracts", () => {
+  test("agent() returns AgentDef", () => {
+    const def = agent({ name: "test" });
+    expectTypeOf(def).toEqualTypeOf<AgentDef>();
+  });
+
+  test("tool() infers parameter type from Zod schema", () => {
+    const params = z.object({ city: z.string() });
+    const t = tool({
+      description: "weather",
+      parameters: params,
+      execute: (args) => {
+        expectTypeOf(args).toEqualTypeOf<{ city: string }>();
+        return "ok";
+      },
+    });
+    expectTypeOf(t).toMatchTypeOf<ToolDef<typeof params>>();
+  });
+
+  test("tool() works without parameters", () => {
+    const t = tool({ description: "no params", execute: () => "ok" });
+    expectTypeOf(t).toMatchTypeOf<ToolDef>();
+  });
+
+  test("agent() accepts tools record", () => {
+    const t = tool({
+      description: "echo",
+      parameters: z.object({ msg: z.string() }),
+      execute: ({ msg }) => msg,
+    });
+    const def = agent({ name: "with-tools", tools: { echo: t } });
+    expectTypeOf(def).toEqualTypeOf<AgentDef>();
+  });
+
+  test("Kv.get returns Promise<unknown> by default", () => {
+    expectTypeOf<Kv["get"]>().returns.toEqualTypeOf<Promise<unknown>>();
+  });
+
+  test("Kv.set accepts various value types", () => {
+    expectTypeOf<Kv["set"]>().toBeCallableWith("key", "string-value");
+    expectTypeOf<Kv["set"]>().toBeCallableWith("key", 42);
+    expectTypeOf<Kv["set"]>().toBeCallableWith("key", { nested: true });
+    expectTypeOf<Kv["set"]>().returns.toEqualTypeOf<Promise<void>>();
+  });
+
+  test("Kv.delete accepts string or string[]", () => {
+    expectTypeOf<Kv["delete"]>().toBeCallableWith("single-key");
+    expectTypeOf<Kv["delete"]>().toBeCallableWith(["key1", "key2"]);
+    expectTypeOf<Kv["delete"]>().returns.toEqualTypeOf<Promise<void>>();
+  });
+});

package/sdk/types.ts

@@ -83,6 +83,8 @@ export type ToolContext<S = Record<string, unknown>> = {
   messages: readonly Message[];
   /** Unique identifier for the current session. Useful for correlating logs across concurrent sessions. */
   sessionId: string;
+  /** Push a custom event to the connected browser client. Fire-and-forget. */
+  send(event: string, data: unknown): void;
 };
 
 /**

package/sdk/ws-upgrade.test.ts

@@ -1,45 +1,45 @@
 // Copyright 2025 the AAI authors. MIT license.
 
-import { describe, expect, it } from "vitest";
+import { describe, expect, test } from "vitest";
 import { parseWsUpgradeParams } from "./ws-upgrade.ts";
 
 describe("parseWsUpgradeParams", () => {
-  it("returns defaults for URL with no query params", () => {
+  test("returns defaults for URL with no query params", () => {
     const result = parseWsUpgradeParams("/websocket");
     expect(result).toEqual({ resumeFrom: undefined, skipGreeting: false });
   });
 
-  it("extracts sessionId and sets skipGreeting", () => {
+  test("extracts sessionId and sets skipGreeting", () => {
     const result = parseWsUpgradeParams("/ws?sessionId=abc-123");
     expect(result.resumeFrom).toBe("abc-123");
     expect(result.skipGreeting).toBe(true);
   });
 
-  it("sets skipGreeting when resume param is present", () => {
+  test("sets skipGreeting when resume param is present", () => {
     const result = parseWsUpgradeParams("/ws?resume=1");
     expect(result.resumeFrom).toBeUndefined();
     expect(result.skipGreeting).toBe(true);
   });
 
-  it("sessionId takes precedence for resumeFrom", () => {
+  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);
   });
 
-  it("handles URL with no query string", () => {
+  test("handles URL with no query string", () => {
     const result = parseWsUpgradeParams("/websocket");
     expect(result.resumeFrom).toBeUndefined();
     expect(result.skipGreeting).toBe(false);
   });
 
-  it("handles full URL with query params", () => {
+  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);
   });
 
-  it("handles empty sessionId", () => {
+  test("handles empty sessionId", () => {
     const result = parseWsUpgradeParams("/ws?sessionId=");
     // Empty string from URLSearchParams.get is truthy for ?? check
     expect(result.resumeFrom).toBe("");

package/tsconfig.build.json

@@ -10,5 +10,12 @@
     "allowImportingTsExtensions": false,
     "rewriteRelativeImportExtensions": true
   },
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/_test-utils.ts", "vitest*.config.ts"]
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.test-d.ts",
+    "**/_test-*.ts",
+    "vitest*.config.ts"
+  ]
 }

package/tsconfig.json

@@ -3,7 +3,7 @@
   "compilerOptions": {
     "incremental": true,
     "tsBuildInfoFile": "../../.tsbuildinfo/aai.tsbuildinfo",
-    "types": ["node"]
+    "types": ["node", "vitest/globals"]
   },
   "include": ["./**/*.ts"],
   "exclude": ["node_modules", "dist", "**/__snapshots__"]

package/vitest.config.ts

@@ -13,5 +13,6 @@ export default defineConfig({
       "node_modules",
       "dist",
     ],
+    setupFiles: ["./sdk/_test-matchers.ts"],
   },
 });

package/dist/system-prompt-nik_iavo.js

@@ -1,92 +0,0 @@
-import { i as ToolChoiceSchema, r as DEFAULT_SYSTEM_PROMPT, t as BuiltinToolSchema } from "./types-Cfx_4QDK.js";
-import { z } from "zod";
-//#region sdk/_internal-types.ts
-/**
-* Zod schema for serializable agent configuration sent over the wire.
-*
-* This is the JSON-safe subset of the agent definition that can be
-* transmitted between the worker and the host process via structured clone.
-*/
-const AgentConfigSchema = z.object({
-	name: z.string().min(1),
-	systemPrompt: z.string(),
-	greeting: z.string(),
-	sttPrompt: z.string().optional(),
-	maxSteps: z.number().int().positive().optional(),
-	toolChoice: ToolChoiceSchema.optional(),
-	builtinTools: z.array(BuiltinToolSchema).readonly().optional(),
-	idleTimeoutMs: z.number().nonnegative().optional()
-});
-/** Extract the serializable {@link AgentConfig} subset from a source object. */
-function toAgentConfig(src) {
-	const config = {
-		name: src.name,
-		systemPrompt: src.systemPrompt,
-		greeting: src.greeting
-	};
-	if (src.sttPrompt !== void 0) config.sttPrompt = src.sttPrompt;
-	if (src.maxSteps !== void 0) config.maxSteps = src.maxSteps;
-	if (src.toolChoice !== void 0) config.toolChoice = src.toolChoice;
-	if (src.builtinTools) config.builtinTools = [...src.builtinTools];
-	if (src.idleTimeoutMs !== void 0) config.idleTimeoutMs = src.idleTimeoutMs;
-	return config;
-}
-/**
-* Zod schema for serialized tool definitions sent over the wire.
-*
-* `parameters` must be a valid JSON Schema object (with `type`, `properties`,
-* etc.) — the Vercel AI SDK wraps it via `jsonSchema()`.
-*/
-const ToolSchemaSchema = z.object({
-	name: z.string().min(1),
-	description: z.string().min(1),
-	parameters: z.record(z.string(), z.unknown())
-});
-/** Empty Zod object schema used as default when tools have no parameters. */
-const EMPTY_PARAMS = z.object({});
-/**
-* Convert agent tool definitions to JSON Schema format for wire transport.
-*
-* Transforms the Zod-based `parameters` of each tool into a plain JSON Schema
-* object suitable for structured clone / JSON serialization.
-*/
-function agentToolsToSchemas(tools) {
-	return Object.entries(tools).map(([name, def]) => ({
-		name,
-		description: def.description,
-		parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
-	}));
-}
-//#endregion
-//#region sdk/system-prompt.ts
-function getFormattedDate() {
-	return (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric"
-	});
-}
-const VOICE_RULES = "\n\nCRITICAL OUTPUT RULES — you MUST follow these for EVERY response:\nYour response will be spoken aloud by a TTS system and displayed as plain text.\n- NEVER use markdown: no **, no *, no _, no #, no `, no [](), no ---\n- NEVER use bullet points (-, *, •) or numbered lists (1., 2.)\n- NEVER use code blocks or inline code\n- NEVER mention tools, search, APIs, or technical failures to the user. If a tool returns no results, just answer naturally without explaining why.\n- Write exactly as you would say it out loud to a friend\n- Use short conversational sentences. To list things, say \"First,\" \"Next,\" \"Finally,\"\n- Keep responses concise — 1 to 3 sentences max";
-/**
-* Build the system prompt sent to the LLM from the agent configuration.
-*
-* Assembles the default system prompt, today's date, agent-specific instructions,
-* and optional sections for tool usage preamble and voice output rules.
-*
-* @param config - The serializable agent configuration (name, systemPrompt, etc.).
-* @param opts.hasTools - When `true`, appends a preamble instructing the LLM to
-*   speak a brief phrase before each tool call to fill silence.
-* @param opts.voice - When `true`, appends strict voice-specific output rules
-*   (no markdown, no bullet points, conversational tone, concise responses).
-* @returns The assembled system prompt string.
-*/
-function buildSystemPrompt(config, opts) {
-	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 guidance = opts.toolGuidance && opts.toolGuidance.length > 0 ? `\n\nBuilt-in Tool Usage:\n${opts.toolGuidance.join("\n")}` : "";
-	return DEFAULT_SYSTEM_PROMPT + `\n\nToday's date is ${getFormattedDate()}.` + agentInstructions + toolPreamble + guidance + (opts.voice ? VOICE_RULES : "");
-}
-//#endregion
-export { agentToolsToSchemas as a, ToolSchemaSchema as i, AgentConfigSchema as n, toAgentConfig as o, EMPTY_PARAMS as r, buildSystemPrompt as t };