@alexkroman1/aai 0.12.2 → 1.0.2

package/dist/host/runtime-config.d.ts

@@ -0,0 +1,42 @@
+/** Structured context attached to log messages. */
+export type LogContext = Record<string, unknown>;
+/**
+ * Structured logger interface. Used by tests to suppress output and by
+ * consumers to plug in custom logging backends.
+ *
+ * @example
+ * ```ts
+ * const myLogger: Logger = {
+ *   info: (msg, ctx) => myBackend.log("info", msg, ctx),
+ *   warn: (msg, ctx) => myBackend.log("warn", msg, ctx),
+ *   error: (msg, ctx) => myBackend.log("error", msg, ctx),
+ *   debug: (msg, ctx) => myBackend.log("debug", msg, ctx),
+ * };
+ * createServer({ agent, logger: myLogger });
+ * ```
+ */
+export type Logger = {
+    info(msg: string, ctx?: LogContext): void;
+    warn(msg: string, ctx?: LogContext): void;
+    error(msg: string, ctx?: LogContext): void;
+    debug(msg: string, ctx?: LogContext): void;
+};
+/** Default console-backed logger. */
+export declare const consoleLogger: Logger;
+export declare const jsonLogger: Logger;
+/**
+ * Speech-to-Speech (S2S) endpoint configuration.
+ *
+ * Controls which AssemblyAI real-time WebSocket endpoint to connect to and
+ * the audio sample rates for input (microphone → STT) and output (TTS → speaker).
+ */
+export type S2SConfig = {
+    /** The WebSocket URL of the S2S real-time endpoint. */
+    wssUrl: string;
+    /** Sample rate in Hz for audio sent to STT (microphone capture). */
+    inputSampleRate: number;
+    /** Sample rate in Hz for TTS audio received from the server. */
+    outputSampleRate: number;
+};
+/** Default S2S endpoint configuration. */
+export declare const DEFAULT_S2S_CONFIG: S2SConfig;

package/dist/host/runtime.d.ts

@@ -1,42 +1,126 @@
-/** Structured context attached to log messages. */
-export type LogContext = Record<string, unknown>;
 /**
- * Structured logger interface. Used by tests to suppress output and by
- * consumers to plug in custom logging backends.
- *
- * @example
- * ```ts
- * const myLogger: Logger = {
- *   info: (msg, ctx) => myBackend.log("info", msg, ctx),
- *   warn: (msg, ctx) => myBackend.log("warn", msg, ctx),
- *   error: (msg, ctx) => myBackend.log("error", msg, ctx),
- *   debug: (msg, ctx) => myBackend.log("debug", msg, ctx),
- * };
- * createServer({ agent, logger: myLogger });
- * ```
+ * Agent runtime — the execution engine for voice agents.
+ *
+ * {@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 "../sdk/_internal-types.ts";
+import type { Kv } from "../sdk/kv.ts";
+import type { ClientSink } from "../sdk/protocol.ts";
+import { type ReadyConfig } from "../sdk/protocol.ts";
+import type { AgentDef } from "../sdk/types.ts";
+import type { Logger, S2SConfig } from "./runtime-config.ts";
+import type { CreateS2sWebSocket } from "./s2s.ts";
+import { type Session } from "./session.ts";
+import { type ExecuteTool } from "./tool-executor.ts";
+import { type SessionWebSocket } from "./ws-handler.ts";
+/** Per-session options passed to {@link AgentRuntime.startSession}. */
+export type SessionStartOptions = {
+    skipGreeting?: boolean;
+    resumeFrom?: string;
+    logContext?: Record<string, string>;
+    onOpen?: () => void;
+    onClose?: () => void;
+    /** Called with session ID after session cleanup, for guest state cleanup. */
+    onSessionEnd?: (sessionId: string) => void;
+};
+/**
+ * Common interface for agent runtimes.
+ *
+ * Implemented by {@link createRuntime} and the platform sandbox.
+ */
+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 Logger = {
-    info(msg: string, ctx?: LogContext): void;
-    warn(msg: string, ctx?: LogContext): void;
-    error(msg: string, ctx?: LogContext): void;
-    debug(msg: string, ctx?: LogContext): void;
+export type RuntimeOptions = {
+    agent: AgentDef<any>;
+    env: Record<string, string>;
+    kv?: Kv | 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 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;
+    /** System prompt guidance for builtin tools. Passed through in sandbox mode. */
+    toolGuidance?: string[] | undefined;
+    /**
+     * Pre-resolved builtin tool definitions. When provided alongside `executeTool`
+     * and `toolSchemas`, skips calling `resolveAllBuiltins` on the host.
+     */
+    builtinDefs?: Record<string, import("../sdk/types.ts").ToolDef> | undefined;
+    /**
+     * Override the fetch implementation used by built-in tools (web_search,
+     * visit_webpage, fetch_json). Defaults to `globalThis.fetch`.
+     *
+     * In platform mode, pass an SSRF-safe fetch to prevent requests to
+     * private/internal networks. In self-hosted mode, users may provide
+     * their own fetch wrapper.
+     */
+    fetch?: typeof globalThis.fetch | undefined;
 };
-/** Default console-backed logger. */
-export declare const consoleLogger: Logger;
-export declare const jsonLogger: Logger;
 /**
- * Speech-to-Speech (S2S) endpoint configuration.
+ * The agent runtime returned by {@link createRuntime}.
  *
- * Controls which AssemblyAI real-time WebSocket endpoint to connect to and
- * the audio sample rates for input (microphone → STT) and output (TTS → speaker).
+ * 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 S2SConfig = {
-    /** The WebSocket URL of the S2S real-time endpoint. */
-    wssUrl: string;
-    /** Sample rate in Hz for audio sent to STT (microphone capture). */
-    inputSampleRate: number;
-    /** Sample rate in Hz for TTS audio received from the server. */
-    outputSampleRate: number;
+export type Runtime = AgentRuntime & {
+    /** Execute a named tool with the given args, returning a JSON result string. */
+    executeTool: ExecuteTool;
+    /** Tool schemas registered with the S2S API (custom + built-in). */
+    toolSchemas: ToolSchema[];
+    /** Create a new voice session for a connected client (lower-level than startSession). */
+    createSession(opts: {
+        id: string;
+        agent: string;
+        client: ClientSink;
+        skipGreeting?: boolean;
+        resumeFrom?: string;
+    }): Session;
 };
-/** Default S2S endpoint configuration. */
-export declare const DEFAULT_S2S_CONFIG: S2SConfig;
+/**
+ * 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 lifecycle hooks.
+ *
+ * @param opts - Runtime configuration. See {@link RuntimeOptions}.
+ * @returns A {@link Runtime} with tool execution, hook invocation,
+ *   schemas, and session management.
+ *
+ * @public
+ */
+export declare function createRuntime(opts: RuntimeOptions): Runtime;

package/dist/host/s2s.d.ts

@@ -3,7 +3,8 @@
  */
 import type { JSONSchema7 } from "json-schema";
 import { type Unsubscribe } from "nanoevents";
-import type { Logger, S2SConfig } from "./runtime.ts";
+import type { ClientEvent } from "../sdk/protocol.ts";
+import type { Logger, S2SConfig } from "./runtime-config.ts";
 export type S2sWebSocket = {
     readonly readyState: number;
     send(data: string): void;
@@ -24,6 +25,14 @@ export type CreateS2sWebSocket = (url: string, opts: {
     headers: Record<string, string>;
 }) => S2sWebSocket;
 export declare const defaultCreateS2sWebSocket: CreateS2sWebSocket;
+/**
+ * A ClientEvent extended with optional internal metadata for S2S-specific
+ * fields that don't appear on the wire protocol (e.g. `interrupted` on
+ * `agent_transcript`, which affects conversation history but not the client).
+ */
+export type S2sEvent = ClientEvent & {
+    _interrupted?: boolean;
+};
 export type S2sSessionConfig = {
     systemPrompt: string;
     tools: S2sToolSchema[];
@@ -35,53 +44,20 @@ export type S2sToolSchema = {
     description: string;
     parameters: JSONSchema7;
 };
-export type S2sToolCall = {
-    callId: string;
-    name: string;
-    args: Record<string, unknown>;
-};
 export type S2sEvents = {
     ready: (detail: {
         sessionId: string;
     }) => void;
-    sessionUpdated: (detail: Record<string, unknown>) => void;
-    sessionExpired: (detail: {
-        code: string;
-        message: string;
-    }) => void;
-    speechStarted: () => void;
-    speechStopped: () => void;
-    userTranscriptDelta: (detail: {
-        text: string;
-    }) => void;
-    userTranscript: (detail: {
-        itemId: string;
-        text: string;
-    }) => void;
     replyStarted: (detail: {
         replyId: string;
     }) => void;
-    agentTranscriptDelta: (detail: {
-        text: string;
-    }) => void;
-    agentTranscript: (detail: {
-        text: string;
-        replyId: string;
-        itemId: string;
-        interrupted: boolean;
-    }) => void;
-    toolCall: (detail: S2sToolCall) => void;
-    replyDone: (detail: {
-        status?: string;
-    }) => void;
+    sessionExpired: () => void;
+    event: (event: S2sEvent) => void;
     audio: (detail: {
         audio: Uint8Array;
     }) => void;
-    error: (detail: {
-        code: string;
-        message: string;
-    }) => void;
-    close: () => void;
+    error: (err: Error) => void;
+    close: (code: number, reason: string) => void;
 };
 export type S2sHandle = {
     on<K extends keyof S2sEvents>(event: K, cb: S2sEvents[K]): Unsubscribe;

package/dist/host/server.d.ts

@@ -1,18 +1,21 @@
 /**
- * Self-hostable agent server.
+ * Agent HTTP+WebSocket server.
  *
  * {@link createServer} wraps a {@link Runtime} with an HTTP + WebSocket
  * server using only `node:http` and `ws` (no framework dependencies).
+ *
+ * **Internal module** — used by `aai-cli` dev server. Not a public API.
+ * Import via `aai/host`.
  */
-import type { Kv } from "../isolate/kv.ts";
-import type { Runtime } from "./direct-executor.ts";
-import type { Logger } from "./runtime.ts";
-export { createRuntime, type Runtime, type RuntimeOptions } from "./direct-executor.ts";
+import type { Kv } from "../sdk/kv.ts";
+import type { Runtime } from "./runtime.ts";
+import type { Logger } from "./runtime-config.ts";
+export { createRuntime, type Runtime, type RuntimeOptions } from "./runtime.ts";
 /**
  * Configuration for {@link createServer}.
- * @public
+ * @internal
  */
-export type ServerOptions = {
+type ServerOptions = {
     runtime: Runtime;
     name?: string;
     kv?: Kv;
@@ -22,11 +25,16 @@ export type ServerOptions = {
 };
 /**
  * Handle returned by {@link createServer}.
- * @public
+ * @internal
  */
 export type AgentServer = {
     listen(port?: number): Promise<void>;
     close(): Promise<void>;
     port: number | undefined;
 };
+/**
+ * Create an HTTP + WebSocket server for an agent.
+ *
+ * @internal Used by aai-cli dev server.
+ */
 export declare function createServer(options: ServerOptions): AgentServer;

package/dist/host/session-ctx.d.ts

@@ -0,0 +1,55 @@
+/** Session context builder — extracted from session.ts. */
+import type { AgentConfig, ExecuteTool } from "../sdk/_internal-types.ts";
+import type { ClientSink } from "../sdk/protocol.ts";
+import type { Message } from "../sdk/types.ts";
+import type { Logger } from "./runtime-config.ts";
+import type { S2sHandle } from "./s2s.ts";
+type PendingTool = {
+    callId: string;
+    result: string;
+};
+/** Per-reply mutable state — reset on beginReply/cancelReply. */
+export type ReplyState = {
+    pendingTools: PendingTool[];
+    toolCallCount: number;
+    currentReplyId: string | null;
+};
+/** Immutable dependencies injected at session creation. */
+export type SessionDeps = {
+    readonly id: string;
+    readonly agent: string;
+    readonly client: ClientSink;
+    readonly agentConfig: AgentConfig;
+    readonly executeTool: ExecuteTool;
+    readonly log: Logger;
+    readonly maxHistory: number;
+};
+/**
+ * Session context threaded through event handlers.
+ *
+ * Split into three layers:
+ * - {@link SessionDeps} — immutable dependencies (set once)
+ * - {@link ReplyState} via `reply` — per-reply mutable state (reset on beginReply/cancelReply)
+ * - Remaining fields — connection, conversation, and lifecycle methods
+ */
+export type S2sSessionCtx = SessionDeps & {
+    s2s: S2sHandle | null;
+    reply: ReplyState;
+    turnPromise: Promise<void> | null;
+    conversationMessages: Message[];
+    consumeToolCallStep(name: string, replyId: string | null): string | null;
+    pushMessages(...msgs: Message[]): void;
+    beginReply(replyId: string): void;
+    cancelReply(): void;
+    chainTurn(p: Promise<void>): void;
+};
+export declare function buildCtx(opts: {
+    id: string;
+    agent: string;
+    client: ClientSink;
+    agentConfig: AgentConfig;
+    executeTool: ExecuteTool;
+    log: Logger;
+    maxHistory?: number | undefined;
+}): S2sSessionCtx;
+export {};

package/dist/host/session.d.ts

@@ -1,78 +1,15 @@
 /** S2S session — relays audio between client and AssemblyAI S2S API. */
-import type { AgentConfig, ExecuteTool, ToolSchema } from "../isolate/_internal-types.ts";
-import type { AgentHookMap, AgentHooks } from "../isolate/hooks.ts";
-import type { ClientSink } from "../isolate/protocol.ts";
-import type { Message } from "../isolate/types.ts";
-import type { Logger, S2SConfig } from "./runtime.ts";
-import { type CreateS2sWebSocket, connectS2s, type S2sHandle } from "./s2s.ts";
-export type { S2sHandle } from "./s2s.ts";
-type PendingTool = {
-    callId: string;
-    result: string;
-};
-/** Per-reply mutable state — reset on beginReply/cancelReply. */
-export type ReplyState = {
-    pendingTools: PendingTool[];
-    toolCallCount: number;
-    currentReplyId: string | null;
-};
-/** Immutable dependencies injected at session creation. */
-export type SessionDeps = {
-    readonly id: string;
-    readonly agent: string;
-    readonly client: ClientSink;
-    readonly agentConfig: AgentConfig;
-    readonly executeTool: ExecuteTool;
-    readonly hooks: AgentHooks | undefined;
-    readonly log: Logger;
-    readonly maxHistory: number;
-};
-/**
- * Session context threaded through event handlers.
- *
- * Split into three layers:
- * - {@link SessionDeps} — immutable dependencies (set once)
- * - {@link ReplyState} via `reply` — per-reply mutable state (reset on beginReply/cancelReply)
- * - Remaining fields — connection, conversation, and lifecycle methods
- */
-export type S2sSessionCtx = SessionDeps & {
-    s2s: S2sHandle | null;
-    reply: ReplyState;
-    turnPromise: Promise<void> | null;
-    conversationMessages: Message[];
-    resolveTurnConfig(): Promise<{
-        maxSteps?: number;
-    } | null>;
-    consumeToolCallStep(turnConfig: {
-        maxSteps?: number;
-    } | null, name: string, replyId: string | null): string | null;
-    fireHook(name: keyof AgentHookMap, ...args: unknown[]): void;
-    drainHooks(): Promise<void>;
-    pushMessages(...msgs: Message[]): void;
-    beginReply(replyId: string): void;
-    cancelReply(): void;
-    chainTurn(p: Promise<void>): void;
-};
-export declare function buildCtx(opts: {
-    id: string;
-    agent: string;
-    client: ClientSink;
-    agentConfig: AgentConfig;
-    executeTool: ExecuteTool;
-    hooks: AgentHooks | undefined;
-    log: Logger;
-    maxHistory?: number | undefined;
-}): S2sSessionCtx;
-export type { AgentHookMap, AgentHooks } from "../isolate/hooks.ts";
-export { callResolveTurnConfig, createAgentHooks } from "../isolate/hooks.ts";
-export { buildSystemPrompt } from "../isolate/system-prompt.ts";
+import type { AgentConfig, ExecuteTool, ToolSchema } from "../sdk/_internal-types.ts";
+import type { ClientSink } from "../sdk/protocol.ts";
+import type { Logger, S2SConfig } from "./runtime-config.ts";
+import { type CreateS2sWebSocket, connectS2s } from "./s2s.ts";
 /**
  * A voice session managing the Speech-to-Speech connection for one client.
  *
  * Created by {@link createS2sSession}. Each session owns a single S2S WebSocket
  * connection and relays audio between the browser client and AssemblyAI.
  *
- * @internal Exported for use by `ws-handler.ts`, `server.ts`, and `direct-executor.ts`.
+ * @internal Exported for use by `ws-handler.ts`, `server.ts`, and `runtime.ts`.
  */
 export type Session = {
     start(): Promise<void>;
@@ -87,21 +24,35 @@ export type Session = {
     }[]): void;
     waitForTurn(): Promise<void>;
 };
-/** Configuration options for creating a new session. */
+/** Configuration options for creating a new S2S voice session. */
 export type S2sSessionOptions = {
+    /** Unique session identifier (used for KV scoping and logging). */
     id: string;
+    /** Agent slug — identifies which deployed agent this session belongs to. */
     agent: string;
+    /** Sink for pushing events and audio to the connected browser client. */
     client: ClientSink;
+    /** Serializable agent config (name, system prompt, greeting, maxSteps, etc.). */
     agentConfig: AgentConfig;
+    /** JSON Schema definitions for the agent's custom tools. */
     toolSchemas: readonly ToolSchema[];
+    /** Optional natural-language guidance appended to the system prompt for tool usage. */
+    toolGuidance?: readonly string[];
+    /** AssemblyAI API key — stays host-side, never forwarded to the guest sandbox. */
     apiKey: string;
+    /** S2S connection config (sample rates, model selection). */
     s2sConfig: S2SConfig;
+    /** Function to invoke tools by name (wired to direct-executor or sandbox RPC). */
     executeTool: ExecuteTool;
+    /** Override WebSocket constructor for testing. */
     createWebSocket?: CreateS2sWebSocket;
+    /** Agent environment variables (secrets). Forwarded to tool context. */
     env?: Record<string, string | undefined>;
-    hooks?: AgentHooks;
+    /** Skip the initial greeting audio on connect (used for session resume). */
     skipGreeting?: boolean;
+    /** Logger instance. Defaults to `consoleLogger`. */
     logger?: Logger;
+    /** Max conversation messages to retain. Defaults to DEFAULT_MAX_HISTORY (200). */
     maxHistory?: number;
 };
 /** @internal Not part of the public API. Exposed for testing only. */

package/dist/host/tool-executor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tool execution — validates arguments and invokes tool handlers.
+ *
+ * {@link executeToolCall} is the single entry point used by both the
+ * direct (self-hosted) runtime and the platform sandbox sidecar.
+ */
+import type { Kv } from "../sdk/kv.ts";
+import type { Message, ToolDef } from "../sdk/types.ts";
+import type { Logger } from "./runtime-config.ts";
+export type { ExecuteTool } from "../sdk/_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;
+};
+export declare function executeToolCall(name: string, args: Readonly<Record<string, unknown>>, options: ExecuteToolCallOptions): Promise<string>;

package/dist/host/unstorage-kv.d.ts

@@ -4,7 +4,7 @@
  * Works with any unstorage driver (memory, fs, S3/R2, etc.).
  */
 import { type Storage } from "unstorage";
-import type { Kv } from "../isolate/kv.ts";
+import type { Kv } from "../sdk/kv.ts";
 /**
  * Options for creating an unstorage-backed KV store.
  */

package/dist/host/ws-handler.d.ts

@@ -3,8 +3,8 @@
  *
  * Audio validation is handled at the host transport layer (see server.ts).
  */
-import type { ClientSink, ReadyConfig } from "../isolate/protocol.ts";
-import type { Logger } from "./runtime.ts";
+import type { ClientSink, ReadyConfig } from "../sdk/protocol.ts";
+import type { Logger } from "./runtime-config.ts";
 import type { Session } from "./session.ts";
 /**
  * Minimal WebSocket interface accepted by {@link wireSessionSocket}.
@@ -36,6 +36,8 @@ export type WsSessionOptions = {
     onOpen?: () => void;
     /** Callback invoked when the WebSocket connection closes. */
     onClose?: () => void;
+    /** Callback invoked with the session ID after session cleanup. */
+    onSessionEnd?: (sessionId: string) => void;
     /** Logger instance. Defaults to console. */
     logger?: Logger;
     /** Timeout in ms for session.start(). Defaults to 10 000 (10s). */

package/dist/index.d.ts

@@ -1,23 +1,12 @@
 /**
- * AAI SDK — build voice agents powered by STT, LLM, and TTS.
+ * aai — shared fundamentals with no Node.js dependencies.
  *
- * @example
- * ```ts
- * import { defineAgent } from "aai";
- * import { z } from "zod";
- *
- * export default defineAgent({
- *   name: "my-agent",
- *   instructions: "You are a helpful voice assistant.",
- *   tools: {
- *     greet: {
- *       description: "Greet the user by name",
- *       parameters: z.object({ name: z.string() }),
- *       execute: ({ name }) => `Hello, ${name}!`,
- *     },
- *   },
- * });
- * ```
+ * Types, KV interface, utils, and constants used across
+ * aai-cli, aai-server, and aai-ui.
  */
-export type { Kv, KvEntry, KvListOptions } from "./isolate/kv.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 "./isolate/types.ts";
+export * from "./sdk/constants.ts";
+export * from "./sdk/define.ts";
+export * from "./sdk/kv.ts";
+export * from "./sdk/types.ts";
+export * from "./sdk/utils.ts";
+export * from "./sdk/ws-upgrade.ts";

package/dist/index.js

@@ -1,2 +1,63 @@
-import { defineAgent, defineTool, defineToolFactory } from "./isolate/types.js";
-export { defineAgent, defineTool, defineTool as tool, defineToolFactory };
+import { _ as WS_OPEN, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, f as MAX_TOOL_RESULT_CHARS, g as TOOL_EXECUTION_TIMEOUT_MS, h as RUN_CODE_TIMEOUT_MS, i as DEFAULT_SESSION_START_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, n as DEFAULT_IDLE_TIMEOUT_MS, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, r as DEFAULT_MAX_HISTORY, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP, u as MAX_MESSAGE_BUFFER_SIZE } from "./constants-VTFoymJ-.js";
+import { i as ToolChoiceSchema, n as DEFAULT_GREETING, r as DEFAULT_SYSTEM_PROMPT, t as BuiltinToolSchema } from "./types-Cfx_4QDK.js";
+import { i as toolError, n as errorDetail, r as errorMessage, t as parseWsUpgradeParams } from "./ws-upgrade-BeOQ7fXL.js";
+//#region sdk/define.ts
+/**
+* Define a tool with typed parameters and execute function.
+*
+* Identity function for type inference — returns the input unchanged.
+* Follows the Vercel AI SDK `tool()` pattern.
+*
+* @example
+* ```ts
+* import { tool } from "@alexkroman1/aai";
+* import { z } from "zod";
+*
+* const greet = tool({
+*   description: "Greet someone by name",
+*   parameters: z.object({ name: z.string() }),
+*   execute: ({ name }) => `Hello, ${name}!`,
+* });
+* ```
+*
+* @public
+*/
+function tool(def) {
+	return def;
+}
+/**
+* Define an agent with tools, system prompt, and configuration.
+*
+* Applies sensible defaults for omitted fields. Export as the default
+* export of your `agent.ts` file.
+*
+* @example
+* ```ts
+* import { agent, tool } from "@alexkroman1/aai";
+* import { z } from "zod";
+*
+* const myTool = tool({
+*   description: "Echo a message",
+*   parameters: z.object({ message: z.string() }),
+*   execute: ({ message }) => message,
+* });
+*
+* export default agent({
+*   name: "Echo Agent",
+*   tools: { echo: myTool },
+* });
+* ```
+*
+* @public
+*/
+function agent(def) {
+	return {
+		systemPrompt: DEFAULT_SYSTEM_PROMPT,
+		greeting: DEFAULT_GREETING,
+		maxSteps: 5,
+		tools: {},
+		...def
+	};
+}
+//#endregion
+export { AGENT_CSP, BuiltinToolSchema, DEFAULT_GREETING, DEFAULT_IDLE_TIMEOUT_MS, DEFAULT_MAX_HISTORY, DEFAULT_SESSION_START_TIMEOUT_MS, DEFAULT_SHUTDOWN_TIMEOUT_MS, DEFAULT_STT_SAMPLE_RATE, DEFAULT_SYSTEM_PROMPT, DEFAULT_TTS_SAMPLE_RATE, FETCH_TIMEOUT_MS, MAX_HTML_BYTES, MAX_MESSAGE_BUFFER_SIZE, MAX_PAGE_CHARS, MAX_TOOL_RESULT_CHARS, MAX_VALUE_SIZE, MAX_WS_PAYLOAD_BYTES, RUN_CODE_TIMEOUT_MS, TOOL_EXECUTION_TIMEOUT_MS, ToolChoiceSchema, WS_OPEN, agent, errorDetail, errorMessage, parseWsUpgradeParams, tool, toolError };