@alexkroman1/aai 0.3.0

package/dist/cli.js

@@ -0,0 +1,3436 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// cli/_colors.ts
+import chalk from "chalk";
+function primary(s) {
+  return chalk.hex("#fab283")(s);
+}
+function interactive(s) {
+  return chalk.hex("#9dbefe")(s);
+}
+function error(s) {
+  return chalk.hex("#fc533a")(s);
+}
+function warning(s) {
+  return chalk.hex("#fcd53a")(s);
+}
+var init_colors = __esm({
+  "cli/_colors.ts"() {
+    "use strict";
+  }
+});
+
+// cli/_output.ts
+import chalk3 from "chalk";
+function fmt(action, color, msg) {
+  return `${color(chalk3.bold(action.padStart(PAD)))} ${msg}`;
+}
+function step(action, msg) {
+  console.log(fmt(action, primary, msg));
+}
+function stepInfo(action, msg) {
+  console.log(fmt(action, interactive, msg));
+}
+function info(msg) {
+  console.log(chalk3.dim(`${" ".repeat(PAD + 1)}${msg}`));
+}
+function warn(msg) {
+  console.error(fmt("warning", warning, msg));
+}
+function error2(msg) {
+  console.error(`${error(chalk3.bold("error"))}: ${msg}`);
+}
+var PAD;
+var init_output = __esm({
+  "cli/_output.ts"() {
+    "use strict";
+    init_colors();
+    PAD = 9;
+  }
+});
+
+// sdk/types.ts
+var DEFAULT_INSTRUCTIONS, DEFAULT_GREETING;
+var init_types = __esm({
+  "sdk/types.ts"() {
+    "use strict";
+    DEFAULT_INSTRUCTIONS = `You are AAI, a helpful AI assistant.
+
+Voice-First Rules:
+- Optimize for natural speech. Avoid jargon unless central to the answer. Use short, punchy sentences.
+- Never mention "search results," "sources," or "the provided text." Speak as if the knowledge is your own.
+- No visual formatting. Do not say "bullet point," "bold," or "bracketed one." If you need to list items, say "First," "Next," and "Finally."
+- Start with the most important information. No introductory filler.
+- Be concise. Keep answers to 1-3 sentences. For complex topics, provide a high-level summary.
+- Be confident. Avoid hedging phrases like "It seems that" or "I believe."
+- If you don't have enough information, say so directly rather than guessing.
+- Never use exclamation points. Keep your tone calm and conversational.`;
+    DEFAULT_GREETING = "Hey there. I'm a voice assistant. What can I help you with?";
+  }
+});
+
+// cli/_new.ts
+var new_exports = {};
+__export(new_exports, {
+  _internals: () => _internals2,
+  listTemplates: () => listTemplates,
+  runNew: () => runNew
+});
+import fs5 from "node:fs/promises";
+import path4 from "node:path";
+import glob from "fast-glob";
+import fsExtra from "fs-extra";
+async function listTemplates(dir) {
+  const templates = [];
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith("_")) {
+      templates.push(entry.name);
+    }
+  }
+  return templates.sort();
+}
+async function copyDirNoOverwrite(src, dest) {
+  const files = await glob("**/*", { cwd: src, dot: true, onlyFiles: true });
+  for (const file of files) {
+    const destPath = path4.join(dest, file);
+    try {
+      await fs5.access(destPath);
+    } catch {
+      await fs5.mkdir(path4.dirname(destPath), { recursive: true });
+      await fs5.copyFile(path4.join(src, file), destPath);
+    }
+  }
+}
+async function runNew(opts) {
+  const { targetDir, template, templatesDir } = opts;
+  const available = await listTemplates(templatesDir);
+  if (!available.includes(template)) {
+    throw new Error(`unknown template '${template}' -- available: ${available.join(", ")}`);
+  }
+  _internals2.step("Create", `from template '${template}'`);
+  await fsExtra.copy(path4.join(templatesDir, template), targetDir, { overwrite: true });
+  await copyDirNoOverwrite(path4.join(templatesDir, "_shared"), targetDir);
+  try {
+    await fs5.copyFile(path4.join(targetDir, ".env.example"), path4.join(targetDir, ".env"));
+  } catch {
+  }
+  const readmePath = path4.join(targetDir, "README.md");
+  try {
+    await fs5.access(readmePath);
+  } catch {
+    const slug = path4.basename(path4.resolve(targetDir));
+    const readme = `# ${slug}
+
+A voice agent built with [aai](https://github.com/anthropics/aai).
+
+## Getting started
+
+\`\`\`sh
+npm install        # Install dependencies
+npm run dev        # Run locally (opens browser)
+npm run deploy     # Deploy to production
+\`\`\`
+
+## Environment variables
+
+Secrets are managed on the server, not in local files:
+
+\`\`\`sh
+aai env add MY_KEY # Set a secret (prompts for value)
+aai env ls         # List secret names
+aai env pull       # Pull names into .env for reference
+aai env rm MY_KEY  # Remove a secret
+\`\`\`
+
+Access secrets in your agent via \`ctx.env.MY_KEY\`.
+
+## Learn more
+
+See \`CLAUDE.md\` for the full agent API reference.
+`;
+    await fs5.writeFile(readmePath, readme);
+  }
+  _internals2.step("Done", targetDir);
+  return targetDir;
+}
+var _internals2;
+var init_new = __esm({
+  "cli/_new.ts"() {
+    "use strict";
+    init_output();
+    _internals2 = {
+      step
+    };
+  }
+});
+
+// sdk/protocol.ts
+import { z } from "zod";
+var PROTOCOL_VERSION, DEFAULT_TTS_SAMPLE_RATE, AUDIO_FORMAT, _bitsPerSample, _channels, AudioFrameSpec, KvRequestBaseSchema, HOOK_TIMEOUT_MS, SessionErrorCodeSchema, TranscriptEventSchema, ClientEventSchema, ClientMessageSchema;
+var init_protocol = __esm({
+  "sdk/protocol.ts"() {
+    "use strict";
+    PROTOCOL_VERSION = 1;
+    DEFAULT_TTS_SAMPLE_RATE = 24e3;
+    AUDIO_FORMAT = "pcm16";
+    _bitsPerSample = 16;
+    _channels = 1;
+    AudioFrameSpec = {
+      /** Audio codec identifier sent in the `ready` message. */
+      format: AUDIO_FORMAT,
+      /** Signed 16-bit integer samples. */
+      bitsPerSample: _bitsPerSample,
+      /** Little-endian byte order. */
+      endianness: "little",
+      /** Mono audio. */
+      channels: _channels,
+      /** Bytes per sample — derived from bitsPerSample and channels. */
+      bytesPerSample: _bitsPerSample / 8 * _channels
+    };
+    KvRequestBaseSchema = z.discriminatedUnion("op", [
+      z.object({ op: z.literal("get"), key: z.string().min(1) }),
+      z.object({
+        op: z.literal("set"),
+        key: z.string().min(1),
+        value: z.string(),
+        ttl: z.number().int().positive().optional()
+      }),
+      z.object({ op: z.literal("del"), key: z.string().min(1) }),
+      z.object({
+        op: z.literal("list"),
+        prefix: z.string(),
+        limit: z.number().int().positive().optional(),
+        reverse: z.boolean().optional()
+      })
+    ]);
+    HOOK_TIMEOUT_MS = 5e3;
+    SessionErrorCodeSchema = z.enum([
+      "stt",
+      "llm",
+      "tts",
+      "tool",
+      "protocol",
+      "connection",
+      "audio",
+      "internal"
+    ]);
+    TranscriptEventSchema = z.object({
+      type: z.literal("transcript"),
+      text: z.string(),
+      isFinal: z.boolean(),
+      turnOrder: z.number().int().nonnegative().optional()
+    });
+    ClientEventSchema = z.discriminatedUnion("type", [
+      z.object({ type: z.literal("speech_started") }),
+      z.object({ type: z.literal("speech_stopped") }),
+      TranscriptEventSchema,
+      z.object({
+        type: z.literal("turn"),
+        text: z.string(),
+        turnOrder: z.number().int().nonnegative().optional()
+      }),
+      z.object({ type: z.literal("chat"), text: z.string() }),
+      z.object({
+        type: z.literal("tool_call_start"),
+        toolCallId: z.string(),
+        toolName: z.string(),
+        args: z.record(z.string(), z.unknown())
+      }),
+      z.object({
+        type: z.literal("tool_call_done"),
+        toolCallId: z.string(),
+        result: z.string().max(4e3)
+      }),
+      z.object({ type: z.literal("tts_done") }),
+      z.object({ type: z.literal("cancelled") }),
+      z.object({ type: z.literal("reset") }),
+      z.object({
+        type: z.literal("error"),
+        code: SessionErrorCodeSchema,
+        message: z.string()
+      })
+    ]);
+    ClientMessageSchema = z.discriminatedUnion("type", [
+      z.object({ type: z.literal("audio_ready") }),
+      z.object({ type: z.literal("cancel") }),
+      z.object({ type: z.literal("reset") }),
+      z.object({
+        type: z.literal("history"),
+        messages: z.array(
+          z.object({
+            role: z.enum(["user", "assistant"]),
+            text: z.string().max(1e5)
+          })
+        ).max(200)
+      })
+    ]);
+  }
+});
+
+// sdk/runtime.ts
+var consoleLogger, noopMetrics, DEFAULT_S2S_CONFIG;
+var init_runtime = __esm({
+  "sdk/runtime.ts"() {
+    "use strict";
+    init_protocol();
+    consoleLogger = {
+      info(msg, ctx) {
+        if (ctx) console.log(msg, ctx);
+        else console.log(msg);
+      },
+      warn(msg, ctx) {
+        if (ctx) console.warn(msg, ctx);
+        else console.warn(msg);
+      },
+      error(msg, ctx) {
+        if (ctx) console.error(msg, ctx);
+        else console.error(msg);
+      },
+      debug(msg, ctx) {
+        if (ctx) console.debug(msg, ctx);
+        else console.debug(msg);
+      }
+    };
+    noopMetrics = {
+      sessionsTotal: { inc() {
+      } },
+      sessionsActive: { inc() {
+      }, dec() {
+      } }
+    };
+    DEFAULT_S2S_CONFIG = {
+      wssUrl: "wss://speech-to-speech.us.assemblyai.com/v1/realtime",
+      inputSampleRate: DEFAULT_TTS_SAMPLE_RATE,
+      outputSampleRate: DEFAULT_TTS_SAMPLE_RATE
+    };
+  }
+});
+
+// sdk/_internal_types.ts
+import { z as z2 } from "zod";
+function agentToolsToSchemas(tools) {
+  return Object.entries(tools).map(([name, def]) => ({
+    name,
+    description: def.description,
+    parameters: z2.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
+  }));
+}
+var EMPTY_PARAMS;
+var init_internal_types = __esm({
+  "sdk/_internal_types.ts"() {
+    "use strict";
+    EMPTY_PARAMS = z2.object({});
+  }
+});
+
+// sdk/builtin_tools.ts
+import { z as z3 } from "zod";
+function htmlToText(html) {
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<(br|hr)\s*\/?>/gi, "\n").replace(/<\/(p|div|li|h[1-6]|tr|blockquote)>/gi, "\n").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#0?39;/g, "'").replace(/[ \t]+/g, " ").replace(/\n /g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function createWebSearch() {
+  return {
+    description: "Search the web for current information, facts, news, or answers to questions. Returns a list of results with title, URL, and description. Use this when the user asks about something you don't know, need up-to-date information, or want to verify facts.",
+    parameters: webSearchParams,
+    async execute(args, ctx) {
+      const { query, max_results: maxResults = 5 } = args;
+      const apiKey = ctx.env.BRAVE_API_KEY ?? "";
+      if (!apiKey) {
+        return { error: "BRAVE_API_KEY is not set \u2014 web search unavailable" };
+      }
+      const url = `${BRAVE_SEARCH_URL}?${new URLSearchParams({
+        q: query,
+        count: String(maxResults),
+        text_decorations: "false"
+      })}`;
+      const resp = await fetch(url, {
+        headers: { "X-Subscription-Token": apiKey },
+        signal: ctx.abortSignal ?? AbortSignal.timeout(15e3)
+      });
+      if (!resp.ok) return [];
+      const raw = await resp.json();
+      const data = BraveSearchResponseSchema.safeParse(raw);
+      if (!data.success) return [];
+      return (data.data.web?.results ?? []).slice(0, maxResults).map((r) => ({
+        title: r.title,
+        url: r.url,
+        description: r.description
+      }));
+    }
+  };
+}
+function createVisitWebpage() {
+  return {
+    description: "Fetch a webpage and return its content as clean text. Use this to read the full content of a URL found via web_search, or any link the user shares. Good for reading articles, documentation, blog posts, or product pages.",
+    parameters: visitWebpageParams,
+    async execute(args, ctx) {
+      const { url } = args;
+      const resp = await fetch(url, {
+        headers: {
+          "User-Agent": "Mozilla/5.0 (compatible; VoiceAgent/1.0; +https://github.com/AssemblyAI/aai)",
+          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        },
+        redirect: "follow",
+        signal: ctx.abortSignal ?? AbortSignal.timeout(15e3)
+      });
+      if (!resp.ok) {
+        return { error: `Failed to fetch: ${resp.status} ${resp.statusText}`, url };
+      }
+      const htmlContent = await resp.text();
+      const trimmedHtml = htmlContent.length > MAX_HTML_BYTES ? htmlContent.slice(0, MAX_HTML_BYTES) : htmlContent;
+      const text = htmlToText(trimmedHtml);
+      const truncated = text.length > MAX_PAGE_CHARS;
+      const content = truncated ? text.slice(0, MAX_PAGE_CHARS) : text;
+      return {
+        url,
+        content,
+        ...truncated ? { truncated: true, totalChars: text.length } : {}
+      };
+    }
+  };
+}
+function createFetchJson() {
+  return {
+    description: "Call a REST API endpoint via HTTP GET and return the JSON response. Use this to fetch structured data from APIs \u2014 for example, weather data, stock prices, exchange rates, or any public JSON API. Supports custom headers for authenticated APIs.",
+    parameters: fetchJsonParams,
+    async execute(args, ctx) {
+      const { url, headers } = args;
+      const resp = await fetch(url, {
+        ...headers && { headers },
+        signal: ctx.abortSignal ?? AbortSignal.timeout(15e3)
+      });
+      if (!resp.ok) {
+        return { error: `HTTP ${resp.status} ${resp.statusText}`, url };
+      }
+      try {
+        return await resp.json();
+      } catch {
+        return { error: "Response was not valid JSON", url };
+      }
+    }
+  };
+}
+function createRunCode() {
+  return {
+    description: "Execute JavaScript code in a secure sandbox and return the output. Use this for calculations, data transformations, string manipulation, or any task that benefits from running code. Output is captured from console.log(). No network or filesystem access.",
+    parameters: runCodeParams,
+    async execute(args) {
+      const { code } = args;
+      const output = [];
+      function capture(...captureArgs) {
+        output.push(captureArgs.map(String).join(" "));
+      }
+      const fakeConsole = {
+        log: capture,
+        info: capture,
+        warn: capture,
+        error: capture,
+        debug: capture
+      };
+      const AsyncFunction = Object.getPrototypeOf(async () => {
+      }).constructor;
+      try {
+        const fn = new AsyncFunction("console", code);
+        await fn(fakeConsole);
+        const result = output.join("\n").trim();
+        return result || "Code ran successfully (no output)";
+      } catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+      }
+    }
+  };
+}
+function createVectorSearch(vectorSearchFn) {
+  return {
+    description: "Search the agent's knowledge base for relevant information. Use this when the user asks a question that might be answered by previously ingested documents or data. Returns the most relevant matches ranked by similarity.",
+    parameters: vectorSearchParams,
+    async execute(args) {
+      const { query, topK = 5 } = args;
+      return vectorSearchFn(query, topK);
+    }
+  };
+}
+function getBuiltinToolDefs(names, opts) {
+  const defs = {};
+  for (const name of names) {
+    switch (name) {
+      case "web_search":
+        defs[name] = createWebSearch();
+        break;
+      case "visit_webpage":
+        defs[name] = createVisitWebpage();
+        break;
+      case "fetch_json":
+        defs[name] = createFetchJson();
+        break;
+      case "run_code":
+        defs[name] = createRunCode();
+        break;
+      case "vector_search":
+        if (opts?.vectorSearch) {
+          defs[name] = createVectorSearch(opts.vectorSearch);
+        }
+        break;
+    }
+  }
+  return defs;
+}
+function getBuiltinToolSchemas(names) {
+  return names.flatMap((name) => {
+    const creator = TOOL_CREATORS[name];
+    if (!creator) return [];
+    const def = creator();
+    return [
+      {
+        name,
+        description: def.description,
+        parameters: z3.toJSONSchema(def.parameters ?? EMPTY_PARAMS2)
+      }
+    ];
+  });
+}
+var EMPTY_PARAMS2, webSearchParams, BRAVE_SEARCH_URL, BraveSearchResponseSchema, MAX_PAGE_CHARS, MAX_HTML_BYTES, visitWebpageParams, fetchJsonParams, runCodeParams, vectorSearchParams, TOOL_CREATORS;
+var init_builtin_tools = __esm({
+  "sdk/builtin_tools.ts"() {
+    "use strict";
+    EMPTY_PARAMS2 = z3.object({});
+    webSearchParams = z3.object({
+      query: z3.string().describe("The search query"),
+      max_results: z3.number().describe("Maximum number of results to return (default 5)").optional()
+    });
+    BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search";
+    BraveSearchResponseSchema = z3.object({
+      web: z3.object({
+        results: z3.array(
+          z3.object({
+            title: z3.string(),
+            url: z3.string(),
+            description: z3.string()
+          })
+        )
+      }).optional()
+    });
+    MAX_PAGE_CHARS = 1e4;
+    MAX_HTML_BYTES = 2e5;
+    visitWebpageParams = z3.object({
+      url: z3.string().describe("The full URL to fetch (e.g., 'https://example.com/page')")
+    });
+    fetchJsonParams = z3.object({
+      url: z3.string().describe("The URL to fetch JSON from"),
+      headers: z3.record(z3.string(), z3.string()).describe("Optional HTTP headers to include in the request").optional()
+    });
+    runCodeParams = z3.object({
+      code: z3.string().describe("JavaScript code to execute. Use console.log() for output.")
+    });
+    vectorSearchParams = z3.object({
+      query: z3.string().describe(
+        'Short keyword query to search the knowledge base. Use specific topic terms, not full sentences. Do NOT include the company or product name since all documents are from the same source. For example, if the user asks "how much does Acme cost", search for "pricing plans rates".'
+      ),
+      topK: z3.number().describe("Maximum results to return (default: 5)").optional()
+    });
+    TOOL_CREATORS = {
+      web_search: createWebSearch,
+      visit_webpage: createVisitWebpage,
+      fetch_json: createFetchJson,
+      run_code: createRunCode,
+      // vector_search uses a stub for schema generation
+      vector_search: () => createVectorSearch(async () => "")
+    };
+  }
+});
+
+// sdk/kv.ts
+function sortAndPaginate(entries, options) {
+  entries.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+  if (options?.reverse) entries.reverse();
+  if (options?.limit && options.limit > 0) {
+    entries.length = Math.min(entries.length, options.limit);
+  }
+  return entries;
+}
+function createMemoryKv() {
+  const store = /* @__PURE__ */ new Map();
+  function isExpired(entry) {
+    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+  }
+  return {
+    get(key) {
+      const entry = store.get(key);
+      if (!entry || isExpired(entry)) {
+        if (entry) store.delete(key);
+        return Promise.resolve(null);
+      }
+      return Promise.resolve(JSON.parse(entry.raw));
+    },
+    set(key, value, options) {
+      const raw = JSON.stringify(value);
+      if (raw.length > MAX_VALUE_SIZE) {
+        throw new Error(`Value exceeds max size of ${MAX_VALUE_SIZE} bytes`);
+      }
+      const expireIn = options?.expireIn;
+      const entry = { raw };
+      if (expireIn && expireIn > 0) {
+        entry.expiresAt = Date.now() + expireIn;
+      }
+      store.set(key, entry);
+      return Promise.resolve();
+    },
+    delete(key) {
+      store.delete(key);
+      return Promise.resolve();
+    },
+    list(prefix, options) {
+      const now = Date.now();
+      const entries = [];
+      for (const [key, entry] of store) {
+        if (entry.expiresAt && entry.expiresAt <= now) {
+          store.delete(key);
+          continue;
+        }
+        if (key.startsWith(prefix)) {
+          entries.push({ key, value: JSON.parse(entry.raw) });
+        }
+      }
+      return Promise.resolve(sortAndPaginate(entries, options));
+    }
+  };
+}
+var MAX_VALUE_SIZE;
+var init_kv = __esm({
+  "sdk/kv.ts"() {
+    "use strict";
+    MAX_VALUE_SIZE = 65536;
+  }
+});
+
+// sdk/s2s.ts
+function uint8ToBase64(bytes) {
+  const CHUNK = 32768;
+  const parts = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode(...bytes.subarray(i, i + CHUNK)));
+  }
+  return btoa(parts.join(""));
+}
+function base64ToUint8(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function connectS2s(opts) {
+  const { apiKey, config, createWebSocket, logger: log = consoleLogger } = opts;
+  return new Promise((resolve, reject) => {
+    log.debug("S2S connecting", { url: config.wssUrl });
+    const ws = createWebSocket(config.wssUrl, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    const target = new EventTarget();
+    let opened = false;
+    function send(msg) {
+      if (ws.readyState !== WS_OPEN) return;
+      const type = msg.type;
+      if (type !== "input.audio") {
+        log.info(`S2S >> ${JSON.stringify(msg)}`);
+      }
+      ws.send(JSON.stringify(msg));
+    }
+    const handle = Object.assign(target, {
+      sendAudio(audio) {
+        send({ type: "input.audio", audio: uint8ToBase64(audio) });
+      },
+      sendToolResult(callId, result) {
+        send({ type: "tool.result", call_id: callId, result });
+      },
+      updateSession(sessionConfig) {
+        send({ type: "session.update", session: sessionConfig });
+      },
+      resumeSession(sessionId) {
+        send({ type: "session.resume", session_id: sessionId });
+      },
+      close() {
+        log.debug("S2S closing");
+        ws.close();
+      }
+    });
+    ws.on("open", () => {
+      opened = true;
+      log.info("S2S WebSocket open");
+      resolve(handle);
+    });
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(data));
+      } catch {
+        return;
+      }
+      const type = msg.type;
+      if (type !== "reply.audio") {
+        log.info(`S2S << ${JSON.stringify(msg)}`);
+      }
+      switch (type) {
+        case "session.ready":
+          target.dispatchEvent(
+            new CustomEvent("ready", {
+              detail: { session_id: msg.session_id }
+            })
+          );
+          break;
+        case "session.updated":
+          target.dispatchEvent(new CustomEvent("session_updated", { detail: msg }));
+          break;
+        case "input.speech.started":
+          target.dispatchEvent(new CustomEvent("speech_started"));
+          break;
+        case "input.speech.stopped":
+          target.dispatchEvent(new CustomEvent("speech_stopped"));
+          break;
+        case "transcript.user.delta":
+          target.dispatchEvent(
+            new CustomEvent("user_transcript_delta", {
+              detail: { text: msg.text }
+            })
+          );
+          break;
+        case "transcript.user":
+          target.dispatchEvent(
+            new CustomEvent("user_transcript", {
+              detail: {
+                item_id: msg.item_id,
+                text: msg.text
+              }
+            })
+          );
+          break;
+        case "reply.started":
+          target.dispatchEvent(
+            new CustomEvent("reply_started", {
+              detail: { reply_id: msg.reply_id }
+            })
+          );
+          break;
+        case "reply.audio": {
+          const audioBytes = base64ToUint8(msg.data);
+          target.dispatchEvent(new CustomEvent("audio", { detail: { audio: audioBytes } }));
+          break;
+        }
+        case "transcript.agent":
+          target.dispatchEvent(
+            new CustomEvent("agent_transcript", {
+              detail: { text: msg.text }
+            })
+          );
+          break;
+        case "tool.call":
+          target.dispatchEvent(
+            new CustomEvent("tool_call", {
+              detail: {
+                call_id: msg.call_id,
+                name: msg.name,
+                args: msg.args ?? {}
+              }
+            })
+          );
+          break;
+        case "reply.done":
+          target.dispatchEvent(
+            new CustomEvent("reply_done", {
+              detail: { status: msg.status ?? void 0 }
+            })
+          );
+          break;
+        case "session.error": {
+          const code = msg.code;
+          const isExpired = code === "session_not_found" || code === "session_forbidden";
+          target.dispatchEvent(
+            new CustomEvent(isExpired ? "session_expired" : "error", {
+              detail: { code, message: msg.message }
+            })
+          );
+          break;
+        }
+      }
+    });
+    ws.on("close", (code, reason) => {
+      log.info("S2S WebSocket closed", {
+        code,
+        reason: reason instanceof Uint8Array ? new TextDecoder().decode(reason) : String(reason ?? "")
+      });
+      target.dispatchEvent(new CustomEvent("close"));
+    });
+    ws.on("error", (err) => {
+      const errObj = err instanceof Error ? err : new Error(String(err));
+      log.error("S2S WebSocket error", { error: errObj.message });
+      if (!opened) {
+        reject(errObj);
+      } else {
+        target.dispatchEvent(
+          new CustomEvent("error", {
+            detail: { code: "ws_error", message: errObj.message }
+          })
+        );
+      }
+    });
+  });
+}
+var WS_OPEN;
+var init_s2s = __esm({
+  "sdk/s2s.ts"() {
+    "use strict";
+    init_runtime();
+    WS_OPEN = 1;
+  }
+});
+
+// sdk/system_prompt.ts
+function buildSystemPrompt(config, opts) {
+  const { hasTools } = opts;
+  const agentInstructions = config.instructions ? `
+
+Agent-Specific Instructions:
+${config.instructions}` : "";
+  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 today = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  return DEFAULT_INSTRUCTIONS + `
+
+Today's date is ${today}.` + agentInstructions + toolPreamble + (opts?.voice ? VOICE_RULES : "");
+}
+var VOICE_RULES;
+var init_system_prompt = __esm({
+  "sdk/system_prompt.ts"() {
+    "use strict";
+    init_types();
+    VOICE_RULES = '\n\nCRITICAL OUTPUT RULES \u2014 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 (-, *, \u2022) 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 \u2014 1 to 3 sentences max';
+  }
+});
+
+// sdk/session.ts
+function createS2sSession(opts) {
+  const {
+    id,
+    agent,
+    client,
+    toolSchemas,
+    apiKey,
+    s2sConfig,
+    executeTool,
+    createWebSocket,
+    hookInvoker,
+    logger: log = consoleLogger,
+    metrics = noopMetrics
+  } = opts;
+  const agentLabel = { agent };
+  const agentConfig = opts.skipGreeting ? { ...opts.agentConfig, greeting: "" } : opts.agentConfig;
+  const hasTools = toolSchemas.length > 0 || (agentConfig.builtinTools?.length ?? 0) > 0;
+  const systemPrompt = buildSystemPrompt(agentConfig, {
+    hasTools,
+    voice: true
+  });
+  const s2sTools = toolSchemas.map((ts) => ({
+    type: "function",
+    name: ts.name,
+    description: ts.description,
+    parameters: ts.parameters
+  }));
+  let s2s = null;
+  const sessionAbort = new AbortController();
+  let audioReady = false;
+  let toolCallCount = 0;
+  let turnPromise = null;
+  let conversationMessages = [];
+  let s2sSessionId = null;
+  let pendingTools = [];
+  async function resolveTurnConfig() {
+    if (!hookInvoker) return null;
+    try {
+      return await hookInvoker.resolveTurnConfig(id, HOOK_TIMEOUT_MS);
+    } catch {
+      return null;
+    }
+  }
+  async function invokeHook(hook, ...args) {
+    if (!hookInvoker) return;
+    try {
+      switch (hook) {
+        case "onConnect":
+          await hookInvoker.onConnect(id, HOOK_TIMEOUT_MS);
+          break;
+        case "onDisconnect":
+          await hookInvoker.onDisconnect(id, HOOK_TIMEOUT_MS);
+          break;
+        case "onTurn":
+          await hookInvoker.onTurn(id, args[0], HOOK_TIMEOUT_MS);
+          break;
+        case "onError":
+          await hookInvoker.onError(id, args[0], HOOK_TIMEOUT_MS);
+          break;
+        case "onStep":
+          await hookInvoker.onStep(id, args[0], HOOK_TIMEOUT_MS);
+          break;
+      }
+    } catch (err) {
+      log.warn(`${hook} hook failed`, {
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  async function handleToolCall(detail) {
+    const { call_id, name, args: parsedArgs } = detail;
+    client.event({
+      type: "tool_call_start",
+      toolCallId: call_id,
+      toolName: name,
+      args: parsedArgs
+    });
+    const turnConfig = await resolveTurnConfig();
+    const maxSteps = turnConfig?.maxSteps ?? agentConfig.maxSteps;
+    toolCallCount++;
+    if (maxSteps !== void 0 && toolCallCount > maxSteps) {
+      log.info("maxSteps exceeded, refusing tool call", {
+        toolCallCount,
+        maxSteps
+      });
+      pendingTools.push({
+        call_id,
+        result: "Maximum tool steps reached. Please respond to the user now."
+      });
+      client.event({ type: "tool_call_done", toolCallId: call_id, result: "" });
+      return;
+    }
+    if (turnConfig?.activeTools && !turnConfig.activeTools.includes(name)) {
+      log.info("Tool filtered by activeTools", { name });
+      const errResult = JSON.stringify({
+        error: `Tool "${name}" is not available at this step.`
+      });
+      pendingTools.push({ call_id, result: errResult });
+      client.event({
+        type: "tool_call_done",
+        toolCallId: call_id,
+        result: errResult
+      });
+      return;
+    }
+    invokeHook("onStep", {
+      stepNumber: toolCallCount - 1,
+      toolCalls: [{ toolName: name, args: parsedArgs }],
+      text: ""
+    });
+    log.info("S2S tool call", { tool: name, call_id, args: parsedArgs, agent });
+    let result;
+    try {
+      result = await executeTool(name, parsedArgs, id, conversationMessages);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.error("Tool execution failed", { tool: name, error: msg });
+      result = JSON.stringify({ error: msg });
+    }
+    log.info("S2S tool result", {
+      tool: name,
+      call_id,
+      resultLength: result.length
+    });
+    pendingTools.push({ call_id, result });
+    client.event({ type: "tool_call_done", toolCallId: call_id, result });
+  }
+  async function connectAndSetup() {
+    try {
+      const handle = await _internals3.connectS2s({
+        apiKey,
+        config: s2sConfig,
+        createWebSocket,
+        logger: log
+      });
+      if (s2sSessionId) {
+        log.info("Attempting S2S session resume", {
+          session_id: s2sSessionId
+        });
+        handle.resumeSession(s2sSessionId);
+      }
+      handle.updateSession({
+        system_prompt: systemPrompt,
+        tools: s2sTools
+      });
+      handle.addEventListener("ready", ((e) => {
+        s2sSessionId = e.detail.session_id;
+        log.info("S2S session ready", { session_id: s2sSessionId });
+      }));
+      handle.addEventListener("session_expired", (() => {
+        log.info("S2S session expired, reconnecting fresh");
+        s2sSessionId = null;
+        handle.close();
+      }));
+      handle.addEventListener("speech_started", () => {
+        client.event({ type: "speech_started" });
+      });
+      handle.addEventListener("speech_stopped", () => {
+        client.event({ type: "speech_stopped" });
+      });
+      handle.addEventListener("user_transcript_delta", ((e) => {
+        client.event({
+          type: "transcript",
+          text: e.detail.text,
+          isFinal: false
+        });
+      }));
+      handle.addEventListener("user_transcript", ((e) => {
+        const { text } = e.detail;
+        log.info("S2S user transcript", { text });
+        client.event({ type: "transcript", text, isFinal: true });
+        client.event({ type: "turn", text });
+        conversationMessages.push({ role: "user", content: text });
+        invokeHook("onTurn", text);
+      }));
+      handle.addEventListener("reply_started", () => {
+        toolCallCount = 0;
+      });
+      handle.addEventListener("audio", ((e) => {
+        client.playAudioChunk(e.detail.audio);
+      }));
+      handle.addEventListener("agent_transcript", ((e) => {
+        const { text } = e.detail;
+        client.event({ type: "chat", text });
+        conversationMessages.push({ role: "assistant", content: text });
+      }));
+      handle.addEventListener("tool_call", ((e) => {
+        const p = handleToolCall(e.detail).catch((err) => {
+          log.error("Tool call handler failed", {
+            err: err instanceof Error ? err.message : String(err)
+          });
+        });
+        const prev = turnPromise;
+        turnPromise = (prev ?? Promise.resolve()).then(() => p).finally(() => {
+          turnPromise = null;
+        });
+      }));
+      handle.addEventListener("reply_done", ((e) => {
+        if (e.detail.status === "interrupted") {
+          log.info("S2S reply interrupted (barge-in)");
+          pendingTools = [];
+          client.event({ type: "cancelled" });
+        } else {
+          if (pendingTools.length > 0) {
+            for (const tool of pendingTools) {
+              s2s?.sendToolResult(tool.call_id, tool.result);
+            }
+            pendingTools = [];
+          } else {
+            client.playAudioDone();
+            client.event({ type: "tts_done" });
+          }
+        }
+      }));
+      handle.addEventListener("error", ((e) => {
+        log.error("S2S error", {
+          code: e.detail.code,
+          message: e.detail.message
+        });
+        client.event({
+          type: "error",
+          code: "internal",
+          message: e.detail.message
+        });
+      }));
+      handle.addEventListener("close", () => {
+        log.info("S2S closed");
+        s2s = null;
+        if (!sessionAbort.signal.aborted) {
+          log.info("Attempting S2S reconnect");
+          connectAndSetup().catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error("S2S reconnect failed", { error: msg });
+          });
+        }
+      });
+      s2s = handle;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.error("S2S connect failed", { error: msg });
+      client.event({ type: "error", code: "internal", message: msg });
+    }
+  }
+  return {
+    async start() {
+      metrics.sessionsTotal.inc(agentLabel);
+      metrics.sessionsActive.inc(agentLabel);
+      invokeHook("onConnect");
+      await connectAndSetup();
+    },
+    async stop() {
+      if (sessionAbort.signal.aborted) return;
+      sessionAbort.abort();
+      metrics.sessionsActive.dec(agentLabel);
+      if (turnPromise) await turnPromise;
+      s2s?.close();
+      invokeHook("onDisconnect");
+    },
+    onAudio(data) {
+      s2s?.sendAudio(data);
+    },
+    onAudioReady() {
+      if (audioReady) return;
+      audioReady = true;
+      if (agentConfig.greeting && s2s) {
+        s2s.updateSession({
+          system_prompt: systemPrompt,
+          tools: s2sTools,
+          greeting: agentConfig.greeting
+        });
+      }
+    },
+    onCancel() {
+      client.event({ type: "cancelled" });
+    },
+    onReset() {
+      conversationMessages = [];
+      toolCallCount = 0;
+      pendingTools = [];
+      s2sSessionId = null;
+      s2s?.close();
+      client.event({ type: "reset" });
+    },
+    onHistory(incoming) {
+      for (const msg of incoming) {
+        conversationMessages.push({ role: msg.role, content: msg.text });
+      }
+    },
+    waitForTurn() {
+      return turnPromise ?? Promise.resolve();
+    }
+  };
+}
+var _internals3;
+var init_session = __esm({
+  "sdk/session.ts"() {
+    "use strict";
+    init_protocol();
+    init_runtime();
+    init_s2s();
+    init_system_prompt();
+    _internals3 = {
+      connectS2s
+    };
+  }
+});
+
+// sdk/worker_entry.ts
+import { z as z4 } from "zod";
+async function executeToolCall(name, args, options) {
+  const { tool, env, sessionId, state, kv, messages } = options;
+  const schema = tool.parameters ?? z4.object({});
+  const parsed = schema.safeParse(args);
+  if (!parsed.success) {
+    const issues = (parsed.error?.issues ?? []).map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join(", ");
+    return `Error: Invalid arguments for tool "${name}": ${issues}`;
+  }
+  try {
+    const abortSignal = AbortSignal.timeout(TOOL_HANDLER_TIMEOUT);
+    const envCopy = { ...env };
+    const ctx = {
+      sessionId: sessionId ?? "",
+      env: envCopy,
+      abortSignal,
+      state: state ?? {},
+      get kv() {
+        if (!kv) throw new Error("KV not available");
+        return kv;
+      },
+      messages: messages ?? []
+    };
+    const result = await Promise.resolve(tool.execute(parsed.data, ctx));
+    if (result == null) return "null";
+    return typeof result === "string" ? result : JSON.stringify(result);
+  } catch (err) {
+    if (err instanceof DOMException && err.name === "TimeoutError") {
+      console.warn(`[tool-executor] Tool execution timed out: ${name}`);
+      return `Error: Tool "${name}" timed out after ${TOOL_HANDLER_TIMEOUT}ms`;
+    }
+    console.warn(`[tool-executor] Tool execution failed: ${name}`, err);
+    return `Error: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}
+var TOOL_HANDLER_TIMEOUT;
+var init_worker_entry = __esm({
+  "sdk/worker_entry.ts"() {
+    "use strict";
+    TOOL_HANDLER_TIMEOUT = 3e4;
+  }
+});
+
+// sdk/direct_executor.ts
+function buildAgentConfig(agent) {
+  const config = {
+    name: agent.name,
+    instructions: agent.instructions,
+    greeting: agent.greeting,
+    voice: agent.voice
+  };
+  if (agent.sttPrompt !== void 0) config.sttPrompt = agent.sttPrompt;
+  if (typeof agent.maxSteps !== "function") config.maxSteps = agent.maxSteps;
+  if (agent.toolChoice !== void 0) config.toolChoice = agent.toolChoice;
+  if (agent.builtinTools) config.builtinTools = [...agent.builtinTools];
+  if (agent.activeTools) config.activeTools = [...agent.activeTools];
+  return config;
+}
+function createDirectExecutor(opts) {
+  const {
+    agent,
+    env,
+    kv = createMemoryKv(),
+    vectorSearch,
+    createWebSocket,
+    logger = consoleLogger,
+    metrics = noopMetrics,
+    s2sConfig = DEFAULT_S2S_CONFIG
+  } = opts;
+  const agentConfig = buildAgentConfig(agent);
+  const builtinDefs = getBuiltinToolDefs(
+    agent.builtinTools ?? [],
+    vectorSearch ? { vectorSearch } : void 0
+  );
+  const allTools = {
+    ...builtinDefs,
+    ...agent.tools
+  };
+  const customSchemas = agentToolsToSchemas(agent.tools ?? {});
+  const builtinSchemas = getBuiltinToolSchemas(agent.builtinTools ?? []);
+  const toolSchemas = [...customSchemas, ...builtinSchemas];
+  const sessionState = /* @__PURE__ */ new Map();
+  const frozenEnv = Object.freeze({ ...env });
+  function getState(sessionId) {
+    if (!sessionState.has(sessionId) && agent.state) {
+      sessionState.set(sessionId, agent.state());
+    }
+    return sessionState.get(sessionId) ?? {};
+  }
+  function makeHookContext(sessionId) {
+    return {
+      sessionId,
+      env: frozenEnv,
+      state: getState(sessionId),
+      get kv() {
+        return kv;
+      }
+    };
+  }
+  const executeTool = async (name, args, sessionId, messages) => {
+    const tool = allTools[name];
+    if (!tool) return JSON.stringify({ error: `Unknown tool: ${name}` });
+    return executeToolCall(name, args, {
+      tool,
+      env: frozenEnv,
+      sessionId,
+      state: getState(sessionId ?? ""),
+      kv,
+      messages
+    });
+  };
+  const hookInvoker = {
+    async onConnect(sessionId) {
+      await agent.onConnect?.(makeHookContext(sessionId));
+    },
+    async onDisconnect(sessionId) {
+      await agent.onDisconnect?.(makeHookContext(sessionId));
+      sessionState.delete(sessionId);
+    },
+    async onTurn(sessionId, text) {
+      await agent.onTurn?.(text, makeHookContext(sessionId));
+    },
+    async onError(sessionId, error3) {
+      await agent.onError?.(new Error(error3.message), makeHookContext(sessionId));
+    },
+    async onStep(sessionId, step2) {
+      await agent.onStep?.(step2, makeHookContext(sessionId));
+    },
+    async resolveTurnConfig(sessionId) {
+      const ctx = makeHookContext(sessionId);
+      let maxSteps;
+      let activeTools;
+      if (typeof agent.maxSteps === "function") {
+        maxSteps = await agent.maxSteps(ctx) ?? void 0;
+      }
+      if (agent.onBeforeStep) {
+        const result = await agent.onBeforeStep(0, ctx);
+        activeTools = result?.activeTools;
+      }
+      if (maxSteps === void 0 && activeTools === void 0) return null;
+      const config = {};
+      if (maxSteps !== void 0) config.maxSteps = maxSteps;
+      if (activeTools !== void 0) config.activeTools = activeTools;
+      return config;
+    }
+  };
+  function createSession(sessionOpts) {
+    if (!createWebSocket) {
+      throw new Error("createWebSocket not provided \u2014 pass it in DirectExecutorOptions");
+    }
+    const apiKey = frozenEnv.ASSEMBLYAI_API_KEY ?? "";
+    return createS2sSession({
+      id: sessionOpts.id,
+      agent: sessionOpts.agent,
+      client: sessionOpts.client,
+      agentConfig,
+      toolSchemas,
+      apiKey,
+      s2sConfig,
+      executeTool,
+      createWebSocket,
+      hookInvoker,
+      skipGreeting: sessionOpts.skipGreeting ?? false,
+      logger,
+      metrics
+    });
+  }
+  return { executeTool, hookInvoker, toolSchemas, createSession };
+}
+var init_direct_executor = __esm({
+  "sdk/direct_executor.ts"() {
+    "use strict";
+    init_internal_types();
+    init_builtin_tools();
+    init_kv();
+    init_runtime();
+    init_session();
+    init_worker_entry();
+  }
+});
+
+// sdk/ws_handler.ts
+function isValidAudioChunk(data) {
+  return data.byteLength > 0 && data.byteLength <= MAX_AUDIO_CHUNK_BYTES && data.byteLength % 2 === 0;
+}
+function createClientSink(ws) {
+  return {
+    get open() {
+      return ws.readyState === 1;
+    },
+    event(e) {
+      if (ws.readyState === 1) {
+        ws.send(JSON.stringify(e));
+      }
+    },
+    playAudioChunk(chunk) {
+      if (ws.readyState === 1) {
+        ws.send(chunk);
+      }
+    },
+    playAudioDone() {
+      if (ws.readyState === 1) {
+        ws.send(JSON.stringify({ type: "audio_done" }));
+      }
+    }
+  };
+}
+function wireSessionSocket(ws, opts) {
+  const { sessions, logger: log = consoleLogger } = opts;
+  const sessionId = crypto.randomUUID();
+  const sid = sessionId.slice(0, 8);
+  const ctx = opts.logContext ?? {};
+  let session = null;
+  ws.addEventListener("open", () => {
+    opts.onOpen?.();
+    log.info("Session connected", { ...ctx, sid });
+    const client = createClientSink(ws);
+    session = opts.createSession(sessionId, client);
+    sessions.set(sessionId, session);
+    ws.send(JSON.stringify({ type: "config", ...opts.readyConfig }));
+    void session.start();
+    log.info("Session ready", { ...ctx, sid });
+  });
+  ws.addEventListener("message", (event) => {
+    if (!session) return;
+    const msgEvent = event;
+    const { data } = msgEvent;
+    if (data instanceof ArrayBuffer) {
+      const chunk = new Uint8Array(data);
+      if (!isValidAudioChunk(chunk)) {
+        log.warn("Invalid audio chunk, dropping", {
+          ...ctx,
+          sid,
+          bytes: chunk.byteLength,
+          aligned: chunk.byteLength % 2 === 0
+        });
+        return;
+      }
+      session.onAudio(chunk);
+      return;
+    }
+    if (typeof data !== "string") return;
+    let json;
+    try {
+      json = JSON.parse(data);
+    } catch {
+      log.warn("Invalid JSON from client", { ...ctx, sid });
+      return;
+    }
+    const parsed = ClientMessageSchema.safeParse(json);
+    if (!parsed.success) {
+      log.warn("Invalid client message", {
+        ...ctx,
+        sid,
+        error: parsed.error.message
+      });
+      return;
+    }
+    const msg = parsed.data;
+    switch (msg.type) {
+      case "audio_ready":
+        session.onAudioReady();
+        break;
+      case "cancel":
+        session.onCancel();
+        break;
+      case "reset":
+        session.onReset();
+        break;
+      case "history":
+        session.onHistory(msg.messages);
+        break;
+    }
+  });
+  ws.addEventListener("close", () => {
+    log.info("Session disconnected", { ...ctx, sid });
+    if (session) {
+      void session.stop().finally(() => {
+        sessions.delete(sessionId);
+      });
+    }
+    opts.onClose?.();
+  });
+  ws.addEventListener("error", (event) => {
+    const msg = event instanceof ErrorEvent ? event.message : "WebSocket error";
+    log.error("WebSocket error", { ...ctx, sid, error: msg });
+  });
+}
+var MAX_AUDIO_CHUNK_BYTES;
+var init_ws_handler = __esm({
+  "sdk/ws_handler.ts"() {
+    "use strict";
+    init_protocol();
+    init_runtime();
+    MAX_AUDIO_CHUNK_BYTES = 1048576;
+  }
+});
+
+// sdk/winterc_server.ts
+function createWintercServer(options) {
+  const {
+    agent,
+    env,
+    kv = createMemoryKv(),
+    vectorSearch,
+    clientHtml,
+    logger = consoleLogger,
+    metrics = noopMetrics,
+    s2sConfig = DEFAULT_S2S_CONFIG
+  } = options;
+  const executor = createDirectExecutor({
+    agent,
+    env,
+    kv,
+    ...vectorSearch ? { vectorSearch } : {},
+    createWebSocket: options.createWebSocket,
+    logger,
+    metrics,
+    s2sConfig
+  });
+  const sessions = /* @__PURE__ */ new Map();
+  const readyConfig = {
+    protocolVersion: PROTOCOL_VERSION,
+    audioFormat: AUDIO_FORMAT,
+    sampleRate: s2sConfig.inputSampleRate,
+    ttsSampleRate: s2sConfig.outputSampleRate,
+    mode: "s2s"
+  };
+  return {
+    async fetch(request) {
+      const url = new URL(request.url);
+      if (url.pathname === "/health") {
+        return new Response(JSON.stringify({ status: "ok", name: agent.name }), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      if (url.pathname === "/" && clientHtml) {
+        return new Response(clientHtml, {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+      if (url.pathname === "/") {
+        return new Response(
+          `<!DOCTYPE html><html><body><h1>${agent.name}</h1><p>Agent server running.</p></body></html>`,
+          { headers: { "Content-Type": "text/html" } }
+        );
+      }
+      return new Response("Not Found", { status: 404 });
+    },
+    handleWebSocket(ws, wsOpts) {
+      wireSessionSocket(ws, {
+        sessions,
+        createSession: (sid, client) => executor.createSession({
+          id: sid,
+          agent: agent.name,
+          client,
+          skipGreeting: wsOpts?.skipGreeting ?? false
+        }),
+        readyConfig,
+        logger
+      });
+    },
+    async close() {
+      for (const session of sessions.values()) {
+        await session.stop();
+      }
+      sessions.clear();
+    }
+  };
+}
+var init_winterc_server = __esm({
+  "sdk/winterc_server.ts"() {
+    "use strict";
+    init_direct_executor();
+    init_kv();
+    init_protocol();
+    init_runtime();
+    init_ws_handler();
+  }
+});
+
+// sdk/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer
+});
+async function loadWsFactory() {
+  try {
+    const mod = await import("ws");
+    const WS = mod.default ?? mod;
+    return (url, opts) => new WS(url, { headers: opts.headers });
+  } catch {
+    throw new Error(
+      "WebSocket factory not provided and `ws` package not found. Install `ws` (`npm install ws`) or pass `createWebSocket` option."
+    );
+  }
+}
+function resolveEnv(env) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) resolved[key] = value;
+  }
+  return resolved;
+}
+function createServer(options) {
+  const { agent, kv, clientHtml, logger = consoleLogger, s2sConfig = DEFAULT_S2S_CONFIG } = options;
+  const env = resolveEnv(
+    options.env ?? (typeof process !== "undefined" ? process.env : {})
+  );
+  let wsFactory = options.createWebSocket ?? null;
+  async function getWsFactory() {
+    if (!wsFactory) {
+      wsFactory = await loadWsFactory();
+    }
+    return wsFactory;
+  }
+  let winterc = null;
+  function getWinterc() {
+    if (!winterc) {
+      winterc = createWintercServer({
+        agent,
+        env,
+        ...kv ? { kv } : {},
+        createWebSocket: wsFactory,
+        clientHtml,
+        logger,
+        s2sConfig
+      });
+    }
+    return winterc;
+  }
+  let serverHandle = null;
+  return {
+    fetch(request) {
+      return getWinterc().fetch(request);
+    },
+    async listen(port = 3e3) {
+      await getWsFactory();
+      const http = await import("node:http");
+      const nodeServer = http.createServer(async (req, res) => {
+        try {
+          const protocol = req.socket.encrypted ? "https" : "http";
+          const host = req.headers.host ?? `localhost:${port}`;
+          const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+          const headers = new Headers();
+          for (const [key, val] of Object.entries(req.headers)) {
+            if (val) headers.set(key, Array.isArray(val) ? val[0] : val);
+          }
+          const request = new Request(url, {
+            method: req.method ?? "GET",
+            headers
+          });
+          const response = await getWinterc().fetch(request);
+          res.writeHead(response.status, Object.fromEntries(response.headers));
+          const body = await response.text();
+          res.end(body);
+        } catch (err) {
+          res.writeHead(500);
+          res.end(err instanceof Error ? err.message : "Internal Server Error");
+        }
+      });
+      try {
+        const wsMod = await import("ws");
+        const WSServer = wsMod.WebSocketServer ?? wsMod.default?.Server;
+        if (WSServer) {
+          const wss = new WSServer({ noServer: true });
+          nodeServer.on("upgrade", (req, socket, head) => {
+            wss.handleUpgrade(
+              req,
+              socket,
+              head,
+              (ws) => {
+                const reqUrl = new URL(
+                  req.url ?? "/",
+                  `http://localhost:${port}`
+                );
+                const resume = reqUrl.searchParams.has("resume");
+                getWinterc().handleWebSocket(ws, { skipGreeting: resume });
+              }
+            );
+          });
+        }
+      } catch {
+        logger.warn("ws package not available for Node.js WebSocket upgrade");
+      }
+      await new Promise((resolve) => {
+        nodeServer.listen(port, () => {
+          logger.info(`Agent "${agent.name}" listening on http://localhost:${port}`);
+          resolve();
+        });
+      });
+      serverHandle = {
+        async shutdown() {
+          await new Promise((resolve, reject) => {
+            nodeServer.close((err) => err ? reject(err) : resolve());
+          });
+        }
+      };
+    },
+    async close() {
+      await winterc?.close();
+      await serverHandle?.shutdown();
+    }
+  };
+}
+var init_server = __esm({
+  "sdk/server.ts"() {
+    init_runtime();
+    init_winterc_server();
+  }
+});
+
+// cli/cli.ts
+import { readFileSync } from "node:fs";
+import path11 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import minimist7 from "minimist";
+
+// cli/_help.ts
+init_colors();
+import chalk2 from "chalk";
+function rootHelp(version) {
+  const lines = [];
+  lines.push("");
+  lines.push(
+    `  ${primary(chalk2.bold(" \u2584\u2580\u2588 \u2584\u2580\u2588 \u2588"))}   ${chalk2.dim("Voice agent development kit")}`
+  );
+  lines.push(`  ${primary(chalk2.bold(" \u2588\u2580\u2588 \u2588\u2580\u2588 \u2588"))}   ${primary(`v${version}`)}`);
+  lines.push("");
+  lines.push(
+    `  ${chalk2.bold(interactive("Usage"))}   ${primary("aai")} ${chalk2.dim("<command> [options]")}`
+  );
+  lines.push("");
+  lines.push(`  ${chalk2.bold(interactive("Commands"))}`);
+  lines.push("");
+  const cmds = [
+    ["init", "[dir]", "Scaffold a new agent project"],
+    ["dev", "", "Start a local development server"],
+    ["deploy", "", "Bundle and deploy to production"],
+    ["start", "", "Start production server from build"],
+    ["secret", "<cmd>", "Manage secrets"],
+    ["rag", "<url>", "Ingest a site into the vector store"]
+  ];
+  for (const [name, args, desc] of cmds) {
+    const nameStr = interactive(name.padEnd(8));
+    const argsStr = args ? primary(args.padEnd(6)) : "      ";
+    lines.push(`    ${nameStr} ${argsStr} ${chalk2.dim(desc)}`);
+  }
+  lines.push("");
+  lines.push(`  ${chalk2.bold(interactive("Options"))}`);
+  lines.push("");
+  lines.push(
+    `    ${interactive("-h")}${chalk2.dim(",")} ${interactive("--help")}      ${chalk2.dim(
+      "Show this help"
+    )}`
+  );
+  lines.push(
+    `    ${interactive("-V")}${chalk2.dim(",")} ${interactive("--version")}   ${chalk2.dim(
+      "Show the version number"
+    )}`
+  );
+  lines.push("");
+  lines.push(`  ${chalk2.bold(interactive("Getting started"))}`);
+  lines.push("");
+  lines.push(
+    `    ${chalk2.dim("$")} ${primary("aai init")} ${interactive("my-agent")}    ${chalk2.dim(
+      "Create a new agent"
+    )}`
+  );
+  lines.push(`    ${chalk2.dim("$")} ${primary("cd my-agent")}`);
+  lines.push(
+    `    ${chalk2.dim("$")} ${primary("aai deploy")}          ${chalk2.dim("Deploy to production")}`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function subcommandHelp(cmd, version) {
+  const lines = [];
+  lines.push("");
+  lines.push(
+    `  ${primary(chalk2.bold("aai"))} ${interactive(chalk2.bold(cmd.name))}${version ? chalk2.dim(`  v${version}`) : ""}`
+  );
+  lines.push(`  ${chalk2.dim(cmd.description)}`);
+  lines.push("");
+  if (cmd.args && cmd.args.length > 0) {
+    lines.push(`  ${chalk2.bold(interactive("Arguments"))}`);
+    lines.push("");
+    for (const arg of cmd.args) {
+      const label = arg.optional ? primary(`[${arg.name}]`) : primary(`<${arg.name}>`);
+      lines.push(`    ${label}`);
+    }
+    lines.push("");
+  }
+  const visibleOptions = (cmd.options ?? []).filter((o) => !o.hidden);
+  if (visibleOptions.length > 0) {
+    lines.push(`  ${chalk2.bold(interactive("Options"))}`);
+    lines.push("");
+    for (const opt of visibleOptions) {
+      lines.push(`    ${interactive(opt.flags)}`);
+      lines.push(`      ${chalk2.dim(opt.description)}`);
+    }
+    lines.push(`    ${interactive("-h")}${chalk2.dim(",")} ${interactive("--help")}`);
+    lines.push(`      ${chalk2.dim("Show this help")}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// cli/cli.ts
+init_output();
+
+// cli/deploy.tsx
+import path6 from "node:path";
+import minimist2 from "minimist";
+
+// cli/_discover.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { humanId } from "human-id";
+
+// cli/_exec.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+
+// cli/_discover.ts
+init_output();
+
+// cli/_prompts.tsx
+import { ConfirmInput, PasswordInput, Select } from "@inkjs/ui";
+import { Box, render, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+async function askPassword(message) {
+  return new Promise((resolve) => {
+    const app = render(
+      /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          message,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx(
+          PasswordInput,
+          {
+            onSubmit: (value) => {
+              resolve(value);
+              app.unmount();
+            }
+          }
+        )
+      ] })
+    );
+  });
+}
+async function askSelect(message, choices) {
+  return new Promise((resolve) => {
+    const app = render(
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(Text, { children: message }),
+        /* @__PURE__ */ jsx(
+          Select,
+          {
+            options: choices,
+            onChange: (value) => {
+              resolve(value);
+              app.unmount();
+            }
+          }
+        )
+      ] })
+    );
+  });
+}
+
+// cli/_discover.ts
+function isDevMode() {
+  return path.basename(process.argv[0] ?? "") !== "aai";
+}
+function generateSlug() {
+  return humanId({ separator: "-", capitalize: false });
+}
+var CONFIG_DIR = path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "aai");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+async function readAuthConfig() {
+  try {
+    return JSON.parse(await fs.readFile(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function writeAuthConfig(config) {
+  await fs.mkdir(CONFIG_DIR, { recursive: true });
+  await fs.writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
+`);
+  if (process.platform !== "win32") {
+    await fs.chmod(CONFIG_FILE, 384);
+  }
+}
+async function getApiKey() {
+  const config = await readAuthConfig();
+  if (config.assemblyai_api_key) {
+    process.env.ASSEMBLYAI_API_KEY = config.assemblyai_api_key;
+    return config.assemblyai_api_key;
+  }
+  step("Setup", "AssemblyAI API key required for speech-to-text");
+  console.log("Get one at https://www.assemblyai.com/dashboard/signup\n");
+  let key;
+  while (!key) {
+    key = await askPassword("ASSEMBLYAI_API_KEY");
+  }
+  config.assemblyai_api_key = key;
+  process.env.ASSEMBLYAI_API_KEY = key;
+  await writeAuthConfig(config);
+  step("Saved", CONFIG_FILE);
+  return key;
+}
+async function readProjectConfig(agentDir) {
+  try {
+    return JSON.parse(await fs.readFile(path.join(agentDir, ".aai", "project.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function writeProjectConfig(agentDir, data) {
+  const aaiDir = path.join(agentDir, ".aai");
+  await fs.mkdir(aaiDir, { recursive: true });
+  await fs.writeFile(path.join(aaiDir, "project.json"), `${JSON.stringify(data, null, 2)}
+`);
+}
+var DEFAULT_SERVER = "https://aai-agent.fly.dev";
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadAgent(dir) {
+  const hasAgentTs = await fileExists(path.join(dir, "agent.ts"));
+  if (!hasAgentTs) return null;
+  const config = await readProjectConfig(dir);
+  const slug = config?.slug ?? generateSlug();
+  const clientEntry = await fileExists(path.join(dir, "client.tsx")) ? path.join(dir, "client.tsx") : "";
+  return {
+    slug,
+    dir,
+    entryPoint: path.join(dir, "agent.ts"),
+    env: {},
+    clientEntry,
+    transport: ["websocket"]
+  };
+}
+async function ensureClaudeMd(targetDir) {
+  const claudePath = path.join(targetDir, "CLAUDE.md");
+  const cliDir2 = path.dirname(fileURLToPath(import.meta.url));
+  const srcPath = path.join(cliDir2, "..", "templates", "_shared", "CLAUDE.md");
+  const srcContent = await fs.readFile(srcPath, "utf-8");
+  let existing = "";
+  try {
+    existing = await fs.readFile(claudePath, "utf-8");
+  } catch {
+  }
+  if (existing !== srcContent) {
+    await fs.writeFile(claudePath, srcContent);
+    step(existing ? "Updated" : "Wrote", "CLAUDE.md \u2014 aai agent API reference");
+  }
+}
+async function ensureDependencies(targetDir) {
+  if (!await fileExists(path.join(targetDir, "node_modules"))) {
+    step("Install", "dependencies");
+    try {
+      await execFileAsync("npm", ["install"], { cwd: targetDir });
+    } catch {
+      step("Skip", "npm install failed");
+    }
+  }
+}
+
+// cli/_deploy.ts
+init_output();
+var _internals = {
+  fetch: globalThis.fetch.bind(globalThis)
+};
+async function attemptDeploy(url, slug, apiKey, env, transport, worker, html, config, toolSchemas) {
+  return await _internals.fetch(`${url}/${slug}/deploy`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      env,
+      worker,
+      html,
+      transport,
+      config,
+      toolSchemas
+    })
+  });
+}
+var MAX_RETRIES = 20;
+async function runDeploy(opts) {
+  const manifest = JSON.parse(opts.bundle.manifest);
+  const worker = opts.bundle.worker;
+  const html = opts.bundle.html;
+  const transport = manifest.transport ?? ["websocket"];
+  const config = manifest.config;
+  const toolSchemas = manifest.toolSchemas;
+  let slug = opts.slug;
+  if (opts.dryRun) {
+    stepInfo("Dry run", "would deploy:");
+    info(`${slug} -> ${opts.url}/${slug}`);
+    return { slug };
+  }
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    const resp = await attemptDeploy(
+      opts.url,
+      slug,
+      opts.apiKey,
+      opts.env,
+      transport,
+      worker,
+      html,
+      config,
+      toolSchemas
+    );
+    if (resp.ok) {
+      step("Deploy", `${slug} -> ${opts.url}/${slug}`);
+      try {
+        const healthResp = await _internals.fetch(`${opts.url}/${slug}/health`);
+        const ok = healthResp.ok && (await healthResp.json()).status === "ok";
+        if (ok) {
+          step("Ready", slug);
+        } else {
+          warn(`${slug} deployed but health check failed -- check for runtime errors`);
+        }
+      } catch {
+      }
+      return { slug };
+    }
+    if (resp.status === 403) {
+      const text2 = await resp.text();
+      if (text2.includes("Slug")) {
+        const next = generateSlug();
+        step("Retry", `slug "${slug}" taken, trying "${next}"`);
+        slug = next;
+        continue;
+      }
+    }
+    const text = await resp.text();
+    throw new Error(`deploy failed (${resp.status}): ${text}`);
+  }
+  throw new Error(`deploy failed: could not find available slug after ${MAX_RETRIES} attempts`);
+}
+
+// cli/_ink.tsx
+import { Spinner } from "@inkjs/ui";
+import { Box as Box2, render as render2, Static, Text as Text2, useApp } from "ink";
+import React, { useRef, useState } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var PAD2 = 9;
+var PRIMARY = "#fab283";
+var INTERACTIVE = "#9dbefe";
+var ERROR_COLOR = "#fc533a";
+var WARNING_COLOR = "#fcd53a";
+function Step({ action, msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: PRIMARY, children: action.padStart(PAD2) }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      " ",
+      msg
+    ] })
+  ] });
+}
+function StepInfo({ action, msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: INTERACTIVE, children: action.padStart(PAD2) }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      " ",
+      msg
+    ] })
+  ] });
+}
+function Info({ msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+    " ".repeat(PAD2 + 1),
+    msg
+  ] });
+}
+function Detail({ msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    " ".repeat(PAD2 + 1),
+    msg
+  ] });
+}
+function Warn({ msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: WARNING_COLOR, children: "warning".padStart(PAD2) }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      " ",
+      msg
+    ] })
+  ] });
+}
+function ErrorLine({ msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: ERROR_COLOR, children: "error" }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      ": ",
+      msg
+    ] })
+  ] });
+}
+function StepLog({ items }) {
+  return /* @__PURE__ */ jsx2(Static, { items, children: (item) => /* @__PURE__ */ jsx2(Box2, { children: item.node }, item.id) });
+}
+function TaskSpinner({ label }) {
+  return /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { children: " ".repeat(PAD2 + 1) }),
+    /* @__PURE__ */ jsx2(Spinner, { label })
+  ] });
+}
+function useStepLog() {
+  const [items, setItems] = useState([]);
+  const nextId = useRef(0);
+  const log = (node) => {
+    const id = nextId.current++;
+    setItems((prev) => [...prev, { id, node }]);
+  };
+  return { items, log };
+}
+function CommandRunner({
+  run,
+  spinnerLabel,
+  onError
+}) {
+  const { exit } = useApp();
+  const { items, log } = useStepLog();
+  const [spinning, setSpinning] = useState(true);
+  const [err, setErr] = useState(null);
+  React.useEffect(() => {
+    (async () => {
+      try {
+        await run(log);
+      } catch (e) {
+        const error3 = e instanceof Error ? e : new Error(String(e));
+        setErr(error3.message);
+        onError?.(error3);
+      }
+      setSpinning(false);
+      exit();
+    })();
+  }, [exit, log, onError, run]);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsx2(StepLog, { items }),
+    err && /* @__PURE__ */ jsx2(ErrorLine, { msg: err }),
+    spinning && /* @__PURE__ */ jsx2(TaskSpinner, { label: spinnerLabel ?? "" })
+  ] });
+}
+async function runWithInk(label, fn) {
+  let thrownError;
+  const app = render2(
+    /* @__PURE__ */ jsx2(
+      CommandRunner,
+      {
+        spinnerLabel: label,
+        onError: (e) => {
+          thrownError = e;
+        },
+        run: fn
+      }
+    )
+  );
+  await app.waitUntilExit();
+  if (thrownError) throw thrownError;
+}
+
+// cli/build.ts
+import fs4 from "node:fs/promises";
+import path3 from "node:path";
+
+// cli/_bundler.ts
+import fs3 from "node:fs/promises";
+import path2 from "node:path";
+import preact from "@preact/preset-vite";
+import tailwindcss from "@tailwindcss/vite";
+import { build } from "vite";
+import { viteSingleFile } from "vite-plugin-singlefile";
+
+// cli/_static_config.ts
+init_types();
+import fs2 from "node:fs/promises";
+import {
+  Project,
+  SyntaxKind
+} from "ts-morph";
+var project = new Project({ useInMemoryFileSystem: true });
+async function extractStaticConfig(agentPath) {
+  const source = await fs2.readFile(agentPath, "utf-8");
+  return extractStaticConfigFromSource(source, agentPath);
+}
+function extractStaticConfigFromSource(source, fileName = "agent.ts") {
+  const sf = project.createSourceFile(fileName, source, { overwrite: true });
+  const call = findDefineAgentCall(sf);
+  if (!call) {
+    throw new BundleError(
+      `Could not find a defineAgent({...}) call in ${fileName}. Make sure your agent.ts has \`export default defineAgent({...})\`.`
+    );
+  }
+  const args = call.getArguments();
+  const arg = args[0];
+  if (!arg || !arg.isKind(SyntaxKind.ObjectLiteralExpression)) {
+    throw new BundleError("The argument to defineAgent() must be an inline object literal");
+  }
+  const obj = arg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  const config = extractConfig(obj, fileName);
+  const toolSchemas = extractToolSchemas(obj, fileName);
+  return { config, toolSchemas };
+}
+function findDefineAgentCall(sf) {
+  return sf.getFirstDescendant((node) => {
+    if (!node.isKind(SyntaxKind.CallExpression)) return false;
+    const expr = node.getExpression();
+    return expr.isKind(SyntaxKind.Identifier) && expr.getText() === "defineAgent";
+  });
+}
+function extractConfig(obj, fileName) {
+  const name = requireString(obj, "name", fileName);
+  const config = {
+    name,
+    instructions: optionalString(obj, "instructions", fileName) ?? DEFAULT_INSTRUCTIONS,
+    greeting: optionalString(obj, "greeting", fileName) ?? DEFAULT_GREETING,
+    voice: optionalString(obj, "voice", fileName) ?? ""
+  };
+  const mode = optionalString(obj, "mode", fileName);
+  config.mode = mode ?? "s2s";
+  const sttPrompt = optionalString(obj, "sttPrompt", fileName);
+  if (sttPrompt !== void 0) config.sttPrompt = sttPrompt;
+  const maxStepsProp = getProperty(obj, "maxSteps");
+  if (maxStepsProp) {
+    const init = maxStepsProp.getInitializer();
+    if (init.isKind(SyntaxKind.NumericLiteral)) {
+      config.maxSteps = Number(init.getLiteralValue());
+    }
+  }
+  const toolChoiceProp = getProperty(obj, "toolChoice");
+  if (toolChoiceProp) {
+    config.toolChoice = evalLiteral(
+      toolChoiceProp.getInitializer(),
+      "toolChoice",
+      fileName
+    );
+  }
+  const builtinToolsProp = getProperty(obj, "builtinTools");
+  if (builtinToolsProp) {
+    config.builtinTools = evalStringArray(
+      builtinToolsProp.getInitializer(),
+      "builtinTools",
+      fileName
+    );
+  }
+  const activeToolsProp = getProperty(obj, "activeTools");
+  if (activeToolsProp) {
+    config.activeTools = evalStringArray(
+      activeToolsProp.getInitializer(),
+      "activeTools",
+      fileName
+    );
+  }
+  const transportProp = getProperty(obj, "transport");
+  if (transportProp) {
+    const init = transportProp.getInitializer();
+    if (init.isKind(SyntaxKind.StringLiteral)) {
+      config.transport = [init.getLiteralValue()];
+    } else if (init.isKind(SyntaxKind.ArrayLiteralExpression)) {
+      config.transport = evalStringArray(init, "transport", fileName);
+    } else {
+      throw new BundleError(
+        `${fileName}: \`transport\` must be a string literal or array of strings.`
+      );
+    }
+  }
+  return config;
+}
+function extractToolSchemas(obj, fileName) {
+  const toolsProp = getProperty(obj, "tools");
+  if (!toolsProp) return [];
+  const init = toolsProp.getInitializer();
+  if (!init.isKind(SyntaxKind.ObjectLiteralExpression)) {
+    throw new BundleError(`${fileName}: \`tools\` must be an inline object literal.`);
+  }
+  const toolsObj = init.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+  const schemas = [];
+  for (const member of toolsObj.getProperties()) {
+    if (member.isKind(SyntaxKind.SpreadAssignment)) {
+      const text = member.getExpression().getText();
+      throw new BundleError(
+        `${fileName}: Spread expressions like \`...${text}\` in tools cannot be statically analyzed. Define each tool directly in the \`tools\` object.`
+      );
+    }
+    if (!member.isKind(SyntaxKind.PropertyAssignment)) continue;
+    const prop = member;
+    const toolName = prop.getName();
+    const toolInit = prop.getInitializer();
+    if (!toolInit.isKind(SyntaxKind.ObjectLiteralExpression)) {
+      throw new BundleError(`${fileName}: Tool \`${toolName}\` must be an inline object literal.`);
+    }
+    const toolObj = toolInit.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    const descProp = getProperty(toolObj, "description");
+    if (!descProp) {
+      throw new BundleError(`${fileName}: Tool \`${toolName}\` is missing a \`description\`.`);
+    }
+    const description = evalStringLiteral(descProp.getInitializer(), toolName, fileName);
+    const paramsProp = getProperty(toolObj, "parameters");
+    const parameters = paramsProp ? zodAstToJsonSchema(paramsProp.getInitializer(), toolName, fileName) : { type: "object", properties: {}, additionalProperties: false };
+    schemas.push({ name: toolName, description, parameters });
+  }
+  return schemas;
+}
+function zodAstToJsonSchema(node, toolName, fileName) {
+  return parseZodExpr(node, toolName, fileName).schema;
+}
+function parseZodExpr(node, toolName, fileName) {
+  if (!node.isKind(SyntaxKind.CallExpression)) {
+    throw zodError(node, toolName, fileName);
+  }
+  const call = node.asKindOrThrow(SyntaxKind.CallExpression);
+  const expr = call.getExpression();
+  if (expr.isKind(SyntaxKind.PropertyAccessExpression)) {
+    const propAccess = expr.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
+    const obj = propAccess.getExpression();
+    const method = propAccess.getName();
+    if (obj.isKind(SyntaxKind.Identifier) && obj.getText() === "z") {
+      return parseZodBase(method, call, toolName, fileName);
+    }
+    if (method === "describe") {
+      const result = parseZodExpr(obj, toolName, fileName);
+      const args = call.getArguments();
+      if (args[0]) {
+        result.schema.description = evalStringLiteral(args[0], toolName, fileName);
+      }
+      return result;
+    }
+    if (method === "optional") {
+      const result = parseZodExpr(obj, toolName, fileName);
+      result.optional = true;
+      return result;
+    }
+    if (method === "default" || method === "nullable") {
+      return parseZodExpr(obj, toolName, fileName);
+    }
+    return parseZodExpr(obj, toolName, fileName);
+  }
+  throw zodError(node, toolName, fileName);
+}
+function parseZodBase(method, call, toolName, fileName) {
+  switch (method) {
+    case "string":
+      return { schema: { type: "string" }, optional: false };
+    case "number":
+      return { schema: { type: "number" }, optional: false };
+    case "boolean":
+      return { schema: { type: "boolean" }, optional: false };
+    case "enum": {
+      const args = call.getArguments();
+      const arg = args[0];
+      if (!arg || !arg.isKind(SyntaxKind.ArrayLiteralExpression)) {
+        throw new BundleError(
+          `${fileName}: Tool \`${toolName}\`: z.enum() requires an array literal argument.`
+        );
+      }
+      const arr = arg.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+      const values = arr.getElements().map((el) => {
+        if (!el.isKind(SyntaxKind.StringLiteral)) {
+          throw new BundleError(
+            `${fileName}: Tool \`${toolName}\`: z.enum() values must be string literals.`
+          );
+        }
+        return el.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+      });
+      return {
+        schema: { type: "string", enum: values },
+        optional: false
+      };
+    }
+    case "array": {
+      const args = call.getArguments();
+      const arg = args[0];
+      if (!arg) {
+        return { schema: { type: "array" }, optional: false };
+      }
+      const items = parseZodExpr(arg, toolName, fileName);
+      return {
+        schema: { type: "array", items: items.schema },
+        optional: false
+      };
+    }
+    case "object": {
+      const args = call.getArguments();
+      const arg = args[0];
+      if (!arg || !arg.isKind(SyntaxKind.ObjectLiteralExpression)) {
+        return {
+          schema: {
+            type: "object",
+            properties: {},
+            additionalProperties: false
+          },
+          optional: false
+        };
+      }
+      const objLit = arg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+      const properties = {};
+      const required = [];
+      for (const member of objLit.getProperties()) {
+        if (!member.isKind(SyntaxKind.PropertyAssignment)) continue;
+        const prop = member;
+        const propName = prop.getName();
+        const result = parseZodExpr(prop.getInitializer(), toolName, fileName);
+        properties[propName] = result.schema;
+        if (!result.optional) {
+          required.push(propName);
+        }
+      }
+      const schema = {
+        type: "object",
+        properties,
+        additionalProperties: false
+      };
+      if (required.length > 0) {
+        schema.required = required;
+      }
+      return { schema, optional: false };
+    }
+    default:
+      throw new BundleError(
+        `${fileName}: Tool \`${toolName}\`: unsupported Zod type \`z.${method}()\`. Supported: z.string(), z.number(), z.boolean(), z.enum([...]), z.array(...), z.object({...}).`
+      );
+  }
+}
+function zodError(node, toolName, fileName) {
+  const text = node.getText().slice(0, 60);
+  return new BundleError(
+    `${fileName}: Tool \`${toolName}\`: unsupported Zod pattern \`${text}\`. Supported: z.string(), z.number(), z.boolean(), z.enum([...]), z.array(...), z.object({...}), .describe(), .optional().`
+  );
+}
+function getProperty(obj, name) {
+  const prop = obj.getProperty(name);
+  if (!prop) return void 0;
+  if (!prop.isKind(SyntaxKind.PropertyAssignment)) return void 0;
+  return prop;
+}
+function requireString(obj, field, fileName) {
+  const prop = getProperty(obj, field);
+  if (!prop) {
+    throw new BundleError(`${fileName}: The \`${field}\` field is required in defineAgent({...}).`);
+  }
+  return evalStringLiteral(prop.getInitializer(), field, fileName);
+}
+function optionalString(obj, field, fileName) {
+  const prop = getProperty(obj, field);
+  if (!prop) return void 0;
+  return evalStringLiteral(prop.getInitializer(), field, fileName);
+}
+function evalStringLiteral(node, context, fileName) {
+  if (node.isKind(SyntaxKind.StringLiteral)) {
+    return node.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+  }
+  if (node.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) {
+    return node.asKindOrThrow(SyntaxKind.NoSubstitutionTemplateLiteral).getLiteralValue();
+  }
+  if (node.isKind(SyntaxKind.TemplateExpression)) {
+    throw new BundleError(
+      `${fileName}: \`${context}\` uses template expressions with substitutions, which cannot be statically analyzed. Use a plain string literal.`
+    );
+  }
+  throw new BundleError(
+    `${fileName}: \`${context}\` must be a static string literal. Dynamic expressions cannot be analyzed at build time.`
+  );
+}
+function evalStringArray(node, context, fileName) {
+  if (!node.isKind(SyntaxKind.ArrayLiteralExpression)) {
+    throw new BundleError(`${fileName}: \`${context}\` must be an array literal.`);
+  }
+  const arr = node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
+  return arr.getElements().map((el) => evalStringLiteral(el, context, fileName));
+}
+function evalLiteral(node, context, fileName) {
+  if (node.isKind(SyntaxKind.StringLiteral)) {
+    return node.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+  }
+  if (node.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) {
+    return node.asKindOrThrow(SyntaxKind.NoSubstitutionTemplateLiteral).getLiteralValue();
+  }
+  if (node.isKind(SyntaxKind.NumericLiteral)) {
+    return Number(node.asKindOrThrow(SyntaxKind.NumericLiteral).getLiteralValue());
+  }
+  if (node.isKind(SyntaxKind.TrueKeyword)) return true;
+  if (node.isKind(SyntaxKind.FalseKeyword)) return false;
+  if (node.isKind(SyntaxKind.ArrayLiteralExpression)) {
+    return node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression).getElements().map((el) => evalLiteral(el, context, fileName));
+  }
+  if (node.isKind(SyntaxKind.ObjectLiteralExpression)) {
+    const obj = node.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
+    const result = {};
+    for (const member of obj.getProperties()) {
+      if (member.isKind(SyntaxKind.PropertyAssignment)) {
+        const prop = member;
+        result[prop.getName()] = evalLiteral(
+          prop.getInitializer(),
+          context,
+          fileName
+        );
+      }
+    }
+    return result;
+  }
+  throw new BundleError(
+    `${fileName}: \`${context}\` must be a static literal value. Dynamic expressions cannot be analyzed at build time.`
+  );
+}
+
+// cli/_bundler.ts
+var BundleError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BundleError";
+  }
+};
+function workerEntryPlugin(agentDir) {
+  const id = "virtual:worker-entry";
+  const resolved = `\0${id}`;
+  return {
+    name: "aai-worker-entry",
+    enforce: "pre",
+    resolveId(source) {
+      if (source === id) return resolved;
+    },
+    load(source) {
+      if (source === resolved) {
+        const agentPath = path2.resolve(agentDir, "agent.ts");
+        return [
+          `import agent from "${agentPath}";`,
+          `import { initWorker } from "@alexkroman1/aai/worker-shim";`,
+          `initWorker(agent);`
+        ].join("\n");
+      }
+    }
+  };
+}
+var DEFAULT_STYLES_CSS = `@import url("https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap");
+@import "tailwindcss";
+@source "./";
+@source "./components/";
+
+@theme {
+  --color-aai-bg: #101010;
+  --color-aai-surface: #151515;
+  --color-aai-surface-faint: rgba(255, 255, 255, 0.031);
+  --color-aai-surface-hover: rgba(255, 255, 255, 0.059);
+  --color-aai-border: #282828;
+  --color-aai-primary: #fab283;
+  --color-aai-text: rgba(255, 255, 255, 0.936);
+  --color-aai-text-secondary: rgba(255, 255, 255, 0.618);
+  --color-aai-text-muted: rgba(255, 255, 255, 0.284);
+  --color-aai-text-dim: rgba(255, 255, 255, 0.422);
+  --color-aai-error: #fc533a;
+  --color-aai-ring: #9dbefe;
+  --color-aai-state-disconnected: rgba(255, 255, 255, 0.422);
+  --color-aai-state-connecting: rgba(255, 255, 255, 0.422);
+  --color-aai-state-ready: #12c905;
+  --color-aai-state-listening: #9dbefe;
+  --color-aai-state-thinking: #fcd53a;
+  --color-aai-state-speaking: #fc533a;
+  --color-aai-state-error: #fc533a;
+  --radius-aai: 6px;
+  --font-aai: "Inter", system-ui, -apple-system, sans-serif;
+  --font-aai-mono: "IBM Plex Mono", monospace;
+}
+
+@layer base {
+  html, body {
+    margin: 0;
+    padding: 0;
+    background: var(--color-aai-bg);
+  }
+}
+
+@keyframes aai-bounce {
+  0%, 80%, 100% {
+    opacity: 0.3;
+    transform: scale(0.8);
+  }
+  40% {
+    opacity: 1;
+    transform: scale(1);
+  }
+}
+
+@keyframes aai-shimmer {
+  0% {
+    background-position: -200% 0;
+  }
+  100% {
+    background-position: 200% 0;
+  }
+}
+
+.tool-shimmer {
+  background: linear-gradient(
+    90deg,
+    var(--color-aai-text) 25%,
+    var(--color-aai-text-dim) 50%,
+    var(--color-aai-text) 75%
+  );
+  background-size: 200% 100%;
+  -webkit-background-clip: text;
+  background-clip: text;
+  -webkit-text-fill-color: transparent;
+  animation: aai-shimmer 2s ease-in-out infinite;
+}
+`;
+var INDEX_HTML = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1.0, viewport-fit=cover"
+    />
+    <title>aai</title>
+    <link rel="icon" href="/favicon.svg" type="image/svg+xml" />
+    <link rel="stylesheet" href="../styles.css" />
+  </head>
+  <body>
+    <main id="app"></main>
+    <script type="module" src="../client.tsx"></script>
+  </body>
+</html>
+`;
+async function bundleAgent(agent, opts) {
+  const aaiDir = path2.join(agent.dir, ".aai");
+  const buildDir = path2.join(aaiDir, "build");
+  await fs3.mkdir(aaiDir, { recursive: true });
+  const { config: agentConfig, toolSchemas } = await extractStaticConfig(agent.entryPoint);
+  await fs3.writeFile(path2.join(aaiDir, "index.html"), INDEX_HTML);
+  const stylesPath = path2.join(agent.dir, "styles.css");
+  try {
+    await fs3.access(stylesPath);
+  } catch {
+    await fs3.writeFile(stylesPath, DEFAULT_STYLES_CSS);
+  }
+  try {
+    await build({
+      configFile: false,
+      root: agent.dir,
+      logLevel: "warn",
+      plugins: [workerEntryPlugin(agent.dir)],
+      build: {
+        outDir: buildDir,
+        emptyOutDir: true,
+        minify: true,
+        target: "es2022",
+        rollupOptions: {
+          input: "virtual:worker-entry",
+          output: {
+            format: "es",
+            entryFileNames: "worker.js",
+            inlineDynamicImports: true
+          }
+        }
+      }
+    });
+  } catch (err) {
+    throw new BundleError(err instanceof Error ? err.message : String(err));
+  }
+  const skipClient = opts?.skipClient || !agent.clientEntry;
+  if (!skipClient) {
+    try {
+      await build({
+        configFile: false,
+        root: aaiDir,
+        logLevel: "warn",
+        plugins: [preact(), tailwindcss(), viteSingleFile()],
+        build: {
+          outDir: buildDir,
+          emptyOutDir: false,
+          minify: true,
+          target: "es2022"
+        }
+      });
+    } catch (err) {
+      throw new BundleError(err instanceof Error ? err.message : String(err));
+    }
+  }
+  const worker = await fs3.readFile(path2.join(buildDir, "worker.js"), "utf-8");
+  const htmlPath = skipClient ? path2.join(aaiDir, "index.html") : path2.join(buildDir, "index.html");
+  const html = await fs3.readFile(htmlPath, "utf-8");
+  const manifest = JSON.stringify(
+    {
+      transport: agentConfig.transport ?? agent.transport,
+      config: agentConfig,
+      toolSchemas
+    },
+    null,
+    2
+  );
+  return {
+    worker,
+    html,
+    manifest,
+    workerBytes: Buffer.byteLength(worker)
+  };
+}
+
+// cli/build.ts
+init_output();
+async function writeBuildOutput(agentDir, bundle) {
+  const buildDir = path3.join(agentDir, ".aai", "build");
+  await fs4.mkdir(buildDir, { recursive: true });
+  await Promise.all([
+    fs4.writeFile(path3.join(buildDir, "worker.js"), bundle.worker),
+    fs4.writeFile(path3.join(buildDir, "manifest.json"), bundle.manifest),
+    fs4.writeFile(path3.join(buildDir, "index.html"), bundle.html)
+  ]);
+}
+async function checkAgent(agentDir) {
+  const userFiles = ["agent.ts"];
+  for (const f of ["client.tsx", "components.tsx"]) {
+    try {
+      await fs4.stat(path3.join(agentDir, f));
+      userFiles.push(f);
+    } catch {
+    }
+  }
+  const checks = [{ args: ["--noEmit", ...userFiles], label: "Type-check" }];
+  const results = await Promise.allSettled(
+    checks.map(({ args }) => execFileAsync("npx", ["tsc", ...args], { cwd: agentDir }))
+  );
+  const errors = [];
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    if (r.status === "rejected") {
+      const msg = r.reason.stderr?.trim() ?? String(r.reason);
+      error2(`${checks[i].label}: ${msg}`);
+      errors.push(checks[i].label);
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`${errors.join(", ")} failed \u2014 fix the errors above`);
+  }
+}
+async function runBuild(opts) {
+  const agent = await loadAgent(opts.agentDir);
+  if (!agent) {
+    throw new Error("No agent found \u2014 run `aai new` first");
+  }
+  step("Check", agent.slug);
+  await checkAgent(opts.agentDir);
+  step("Bundle", agent.slug);
+  let bundle;
+  try {
+    bundle = await bundleAgent(agent);
+  } catch (err) {
+    if (err instanceof BundleError) {
+      error2(err.message);
+      throw new Error("Bundle failed \u2014 fix the errors above");
+    }
+    throw err;
+  }
+  await writeBuildOutput(opts.agentDir, bundle);
+  return { agent, bundle };
+}
+
+// cli/new.tsx
+init_colors();
+import fs6 from "node:fs/promises";
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import minimist from "minimist";
+init_new();
+var newCommandDef = {
+  name: "init",
+  description: "Scaffold a new agent project",
+  args: [{ name: "dir", optional: true }],
+  options: [
+    {
+      flags: "-t, --template <template>",
+      description: "Template to use"
+    },
+    { flags: "-f, --force", description: "Overwrite existing agent.ts" },
+    { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
+  ]
+};
+var TEMPLATE_DESCRIPTIONS = {
+  simple: "Minimal starter with search, code, and fetch tools",
+  "web-researcher": "Research assistant with web search and page visits",
+  "smart-research": "Phase-based research with dynamic tool filtering",
+  "memory-agent": "Persistent KV storage across conversations",
+  "code-interpreter": "Writes and runs JavaScript for calculations",
+  "math-buddy": "Calculations, unit conversions, dice rolls",
+  "health-assistant": "Medication lookup, drug interactions, BMI",
+  "personal-finance": "Currency, crypto, loans, savings projections",
+  "travel-concierge": "Trip planning, weather, flights, hotels",
+  "night-owl": "Movie/music/book recs by mood \u2014 custom UI",
+  "dispatch-center": "911 dispatch with triage \u2014 custom UI",
+  "infocom-adventure": "Zork-style text adventure \u2014 custom UI",
+  "embedded-assets": "FAQ bot using embedded JSON knowledge",
+  support: "RAG-powered support agent for a documentation site",
+  terminal: "STT-only mode for voice-driven commands"
+};
+async function selectTemplate(available) {
+  const sorted = ["simple", ...available.filter((t) => t !== "simple")];
+  const maxLen = Math.max(...sorted.map((t) => t.length));
+  const choices = sorted.map((name) => ({
+    label: `${name.padEnd(maxLen + 2)}${TEMPLATE_DESCRIPTIONS[name] ?? ""}`,
+    value: name
+  }));
+  return await askSelect("Which template?", choices);
+}
+async function runNewCommand(args, version) {
+  const parsed = minimist(args, {
+    string: ["template"],
+    boolean: ["force", "help", "yes"],
+    alias: { t: "template", f: "force", h: "help", y: "yes" }
+  });
+  if (parsed.help) {
+    console.log(subcommandHelp(newCommandDef, version));
+    return "";
+  }
+  const dir = parsed._[0];
+  const cwd = dir ?? (process.env.INIT_CWD || process.cwd());
+  if (!parsed.force && await fileExists(path5.join(cwd, "agent.ts"))) {
+    console.log(
+      `agent.ts already exists in this directory. Use ${interactive("--force")} to overwrite.`
+    );
+    process.exit(1);
+  }
+  const cliDir2 = path5.dirname(fileURLToPath2(import.meta.url));
+  const templatesDir = path5.join(cliDir2, "..", "templates");
+  const { runNew: runNew2 } = await Promise.resolve().then(() => (init_new(), new_exports));
+  const available = await listTemplates(templatesDir);
+  const template = parsed.template || (parsed.yes ? "simple" : await selectTemplate(available));
+  await runWithInk("Scaffolding...", async () => {
+    await runNew2({
+      targetDir: cwd,
+      template,
+      templatesDir
+    });
+    if (isDevMode()) {
+      const monorepoRoot = path5.join(cliDir2, "..");
+      const pkgJsonPath2 = path5.join(cwd, "package.json");
+      const pkgJson2 = JSON.parse(await fs6.readFile(pkgJsonPath2, "utf-8"));
+      for (const pkg of ["sdk", "ui"]) {
+        const localPkgPath = path5.join(monorepoRoot, pkg, "package.json");
+        const localPkg = JSON.parse(await fs6.readFile(localPkgPath, "utf-8"));
+        const pkgName = localPkg.name;
+        pkgJson2.dependencies[pkgName] = `file:${path5.join(monorepoRoot, pkg)}`;
+      }
+      await fs6.writeFile(pkgJsonPath2, `${JSON.stringify(pkgJson2, null, 2)}
+`);
+    }
+    await ensureClaudeMd(cwd);
+    await ensureDependencies(cwd);
+  });
+  return cwd;
+}
+
+// cli/deploy.tsx
+var deployCommandDef = {
+  name: "deploy",
+  description: "Bundle and deploy to production",
+  options: [
+    { flags: "-s, --server <url>", description: "Server URL" },
+    {
+      flags: "--local [url]",
+      description: "Use local server",
+      hidden: true
+    },
+    {
+      flags: "--dry-run",
+      description: "Validate and bundle without deploying"
+    },
+    { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
+  ]
+};
+async function runDeployCommand(args, version) {
+  const parsed = minimist2(args, {
+    string: ["server", "local"],
+    boolean: ["dry-run", "help", "yes"],
+    alias: { s: "server", h: "help", y: "yes" }
+  });
+  if (parsed.help) {
+    console.log(subcommandHelp(deployCommandDef, version));
+    return;
+  }
+  const cwd = process.env.INIT_CWD || process.cwd();
+  if (!await fileExists(path6.join(cwd, "agent.ts"))) {
+    await runNewCommand(parsed.yes ? ["-y"] : [], version);
+  }
+  const local = parsed.local;
+  const serverUrl = local !== void 0 ? typeof local === "string" && local !== "" ? local : "http://localhost:3100" : parsed.server || (isDevMode() ? "http://localhost:3100" : DEFAULT_SERVER);
+  const dryRun = parsed["dry-run"] ?? false;
+  const apiKey = dryRun ? "" : await getApiKey();
+  const projectConfig = await readProjectConfig(cwd);
+  const slug = projectConfig?.slug ?? generateSlug();
+  await runWithInk("Deploying...", async () => {
+    const result = await runBuild({ agentDir: cwd });
+    const deployed = await runDeploy({
+      url: serverUrl,
+      bundle: result.bundle,
+      env: dryRun ? {} : { ASSEMBLYAI_API_KEY: apiKey },
+      slug,
+      dryRun,
+      apiKey
+    });
+    await writeProjectConfig(cwd, {
+      slug: deployed.slug,
+      serverUrl
+    });
+  });
+}
+
+// cli/dev.tsx
+import path8 from "node:path";
+import minimist3 from "minimist";
+
+// cli/_dev.ts
+init_output();
+
+// cli/_server_common.ts
+import path7 from "node:path";
+init_output();
+async function loadAgentDef(cwd) {
+  const agentPath = path7.resolve(cwd, "agent.ts");
+  const agentModule = await import(agentPath);
+  const agentDef = agentModule.default;
+  if (!agentDef || typeof agentDef !== "object" || !agentDef.name) {
+    throw new Error("agent.ts must export a default agent definition (from defineAgent())");
+  }
+  return agentDef;
+}
+async function resolveServerEnv() {
+  const env = { ...process.env };
+  if (!env.ASSEMBLYAI_API_KEY) {
+    try {
+      env.ASSEMBLYAI_API_KEY = await getApiKey();
+    } catch {
+      error2("ASSEMBLYAI_API_KEY not set. Set it in your environment or run `aai env add`.");
+      throw new Error("ASSEMBLYAI_API_KEY is required");
+    }
+  }
+  return env;
+}
+async function bootServer(agentDef, html, env, port) {
+  step("Start", `http://localhost:${port}`);
+  const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  const server = createServer2({
+    agent: agentDef,
+    clientHtml: html,
+    env
+  });
+  await server.listen(port);
+  step("Ready", `http://localhost:${port}`);
+}
+
+// cli/_dev.ts
+async function _startDevServer(cwd, port) {
+  const agent = await loadAgent(cwd);
+  if (!agent) {
+    throw new Error("No agent found \u2014 run `aai new` first");
+  }
+  step("Bundle", agent.slug);
+  let html;
+  try {
+    const bundle = await bundleAgent(agent);
+    html = bundle.html;
+  } catch (err) {
+    if (err instanceof BundleError) {
+      error2(err.message);
+      throw new Error("Bundle failed \u2014 fix the errors above");
+    }
+    throw err;
+  }
+  step("Load", "agent.ts");
+  const agentDef = await loadAgentDef(cwd);
+  const env = await resolveServerEnv();
+  await bootServer(agentDef, html, env, port);
+}
+
+// cli/dev.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var devCommandDef = {
+  name: "dev",
+  description: "Start a local development server",
+  options: [
+    {
+      flags: "-p, --port <number>",
+      description: "Port to listen on (default: 3000)"
+    },
+    { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
+  ]
+};
+async function runDevCommand(args, version) {
+  const parsed = minimist3(args, {
+    string: ["port"],
+    boolean: ["help", "yes"],
+    alias: { p: "port", h: "help", y: "yes" }
+  });
+  if (parsed.help) {
+    console.log(subcommandHelp(devCommandDef, version));
+    return;
+  }
+  const cwd = process.env.INIT_CWD || process.cwd();
+  const port = Number.parseInt(parsed.port ?? "3000", 10);
+  if (!await fileExists(path8.join(cwd, "agent.ts"))) {
+    await runNewCommand(parsed.yes ? ["-y"] : [], version);
+  }
+  await getApiKey();
+  await runWithInk("Bundling...", async (log) => {
+    log(/* @__PURE__ */ jsx3(Step, { action: "Dev", msg: `starting on port ${port}` }));
+    await _startDevServer(cwd, port);
+  });
+}
+
+// cli/rag.tsx
+import { render as render3, Text as Text3, useApp as useApp2 } from "ink";
+import minimist4 from "minimist";
+import pLimit from "p-limit";
+import { useEffect, useState as useState2 } from "react";
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var ragCommandDef = {
+  name: "rag",
+  description: "Ingest a site's llms-full.txt into the vector store",
+  args: [{ name: "url" }],
+  options: [
+    { flags: "-s, --server <url>", description: "Server URL" },
+    {
+      flags: "--chunk-size <n>",
+      description: "Max chunk size in tokens (default: 512)"
+    },
+    { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
+  ]
+};
+var FETCH_TIMEOUT_MS = 6e4;
+var PAD3 = 9;
+function RagUI({ url, apiKey, serverUrl, slug, chunkSize, onError }) {
+  const { exit } = useApp2();
+  const { items, log } = useStepLog();
+  const [progress, setProgress] = useState2(null);
+  const [err, setErr] = useState2(null);
+  useEffect(() => {
+    (async () => {
+      try {
+        await runRag({
+          url,
+          apiKey,
+          serverUrl,
+          slug,
+          chunkSize,
+          log,
+          setProgress
+        });
+      } catch (e) {
+        const error3 = e instanceof Error ? e : new Error(String(e));
+        setErr(error3.message);
+        onError?.(error3);
+      }
+      setProgress(null);
+      exit();
+    })();
+  }, [apiKey, chunkSize, exit, log, onError, serverUrl, slug, url]);
+  return /* @__PURE__ */ jsxs3(Fragment2, { children: [
+    /* @__PURE__ */ jsx4(StepLog, { items }),
+    err && /* @__PURE__ */ jsx4(ErrorLine, { msg: err }),
+    progress && /* @__PURE__ */ jsxs3(Text3, { children: [
+      " ".repeat(PAD3 + 1),
+      "Upsert ",
+      progress.completed,
+      "/",
+      progress.total,
+      " (",
+      Math.round(progress.completed / progress.total * 100),
+      "%)"
+    ] })
+  ] });
+}
+async function runRag(opts) {
+  const { url, apiKey, serverUrl, slug, chunkSize, log, setProgress } = opts;
+  log(/* @__PURE__ */ jsx4(Step, { action: "Fetch", msg: url }));
+  const resp = await fetch(url, {
+    headers: { "User-Agent": "aai-cli/1.0" },
+    redirect: "follow",
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+  });
+  if (!resp.ok) {
+    throw new Error(`Failed to fetch: ${resp.status} ${resp.statusText}`);
+  }
+  const content = await resp.text();
+  if (content.length === 0) {
+    log(/* @__PURE__ */ jsx4(Warn, { msg: "File is empty" }));
+    return;
+  }
+  log(/* @__PURE__ */ jsx4(Info, { msg: `${(content.length / 1024).toFixed(0)} KB` }));
+  const origin = new URL(url).origin;
+  const pages = splitPages(content);
+  log(/* @__PURE__ */ jsx4(Step, { action: "Parsed", msg: `${pages.length} pages` }));
+  const { RecursiveChunker } = await import("@chonkiejs/core");
+  const chunker = await RecursiveChunker.create({ chunkSize });
+  const allChunks = [];
+  const siteSlug = slugify(origin);
+  for (const page of pages) {
+    page.body = stripNoise(page.body);
+    if (!page.body) continue;
+    const raw = await chunker.chunk(page.body);
+    for (let i = 0; i < raw.length; i++) {
+      const c = raw[i];
+      const data = page.title ? `${page.title}
+
+${c.text}` : c.text;
+      const id = `${siteSlug}:${slugify(page.title || "page")}:${i}`;
+      allChunks.push({
+        id,
+        data,
+        metadata: {
+          source: origin,
+          ...page.title ? { title: page.title } : {},
+          tokenCount: c.tokenCount
+        }
+      });
+    }
+  }
+  log(/* @__PURE__ */ jsx4(Step, { action: "Chunked", msg: `${allChunks.length} chunks` }));
+  const vectorUrl = `${serverUrl}/${slug}/vector`;
+  log(/* @__PURE__ */ jsx4(Info, { msg: `target: ${vectorUrl}` }));
+  const total = allChunks.length;
+  let completed = 0;
+  let upserted = 0;
+  let errors = 0;
+  let lastError = "";
+  setProgress({ completed: 0, total });
+  const limit = pLimit(5);
+  await Promise.all(
+    allChunks.map(
+      (chunk) => limit(async () => {
+        try {
+          const r = await fetch(vectorUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${apiKey}`
+            },
+            body: JSON.stringify({
+              op: "upsert",
+              id: chunk.id,
+              data: chunk.data,
+              metadata: chunk.metadata
+            })
+          });
+          if (!r.ok) {
+            lastError = await r.text();
+            errors++;
+          } else {
+            upserted++;
+          }
+        } catch (err) {
+          lastError = err instanceof Error ? err.message : String(err);
+          errors++;
+        }
+        completed++;
+        setProgress({ completed, total });
+      })
+    )
+  );
+  log(/* @__PURE__ */ jsx4(Step, { action: "Done", msg: `${upserted} chunks upserted` }));
+  if (errors > 0) {
+    log(/* @__PURE__ */ jsx4(Warn, { msg: `${errors} failed` }));
+    if (lastError) log(/* @__PURE__ */ jsx4(Info, { msg: `last error: ${lastError}` }));
+  }
+  log(/* @__PURE__ */ jsx4(Detail, { msg: `Agent: ${slug}` }));
+}
+async function runRagCommand(args, version) {
+  const parsed = minimist4(args, {
+    string: ["server", "chunk-size"],
+    boolean: ["help", "yes"],
+    alias: { s: "server", h: "help", y: "yes" },
+    stopEarly: true
+  });
+  if (parsed.help) {
+    console.log(subcommandHelp(ragCommandDef, version));
+    return;
+  }
+  const url = String(parsed._[0] ?? "");
+  if (!url) {
+    throw new Error(
+      "Usage: aai rag <url>\n\nProvide the full URL to a site's llms-full.txt file"
+    );
+  }
+  try {
+    new URL(url);
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+  const cwd = process.env.INIT_CWD || process.cwd();
+  const config = await readProjectConfig(cwd);
+  if (!config) {
+    throw new Error("No .aai/project.json found \u2014 deploy first with `aai deploy`");
+  }
+  const apiKey = await getApiKey();
+  const serverUrl = parsed.server || config.serverUrl || (isDevMode() ? "http://localhost:3100" : DEFAULT_SERVER);
+  const slug = config.slug;
+  const chunkSize = Number.parseInt(parsed["chunk-size"] ?? "512", 10);
+  let thrownError;
+  const app = render3(
+    /* @__PURE__ */ jsx4(
+      RagUI,
+      {
+        url,
+        apiKey,
+        serverUrl,
+        slug,
+        chunkSize,
+        onError: (e) => {
+          thrownError = e;
+        }
+      }
+    )
+  );
+  await app.waitUntilExit();
+  if (thrownError) throw thrownError;
+}
+function splitPages(content) {
+  const raw = content.split(/^\*{3,}$/m);
+  const pages = [];
+  for (const section of raw) {
+    const trimmed = section.trim();
+    if (!trimmed) continue;
+    let title = "";
+    let body = trimmed;
+    const dashIndex = trimmed.search(/^-{3,}$/m);
+    if (dashIndex !== -1) {
+      const frontmatter = trimmed.slice(0, dashIndex);
+      body = trimmed.slice(dashIndex).replace(/^-+$/m, "").trim();
+      const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
+      if (titleMatch) {
+        title = titleMatch[1].trim();
+      }
+    }
+    if (!title) {
+      const titleLineMatch = body.match(/^#{1,2}\s+title:\s*(.+)$/m);
+      if (titleLineMatch) {
+        title = titleLineMatch[1].trim();
+        body = body.replace(/^#{1,2}\s+title:\s*.+\n?/m, "").trim();
+      } else {
+        const headingMatch = body.match(/^(#{1,3})\s+(.+)$/m);
+        if (headingMatch) {
+          title = headingMatch[2].trim();
+        }
+      }
+    }
+    if (body.length > 0) {
+      pages.push({ title, body });
+    }
+  }
+  return pages;
+}
+function stripNoise(text) {
+  return text.replace(/^(`{3,}|~{3,}).*[\s\S]*?^\1/gm, "").replace(/^(?:[ ]{4,}|\t).+$/gm, "").replace(/`[^`]+`/g, "").replace(/\{\/\*[\s\S]*?\*\/\}/g, "").replace(/<[^>]+>/g, "").replace(/^\s*\}[^}\n]*$/gm, "").replace(/^\s+$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function slugify(s) {
+  return s.replace(/^https?:\/\//, "").replace(/^#+\s*/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 80);
+}
+
+// cli/secret.tsx
+import minimist5 from "minimist";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var secretCommandDef = {
+  name: "secret",
+  description: "Manage secrets",
+  options: [
+    { flags: "put <name>", description: "Create or update a secret" },
+    { flags: "delete <name>", description: "Delete a secret" },
+    { flags: "list", description: "List secret names" }
+  ]
+};
+async function requireProjectConfig(cwd) {
+  const config = await readProjectConfig(cwd);
+  if (!config) {
+    throw new Error("No .aai/project.json found \u2014 deploy first with `aai deploy`");
+  }
+  return config;
+}
+async function runSecretCommand(args, version) {
+  const parsed = minimist5(args, {
+    boolean: ["help", "yes"],
+    alias: { h: "help", y: "yes" },
+    stopEarly: true
+  });
+  if (parsed.help || parsed._.length === 0) {
+    console.log(subcommandHelp(secretCommandDef, version));
+    return;
+  }
+  const sub = String(parsed._[0]);
+  const cwd = process.env.INIT_CWD || process.cwd();
+  await getApiKey();
+  let secretValue;
+  if (sub === "put") {
+    const name = String(parsed._[1] ?? "");
+    if (!name) throw new Error("Usage: aai secret put <NAME>");
+    secretValue = await askPassword(`Enter value for ${name}`);
+    if (!secretValue) throw new Error("No value provided");
+  }
+  switch (sub) {
+    case "put":
+      await secretPut(cwd, String(parsed._[1] ?? ""), secretValue);
+      break;
+    case "delete":
+      await secretDelete(cwd, String(parsed._[1] ?? ""));
+      break;
+    case "list":
+      await secretList(cwd);
+      break;
+    default:
+      throw new Error(`Unknown secret subcommand: ${sub}`);
+  }
+}
+async function getServerInfo(cwd) {
+  const config = await requireProjectConfig(cwd);
+  const apiKey = await getApiKey();
+  const serverUrl = config.serverUrl || DEFAULT_SERVER;
+  const slug = config.slug;
+  return { serverUrl, slug, apiKey };
+}
+async function secretPut(cwd, name, value) {
+  await runWithInk("Setting...", async (log) => {
+    const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
+    const resp = await fetch(`${serverUrl}/${slug}/secret`, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ [name]: value })
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`Failed to set secret: ${text}`);
+    }
+    log(/* @__PURE__ */ jsx5(Step, { action: "Set", msg: `${name} for ${slug}` }));
+  });
+}
+async function secretDelete(cwd, name) {
+  if (!name) throw new Error("Usage: aai secret delete <NAME>");
+  await runWithInk("Removing...", async (log) => {
+    const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
+    const resp = await fetch(`${serverUrl}/${slug}/secret/${name}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`Failed to delete secret: ${text}`);
+    }
+    log(/* @__PURE__ */ jsx5(Step, { action: "Deleted", msg: `${name} from ${slug}` }));
+  });
+}
+async function secretList(cwd) {
+  await runWithInk("Loading...", async (log) => {
+    const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
+    const resp = await fetch(`${serverUrl}/${slug}/secret`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`Failed to list secrets: ${text}`);
+    }
+    const { vars } = await resp.json();
+    if (vars.length === 0) {
+      log(/* @__PURE__ */ jsx5(StepInfo, { action: "Secrets", msg: "No secrets set" }));
+    } else {
+      for (const name of vars) {
+        log(/* @__PURE__ */ jsx5(Detail, { msg: name }));
+      }
+    }
+  });
+}
+
+// cli/start.tsx
+import path10 from "node:path";
+import minimist6 from "minimist";
+
+// cli/_start.ts
+init_output();
+import fs7 from "node:fs/promises";
+import path9 from "node:path";
+async function _startProductionServer(cwd, port) {
+  const buildDir = path9.join(cwd, ".aai", "build");
+  const html = await fs7.readFile(path9.join(buildDir, "index.html"), "utf-8");
+  step("Load", "agent");
+  const agentDef = await loadAgentDef(cwd);
+  const env = await resolveServerEnv();
+  await bootServer(agentDef, html, env, port);
+}
+
+// cli/start.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var startCommandDef = {
+  name: "start",
+  description: "Start the production server from a build",
+  options: [
+    {
+      flags: "-p, --port <number>",
+      description: "Port to listen on (default: 3000)"
+    },
+    { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
+  ]
+};
+async function runStartCommand(args, version) {
+  const parsed = minimist6(args, {
+    string: ["port"],
+    boolean: ["help", "yes"],
+    alias: { p: "port", h: "help", y: "yes" }
+  });
+  if (parsed.help) {
+    console.log(subcommandHelp(startCommandDef, version));
+    return;
+  }
+  const cwd = process.env.INIT_CWD || process.cwd();
+  const port = Number.parseInt(parsed.port ?? "3000", 10);
+  const buildDir = path10.join(cwd, ".aai", "build");
+  if (!await fileExists(path10.join(buildDir, "worker.js"))) {
+    throw new Error("No build found \u2014 run `aai build` first");
+  }
+  await getApiKey();
+  await runWithInk("Starting...", async (log) => {
+    log(/* @__PURE__ */ jsx6(Step, { action: "Start", msg: `production server on port ${port}` }));
+    await _startProductionServer(cwd, port);
+  });
+}
+
+// cli/cli.ts
+var cliDir = path11.dirname(fileURLToPath3(import.meta.url));
+var pkgJsonPath = path11.join(cliDir, "..", "package.json");
+var pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+var VERSION = pkgJson.version;
+async function main(args) {
+  const parsed = minimist7(args, {
+    boolean: ["help", "version"],
+    alias: { h: "help", V: "version" },
+    stopEarly: true
+  });
+  if (parsed.version) {
+    console.log(VERSION);
+    return;
+  }
+  if (parsed.help && parsed._.length === 0) {
+    console.log(rootHelp(VERSION));
+    return;
+  }
+  const [subcommand, ...rest] = parsed._;
+  const subArgs = rest.map(String);
+  switch (subcommand) {
+    case "init":
+    case "new":
+      await runNewCommand(subArgs, VERSION);
+      return;
+    case "deploy":
+      await runDeployCommand(subArgs, VERSION);
+      return;
+    case "dev":
+      await runDevCommand(subArgs, VERSION);
+      return;
+    case "start":
+      await runStartCommand(subArgs, VERSION);
+      return;
+    case "secret":
+      await runSecretCommand(subArgs, VERSION);
+      return;
+    case "rag":
+      await runRagCommand(subArgs, VERSION);
+      return;
+    case "help":
+    case void 0:
+      console.log(rootHelp(VERSION));
+      return;
+    default:
+      error2(`Unknown command: ${subcommand}`);
+      console.log(rootHelp(VERSION));
+      process.exit(1);
+  }
+}
+var isMain = process.argv[1] === fileURLToPath3(import.meta.url);
+if (isMain) {
+  try {
+    await main(process.argv.slice(2));
+  } catch (err) {
+    error2(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+export {
+  main
+};