@alexkroman1/aai 0.10.3 → 0.10.4

package/dist/direct-executor.d.ts

@@ -1,69 +1,128 @@
 /**
- * Direct tool execution for self-hosted mode.
+ * Agent runtime — the execution engine for voice agents.
  *
- * In self-hosted mode, agent code is trusted (you're running your own code).
- * Tools execute directly in-process — no sandbox, no RPC.
+ * {@link createRuntime} builds the single execution engine used by both
+ * self-hosted servers and the platform sandbox. It wires up tool execution,
+ * lifecycle hooks, and session management.
  */
-import { type ToolSchema } from "./_internal-types.ts";
+import { type ExecuteTool, type ToolSchema } from "./_internal-types.ts";
+import { type AgentHooks } from "./hooks.ts";
 import type { Kv } from "./kv.ts";
 import type { ClientSink } from "./protocol.ts";
+import { type ReadyConfig } from "./protocol.ts";
 import type { Logger, S2SConfig } from "./runtime.ts";
 import type { CreateS2sWebSocket } from "./s2s.ts";
-import { type HookInvoker, type Session } from "./session.ts";
-import type { AgentDef } from "./types.ts";
-import type { VectorStore } from "./vector.ts";
-import type { ExecuteTool } from "./worker-entry.ts";
+import { type Session } from "./session.ts";
+import type { AgentDef, Message, ToolDef } from "./types.ts";
+import { type SessionWebSocket } from "./ws-handler.ts";
+export type { ExecuteTool } from "./_internal-types.ts";
+export type ExecuteToolCallOptions = {
+    tool: ToolDef;
+    env: Readonly<Record<string, string>>;
+    state?: Record<string, unknown>;
+    sessionId?: string | undefined;
+    kv?: Kv | undefined;
+    messages?: readonly Message[] | undefined;
+    logger?: Logger | undefined;
+    fetch?: typeof globalThis.fetch | undefined;
+};
+export declare function executeToolCall(name: string, args: Readonly<Record<string, unknown>>, options: ExecuteToolCallOptions): Promise<string>;
+/** Per-session options passed to {@link AgentRuntime.startSession}. */
+export type SessionStartOptions = {
+    skipGreeting?: boolean;
+    resumeFrom?: string;
+    logContext?: Record<string, string>;
+    onOpen?: () => void;
+    onClose?: () => void;
+};
 /**
- * Configuration for creating a direct (in-process) tool executor for self-hosted mode.
+ * Common interface for agent runtimes.
  *
- * In self-hosted mode, agent tools run directly in the Node process — no sandbox or
- * RPC layer. This type configures the agent, environment, stores, and logging.
+ * Implemented by {@link createRuntime} and the platform sandbox.
  */
-export type DirectExecutorOptions = {
+export type AgentRuntime = {
+    startSession(ws: SessionWebSocket, opts?: SessionStartOptions): void;
+    shutdown(): Promise<void>;
+    readonly readyConfig: ReadyConfig;
+};
+/**
+ * Configuration for {@link createRuntime}.
+ *
+ * Configures the agent, environment, KV store, logging, and S2S connection.
+ *
+ * @public
+ */
+export type RuntimeOptions = {
     agent: AgentDef<any>;
     env: Record<string, string>;
     kv?: Kv | undefined;
-    vector?: VectorStore | undefined;
-    /** Vector search callback. Accepts a query and topK, returns a JSON string.
-     *  Used as an RPC proxy in platform mode; in self-hosted mode the default
-     *  uses the local `vector` store directly. */
-    vectorSearch?: ((query: string, topK: number) => Promise<string>) | undefined;
     /** Custom WebSocket factory for the S2S connection (useful for testing). */
     createWebSocket?: CreateS2sWebSocket | undefined;
     logger?: Logger | undefined;
     s2sConfig?: S2SConfig | undefined;
+    /**
+     * Timeout in ms for `session.start()` (S2S connection setup).
+     * Defaults to 10 000 (10 s).
+     */
+    sessionStartTimeoutMs?: number | undefined;
+    /**
+     * Maximum time in milliseconds to wait for sessions to stop during
+     * {@link AgentRuntime.shutdown | shutdown()}. Defaults to `30_000` (30 s).
+     */
+    shutdownTimeoutMs?: number | undefined;
+    /**
+     * Override tool execution. When provided, `createRuntime` skips building
+     * in-process tool definitions and uses this function instead. Used by the
+     * platform sandbox to RPC tool calls to the isolate.
+     */
+    executeTool?: ExecuteTool | undefined;
+    /**
+     * Override lifecycle hooks. When provided, `createRuntime` skips building
+     * in-process hooks and uses these instead. Used by the platform sandbox
+     * to RPC hook calls to the isolate.
+     */
+    hooks?: AgentHooks | undefined;
+    /**
+     * Override tool schemas sent to the S2S API. Required when `executeTool`
+     * is provided (the host doesn't have the tool definitions to derive schemas).
+     */
+    toolSchemas?: ToolSchema[] | undefined;
 };
 /**
- * The direct (in-process) executor returned by {@link createDirectExecutor}.
+ * The agent runtime returned by {@link createRuntime}.
  *
- * Provides tool execution, hook invocation, tool schemas for the S2S API,
- * and a factory for creating voice sessions.
+ * Satisfies {@link AgentRuntime} for use by transport code, and also exposes
+ * lower-level helpers (`executeTool`, `hooks`, `toolSchemas`,
+ * `createSession`) for testing and advanced usage.
+ *
+ * @public
  */
-export type DirectExecutor = {
+export type Runtime = AgentRuntime & {
     /** Execute a named tool with the given args, returning a JSON result string. */
     executeTool: ExecuteTool;
-    /** Hook invoker wired to the agent's lifecycle hooks and middleware. */
-    hookInvoker: HookInvoker;
+    /** Hookable instance wired to the agent's lifecycle hooks. */
+    hooks: AgentHooks;
     /** Tool schemas registered with the S2S API (custom + built-in). */
     toolSchemas: ToolSchema[];
-    /** Create a new voice session for a connected client. */
+    /** Create a new voice session for a connected client (lower-level than startSession). */
     createSession(opts: {
         id: string;
         agent: string;
         client: ClientSink;
         skipGreeting?: boolean;
-        /** Old session ID to resume from (loads persisted state from KV). */
         resumeFrom?: string;
     }): Session;
 };
 /**
- * Create a direct (in-process) tool executor and hook invoker for an agent.
+ * Create an agent runtime — the execution engine for a voice agent.
  *
  * Merges built-in and custom tool definitions, builds tool schemas for the
- * S2S API, and wires up middleware and lifecycle hooks.
+ * S2S API, and wires up lifecycle hooks.
+ *
+ * @param opts - Runtime configuration. See {@link RuntimeOptions}.
+ * @returns A {@link Runtime} with tool execution, hook invocation,
+ *   schemas, and session management.
  *
- * @param opts - Executor configuration. See {@link DirectExecutorOptions}.
- * @returns A {@link DirectExecutor} with tool execution, hook invocation,
- *   schemas, and session creation.
+ * @public
  */
-export declare function createDirectExecutor(opts: DirectExecutorOptions): DirectExecutor;
+export declare function createRuntime(opts: RuntimeOptions): Runtime;

package/dist/hooks.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Hookable-based lifecycle hook system.
+ *
+ * Provides a unified hook registry built on {@link https://github.com/unjs/hookable | hookable}.
+ * Lifecycle hooks (connect, disconnect, turn, error, resolveTurnConfig) are
+ * registered on a single `Hookable<AgentHookMap>` instance.
+ */
+import { type Hookable } from "hookable";
+import type { AgentDef, HookContext } from "./types.ts";
+/**
+ * Map of all agent hook names to their function signatures.
+ *
+ * All hooks are typed as void-returning for hookable compatibility.
+ * Value-returning hooks (resolveTurnConfig) are invoked via
+ * {@link callHookWith} with a custom caller that extracts the return value.
+ */
+export interface AgentHookMap {
+    connect: (sessionId: string, timeoutMs?: number) => void | Promise<void>;
+    disconnect: (sessionId: string, timeoutMs?: number) => void | Promise<void>;
+    turn: (sessionId: string, text: string, timeoutMs?: number) => void | Promise<void>;
+    error: (sessionId: string, error: {
+        message: string;
+    }, timeoutMs?: number) => void | Promise<void>;
+    resolveTurnConfig: (sessionId: string, timeoutMs?: number) => void | Promise<void>;
+}
+/** A hookable instance typed to the agent hook map. */
+export type AgentHooks = Hookable<AgentHookMap>;
+/**
+ * Call the resolveTurnConfig hook.
+ * Returns null when no handler is registered.
+ */
+export declare function callResolveTurnConfig(hooks: AgentHooks | undefined, sessionId: string, timeoutMs?: number): Promise<{
+    maxSteps?: number;
+} | null>;
+/**
+ * Create an {@link AgentHooks} instance from an agent definition.
+ *
+ * Registers lifecycle hooks from the agent's `onConnect`, `onDisconnect`,
+ * `onTurn`, `onError` callbacks.
+ */
+export declare function createAgentHooks(opts: {
+    agent: AgentDef<any>;
+    makeCtx: (sessionId: string) => HookContext;
+}): AgentHooks;

package/dist/hooks.js

@@ -0,0 +1,58 @@
+import { createHooks } from "hookable";
+//#region hooks.ts
+/**
+* Hookable-based lifecycle hook system.
+*
+* Provides a unified hook registry built on {@link https://github.com/unjs/hookable | hookable}.
+* Lifecycle hooks (connect, disconnect, turn, error, resolveTurnConfig) are
+* registered on a single `Hookable<AgentHookMap>` instance.
+*/
+/**
+* Caller that invokes the first registered handler and returns its result.
+* Returns `fallback` when no handlers are registered.
+*/
+function firstResultCaller(fallback) {
+	return async (fns, args) => {
+		if (fns.length === 0) return fallback;
+		return await fns[0](...args) ?? fallback;
+	};
+}
+/**
+* Call the resolveTurnConfig hook.
+* Returns null when no handler is registered.
+*/
+async function callResolveTurnConfig(hooks, sessionId, timeoutMs) {
+	if (!hooks) return null;
+	return hooks.callHookWith(firstResultCaller(null), "resolveTurnConfig", [sessionId, timeoutMs]);
+}
+/**
+* Create an {@link AgentHooks} instance from an agent definition.
+*
+* Registers lifecycle hooks from the agent's `onConnect`, `onDisconnect`,
+* `onTurn`, `onError` callbacks.
+*/
+function createAgentHooks(opts) {
+	const { agent, makeCtx } = opts;
+	const hooks = createHooks();
+	hooks.hook("connect", async (sessionId) => {
+		await agent.onConnect?.(makeCtx(sessionId));
+	});
+	hooks.hook("disconnect", async (sessionId) => {
+		await agent.onDisconnect?.(makeCtx(sessionId));
+	});
+	hooks.hook("turn", async (sessionId, text) => {
+		await agent.onTurn?.(text, makeCtx(sessionId));
+	});
+	hooks.hook("error", async (sessionId, error) => {
+		await agent.onError?.(new Error(error.message), makeCtx(sessionId));
+	});
+	hooks.hook("resolveTurnConfig", (async (sessionId) => {
+		const ctx = makeCtx(sessionId);
+		const maxSteps = typeof agent.maxSteps === "function" ? await agent.maxSteps(ctx) ?? void 0 : void 0;
+		if (maxSteps === void 0) return null;
+		return { maxSteps };
+	}));
+	return hooks;
+}
+//#endregion
+export { callResolveTurnConfig, createAgentHooks };

package/dist/index.d.ts

@@ -20,5 +20,4 @@
  * ```
  */
 export type { Kv, KvEntry, KvListOptions } from "./kv.ts";
-export { type AgentDef, type AgentOptions, type BuiltinTool, createToolFactory, defineAgent, defineTool, type HookContext, type Message, type Middleware, type MiddlewareBlockResult, type StepInfo, type ToolCallInterceptResult, type ToolChoice, type ToolContext, type ToolDef, type ToolResultMap, tool, } from "./types.ts";
-export type { VectorEntry, VectorStore } from "./vector.ts";
+export { type AgentDef, type AgentOptions, type BuiltinTool, defineAgent, defineTool, defineToolFactory, type HookContext, type Message, type ToolChoice, type ToolContext, type ToolDef, type ToolResultMap, tool, } from "./types.ts";

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as createToolFactory, o as defineAgent, s as defineTool } from "./types-D8ZBxTL_.js";
-export { createToolFactory, defineAgent, defineTool, defineTool as tool };
+import { defineAgent, defineTool, defineToolFactory } from "./types.js";
+export { defineAgent, defineTool, defineTool as tool, defineToolFactory };

package/dist/internal.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Internal barrel — re-exports all SDK internals for use by the platform
+ * server (`aai-server`) and CLI. **Not a public API.**
+ *
+ * Consumer packages should import from the top-level `@alexkroman1/aai`
+ * entry, `./server`, `./types`, `./kv`, `./protocol`, or `./testing`.
+ */
+export * from "./_internal-types.ts";
+export * from "./_runtime-conformance.ts";
+export * from "./_utils.ts";
+export * from "./constants.ts";
+export * from "./direct-executor.ts";
+export * from "./hooks.ts";
+export * from "./protocol.ts";
+export * from "./runtime.ts";
+export * from "./s2s.ts";
+export * from "./session.ts";
+export * from "./unstorage-kv.ts";
+export * from "./ws-handler.ts";

package/dist/internal.js

@@ -0,0 +1,209 @@
+import { defineTool } from "./types.js";
+import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_HTML_BYTES, f as MAX_PAGE_CHARS, g as RUN_CODE_TIMEOUT_MS, h as RUN_CODE_MEMORY_MB, i as DEFAULT_SESSION_START_TIMEOUT_MS, l as HOOK_TIMEOUT_MS, m as MAX_VALUE_SIZE, n as DEFAULT_IDLE_TIMEOUT_MS, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_TOOL_RESULT_CHARS, r as DEFAULT_MAX_HISTORY, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP, u as MAX_GLOB_PATTERN_LENGTH } from "./constants-BbAOvKl_.js";
+import { _ as consoleLogger, a as _internals, c as buildSystemPrompt, d as AgentConfigSchema, f as EMPTY_PARAMS, g as DEFAULT_S2S_CONFIG, h as toAgentConfig, i as createUnstorageKv, l as connectS2s, m as agentToolsToSchemas, n as executeToolCall, o as buildCtx, p as ToolSchemaSchema, r as wireSessionSocket, s as createS2sSession, t as createRuntime, u as defaultCreateS2sWebSocket, v as jsonLogger } from "./direct-executor-BfHrDdPL.js";
+import { createSessionStateMap, errorDetail, errorMessage, isReadOnlyFsOp, toolError } from "./_utils.js";
+import { callResolveTurnConfig, createAgentHooks } from "./hooks.js";
+import { AUDIO_FORMAT, ClientEventSchema, ClientMessageSchema, KvRequestSchema, ReadyConfigSchema, ServerMessageSchema, SessionErrorCodeSchema, TurnConfigSchema, buildReadyConfig } from "./protocol.js";
+import { z } from "zod";
+import { describe, expect, test } from "vitest";
+//#region _runtime-conformance.ts
+/**
+* Shared runtime conformance tests.
+*
+* Both the self-hosted direct executor and the platform sandbox must satisfy
+* the same behavioral contract. This module defines that contract as a
+* reusable test suite that can be wired to either runtime.
+*
+* Inspired by Nitro's `testNitro()` pattern: one test fixture, many runtimes.
+*
+* @example Direct executor (unit test)
+* ```ts
+* import { testRuntime } from "./_runtime-conformance.ts";
+*
+* testRuntime("direct", () => {
+*   const exec = createRuntime({ agent: CONFORMANCE_AGENT, env: { MY_VAR: "test-value" } });
+*   return { executeTool: exec.executeTool, hooks: exec.hooks };
+* });
+* ```
+*
+* @example Sandbox (integration test)
+* ```ts
+* import { testRuntime, CONFORMANCE_AGENT_BUNDLE } from "@alexkroman1/aai/runtime-conformance";
+*
+* testRuntime("sandbox", async () => {
+*   // ... start isolate with CONFORMANCE_AGENT_BUNDLE
+*   return { executeTool: buildExecuteTool(...), hooks: buildHookInvoker(...) };
+* });
+* ```
+*/
+/**
+* Agent definition used by the conformance suite (direct executor path).
+*
+* Must be kept in sync with {@link CONFORMANCE_AGENT_BUNDLE}.
+*/
+const CONFORMANCE_AGENT = {
+	name: "conformance-test",
+	instructions: "Conformance test agent.",
+	greeting: "Hello!",
+	maxSteps: 5,
+	state: () => ({
+		count: 0,
+		lastTurn: ""
+	}),
+	tools: {
+		echo: defineTool({
+			description: "Echo input",
+			parameters: z.object({ text: z.string() }),
+			execute: ({ text }) => `echo:${text}`
+		}),
+		get_env: {
+			description: "Get MY_VAR from env",
+			execute: (_args, ctx) => ctx.env.MY_VAR ?? "missing"
+		},
+		get_state: {
+			description: "Get session state",
+			execute: (_args, ctx) => JSON.stringify(ctx.state)
+		},
+		echo_messages: {
+			description: "Return messages as JSON",
+			execute: (_args, ctx) => JSON.stringify(ctx.messages)
+		},
+		kv_roundtrip: defineTool({
+			description: "KV set then get",
+			parameters: z.object({ value: z.string() }),
+			execute: async ({ value }, ctx) => {
+				await ctx.kv.set("test-key", value);
+				const result = await ctx.kv.get("test-key");
+				return `stored:${JSON.stringify(result)}`;
+			}
+		})
+	},
+	onConnect: (ctx) => {
+		ctx.state.count = 1;
+	},
+	onTurn: (text, ctx) => {
+		ctx.state.lastTurn = text;
+	}
+};
+/**
+* JavaScript bundle equivalent of {@link CONFORMANCE_AGENT} for the sandbox
+* isolate path. Must be kept in sync with the AgentDef above.
+*/
+const CONFORMANCE_AGENT_BUNDLE = `
+export default {
+  name: "conformance-test",
+  instructions: "Conformance test agent.",
+  greeting: "Hello!",
+  maxSteps: 5,
+  state: () => ({ count: 0, lastTurn: "" }),
+  tools: {
+    echo: {
+      description: "Echo input",
+      execute(args) { return "echo:" + args.text; },
+    },
+    get_env: {
+      description: "Get MY_VAR from env",
+      execute(_args, ctx) { return ctx.env.MY_VAR ?? "missing"; },
+    },
+    get_state: {
+      description: "Get session state",
+      execute(_args, ctx) { return JSON.stringify(ctx.state); },
+    },
+    echo_messages: {
+      description: "Return messages as JSON",
+      execute(_args, ctx) { return JSON.stringify(ctx.messages); },
+    },
+    kv_roundtrip: {
+      description: "KV set then get",
+      async execute(args, ctx) {
+        await ctx.kv.set("test-key", args.value);
+        const result = await ctx.kv.get("test-key");
+        return "stored:" + JSON.stringify(result);
+      },
+    },
+  },
+  onConnect: (ctx) => { ctx.state.count = 1; },
+  onTurn: (text, ctx) => { ctx.state.lastTurn = text; },
+};
+`;
+/**
+* Run the runtime conformance test suite against a given runtime context.
+*
+* The `getContext` callback is invoked once per test to retrieve the
+* current {@link RuntimeTestContext}. This allows the caller to set up
+* the runtime in a `beforeAll` and return it lazily.
+*
+* All tests assume the runtime was created with {@link CONFORMANCE_AGENT}
+* (or its bundle equivalent) and `env: { MY_VAR: "test-value" }`.
+*/
+function testRuntime(label, getContext) {
+	describe(`runtime conformance: ${label}`, () => {
+		test("executes tool and returns result", async () => {
+			const { executeTool } = getContext();
+			expect(await executeTool("echo", { text: "hello" }, "s1", [])).toBe("echo:hello");
+		});
+		test("tool receives env variables", async () => {
+			const { executeTool } = getContext();
+			expect(await executeTool("get_env", {}, "s1", [])).toBe("test-value");
+		});
+		test("tool receives conversation messages", async () => {
+			const { executeTool } = getContext();
+			const msgs = [{
+				role: "user",
+				content: "hi"
+			}, {
+				role: "assistant",
+				content: "hello"
+			}];
+			const result = await executeTool("echo_messages", {}, "s1", msgs);
+			expect(JSON.parse(result)).toEqual(msgs);
+		});
+		test("KV round-trip through tool context", async () => {
+			const { executeTool } = getContext();
+			expect(await executeTool("kv_roundtrip", { value: "abc" }, "s1", [])).toBe("stored:\"abc\"");
+		});
+		test("session state is initialized from factory", async () => {
+			const { executeTool } = getContext();
+			const result = await executeTool("get_state", {}, "state-init", []);
+			const state = JSON.parse(result);
+			expect(state).toHaveProperty("count", 0);
+			expect(state).toHaveProperty("lastTurn", "");
+		});
+		test("onConnect hook updates session state", async () => {
+			const { executeTool, hooks } = getContext();
+			const sid = "state-connect";
+			await hooks.callHook("connect", sid);
+			const result = await executeTool("get_state", {}, sid, []);
+			expect(JSON.parse(result).count).toBe(1);
+		});
+		test("onTurn hook updates session state", async () => {
+			const { executeTool, hooks } = getContext();
+			const sid = "state-turn";
+			await hooks.callHook("turn", sid, "user said something");
+			const result = await executeTool("get_state", {}, sid, []);
+			expect(JSON.parse(result).lastTurn).toBe("user said something");
+		});
+		test("onConnect resolves without error", async () => {
+			const { hooks } = getContext();
+			await expect(hooks.callHook("connect", "hook-1")).resolves.toBeUndefined();
+		});
+		test("onDisconnect resolves without error", async () => {
+			const { hooks } = getContext();
+			await expect(hooks.callHook("disconnect", "hook-2")).resolves.toBeUndefined();
+		});
+		test("onTurn resolves without error", async () => {
+			const { hooks } = getContext();
+			await expect(hooks.callHook("turn", "hook-3", "test")).resolves.toBeUndefined();
+		});
+		test("onError resolves without error", async () => {
+			const { hooks } = getContext();
+			await expect(hooks.callHook("error", "hook-4", { message: "boom" })).resolves.toBeUndefined();
+		});
+		test("resolveTurnConfig returns null for static maxSteps", async () => {
+			const { hooks } = getContext();
+			expect(await callResolveTurnConfig(hooks, "hook-5")).toBeNull();
+		});
+	});
+}
+//#endregion
+export { AGENT_CSP, AUDIO_FORMAT, AgentConfigSchema, CONFORMANCE_AGENT, CONFORMANCE_AGENT_BUNDLE, ClientEventSchema, ClientMessageSchema, DEFAULT_IDLE_TIMEOUT_MS, DEFAULT_MAX_HISTORY, DEFAULT_S2S_CONFIG, DEFAULT_SESSION_START_TIMEOUT_MS, DEFAULT_SHUTDOWN_TIMEOUT_MS, DEFAULT_STT_SAMPLE_RATE, DEFAULT_TTS_SAMPLE_RATE, EMPTY_PARAMS, FETCH_TIMEOUT_MS, HOOK_TIMEOUT_MS, KvRequestSchema, MAX_GLOB_PATTERN_LENGTH, MAX_HTML_BYTES, MAX_PAGE_CHARS, MAX_TOOL_RESULT_CHARS, MAX_VALUE_SIZE, RUN_CODE_MEMORY_MB, RUN_CODE_TIMEOUT_MS, ReadyConfigSchema, ServerMessageSchema, SessionErrorCodeSchema, TOOL_EXECUTION_TIMEOUT_MS, ToolSchemaSchema, TurnConfigSchema, _internals, agentToolsToSchemas, buildCtx, buildReadyConfig, buildSystemPrompt, callResolveTurnConfig, connectS2s, consoleLogger, createAgentHooks, createRuntime, createS2sSession, createSessionStateMap, createUnstorageKv, defaultCreateS2sWebSocket, errorDetail, errorMessage, executeToolCall, isReadOnlyFsOp, jsonLogger, testRuntime, toAgentConfig, toolError, wireSessionSocket };

package/dist/kv.d.ts

@@ -1,6 +1,7 @@
 /**
  * Key-value storage interface and shared utilities.
  */
+export { MAX_VALUE_SIZE } from "./constants.ts";
 /**
  * A single key-value entry returned by {@link Kv.list}.
  *
@@ -106,7 +107,6 @@ export type Kv = {
      */
     close?(): void;
 };
-export declare const MAX_VALUE_SIZE = 65536;
 /** Sort entries by key and apply reverse/limit options. Mutates the array. */
 export declare function sortAndPaginate<T extends {
     key: string;

package/dist/kv.js

@@ -1,2 +1,33 @@
-import { n as matchGlob, r as sortAndPaginate, t as MAX_VALUE_SIZE } from "./kv-iXtikQmR.js";
+import { m as MAX_VALUE_SIZE, u as MAX_GLOB_PATTERN_LENGTH } from "./constants-BbAOvKl_.js";
+//#region kv.ts
+/**
+* Key-value storage interface and shared utilities.
+*/
+/** Sort entries by key and apply reverse/limit options. Mutates the array. */
+function sortAndPaginate(entries, options) {
+	entries.sort((a, b) => a.key.localeCompare(b.key));
+	if (options?.reverse) entries.reverse();
+	if (options?.limit && options.limit > 0) entries.length = Math.min(entries.length, options.limit);
+	return entries;
+}
+/** Simple glob matcher — supports `*` as a wildcard for any characters. */
+function matchGlob(key, pattern) {
+	if (pattern.length > 1024) throw new Error(`Glob pattern exceeds maximum length of ${MAX_GLOB_PATTERN_LENGTH}`);
+	const parts = pattern.split("*");
+	if (parts.length === 1) return key === pattern;
+	const first = parts[0];
+	if (!key.startsWith(first)) return false;
+	const last = parts.at(-1);
+	if (key.length < first.length + last.length) return false;
+	if (!key.endsWith(last)) return false;
+	let pos = first.length;
+	const end = key.length - last.length;
+	for (const part of parts.slice(1, -1)) {
+		const idx = key.indexOf(part, pos);
+		if (idx === -1 || idx > end) return false;
+		pos = idx + part.length;
+	}
+	return pos <= end;
+}
+//#endregion
 export { MAX_VALUE_SIZE, matchGlob, sortAndPaginate };

package/dist/matchers.js

@@ -1,4 +1,4 @@
-import { n as TurnResult } from "./testing-BbitshLb.js";
+import { n as TurnResult } from "./testing-BonJtfHJ.js";
 import { expect } from "vitest";
 //#region matchers.ts
 /**

package/dist/protocol.d.ts

@@ -4,18 +4,6 @@
  * Note: this module is for internal use only and should not be used directly.
  */
 import { z } from "zod";
-/**
- * Default sample rate for speech-to-text audio in Hz.
- *
- * This is the sample rate expected by the STT provider (AssemblyAI).
- */
-export declare const DEFAULT_STT_SAMPLE_RATE = 16000;
-/**
- * Default sample rate for text-to-speech audio in Hz.
- *
- * This is the sample rate produced by the TTS provider.
- */
-export declare const DEFAULT_TTS_SAMPLE_RATE = 24000;
 /**
  * Audio codec identifier used in the wire protocol.
  *
@@ -45,23 +33,17 @@ export declare const KvRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "op">;
 /** KV operation request — discriminated union on the `op` field. */
 export type KvRequest = z.infer<typeof KvRequestSchema>;
-/** Default timeout for agent lifecycle hooks (onConnect, onTurn, etc). */
-export declare const HOOK_TIMEOUT_MS = 5000;
-/** Default timeout for tool execution in the worker. */
-export declare const TOOL_EXECUTION_TIMEOUT_MS = 30000;
-/** Maximum length for tool result strings sent to clients. */
-export declare const MAX_TOOL_RESULT_CHARS = 4000;
 /**
  * Zod schema for session error codes.
  * @public
  */
 export declare const SessionErrorCodeSchema: z.ZodEnum<{
     tool: "tool";
+    connection: "connection";
     stt: "stt";
     llm: "llm";
     tts: "tts";
     protocol: "protocol";
-    connection: "connection";
     audio: "audio";
     internal: "internal";
 }>;
@@ -96,10 +78,6 @@ export declare const ClientEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     toolCallId: z.ZodString;
     toolName: z.ZodString;
     args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool_call_update">;
-    toolCallId: z.ZodString;
-    data: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"tool_call_done">;
     toolCallId: z.ZodString;
@@ -116,11 +94,11 @@ export declare const ClientEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"error">;
     code: z.ZodEnum<{
         tool: "tool";
+        connection: "connection";
         stt: "stt";
         llm: "llm";
         tts: "tts";
         protocol: "protocol";
-        connection: "connection";
         audio: "audio";
         internal: "internal";
     }>;
@@ -188,10 +166,6 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     toolCallId: z.ZodString;
     toolName: z.ZodString;
     args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"tool_call_update">;
-    toolCallId: z.ZodString;
-    data: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"tool_call_done">;
     toolCallId: z.ZodString;
@@ -208,11 +182,11 @@ export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"error">;
     code: z.ZodEnum<{
         tool: "tool";
+        connection: "connection";
         stt: "stt";
         llm: "llm";
         tts: "tts";
         protocol: "protocol";
-        connection: "connection";
         audio: "audio";
         internal: "internal";
     }>;