@alexkroman1/aai 0.8.3 → 0.8.4

package/dist/cli.js

@@ -9,17 +9,143 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// cli/_colors.ts
+// sdk/_utils.ts
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+var init_utils = __esm({
+  "sdk/_utils.ts"() {
+    "use strict";
+  }
+});
+
+// cli/_ink.tsx
+import { Spinner, StatusMessage } from "@inkjs/ui";
 import chalk from "chalk";
+import { Box, render, Static, Text, useApp } from "ink";
+import React, { useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 function primary(s) {
   return chalk.hex(COLORS.primary)(s);
 }
 function interactive(s) {
   return chalk.hex(COLORS.interactive)(s);
 }
+function StepBase({ action, msg, color }) {
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color, children: action }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      msg
+    ] })
+  ] });
+}
+function Step({ action, msg }) {
+  return /* @__PURE__ */ jsx(StepBase, { action, msg, color: COLORS.primary });
+}
+function StepInfo({ action, msg }) {
+  return /* @__PURE__ */ jsx(StepBase, { action, msg, color: COLORS.interactive });
+}
+function Info({ msg }) {
+  return /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    "  ",
+    msg
+  ] });
+}
+function Detail({ msg }) {
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    "  ",
+    msg
+  ] });
+}
+function Warn({ msg }) {
+  return /* @__PURE__ */ jsx(StatusMessage, { variant: "warning", children: msg });
+}
+function ErrorLine({ msg }) {
+  return /* @__PURE__ */ jsx(StatusMessage, { variant: "error", children: msg });
+}
+function StepLog({ items }) {
+  return /* @__PURE__ */ jsx(Static, { items, children: (item) => /* @__PURE__ */ jsx(Box, { children: item.node }, item.id) });
+}
+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,
+  onError
+}) {
+  const { exit } = useApp();
+  const { items, log } = useStepLog();
+  const [spinning, setSpinning] = useState(true);
+  const [currentStep, setCurrentStep] = useState(null);
+  const [statusLine, setStatusLine] = useState(null);
+  const [err, setErr] = useState(null);
+  const currentStepRef = useRef(null);
+  const wrappedLog = (node) => {
+    if (currentStepRef.current) {
+      log(currentStepRef.current);
+    }
+    currentStepRef.current = node;
+    setCurrentStep(node);
+  };
+  const started = useRef(false);
+  React.useEffect(() => {
+    if (started.current) return;
+    started.current = true;
+    (async () => {
+      try {
+        await run({ log: wrappedLog, setStatus: setStatusLine });
+      } catch (e) {
+        const error = e instanceof Error ? e : new Error(String(e));
+        setErr(error.message);
+        onError?.(error);
+      }
+      if (currentStepRef.current) {
+        log(currentStepRef.current);
+        currentStepRef.current = null;
+      }
+      setCurrentStep(null);
+      setStatusLine(null);
+      setSpinning(false);
+      setTimeout(() => exit(), 0);
+    })();
+  });
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(StepLog, { items }),
+    err && /* @__PURE__ */ jsx(ErrorLine, { msg: err }),
+    spinning && currentStep && /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Spinner, {}),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      currentStep
+    ] }),
+    spinning && statusLine && /* @__PURE__ */ jsx(Box, { children: statusLine })
+  ] });
+}
+async function runWithInk(fn) {
+  let thrownError;
+  const app = render(
+    /* @__PURE__ */ jsx(
+      CommandRunner,
+      {
+        onError: (e) => {
+          thrownError = e;
+        },
+        run: fn
+      }
+    )
+  );
+  await app.waitUntilExit();
+  if (thrownError) throw thrownError;
+}
 var COLORS;
-var init_colors = __esm({
-  "cli/_colors.ts"() {
+var init_ink = __esm({
+  "cli/_ink.tsx"() {
     "use strict";
     if (chalk.level === 0 && !process.env.NO_COLOR) {
       const ct = process.env.COLORTERM;
@@ -43,200 +169,61 @@ var init_colors = __esm({
   }
 });
 
-// cli/_help.ts
-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"],
-    ["build", "", "Bundle and validate (no server or deploy)"],
-    ["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")}`);
-  lines.push(`    ${chalk2.dim("$")} ${primary("cd")} ${interactive("my-agent")}`);
-  lines.push(`    ${chalk2.dim("$")} ${primary("aai dev")}`);
-  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");
-}
-var init_help = __esm({
-  "cli/_help.ts"() {
-    "use strict";
-    init_colors();
-  }
-});
-
 // cli/_prompts.tsx
 import { ConfirmInput, PasswordInput, Select, TextInput } 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 askText(message, defaultValue) {
+import { Box as Box2, render as render2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function inkPrompt(ui) {
   return new Promise((resolve) => {
-    const app = render(
-      /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsxs(Text, { color: COLORS.interactive, children: [
-          message,
-          " \u203A "
-        ] }),
-        /* @__PURE__ */ jsx(
-          TextInput,
-          {
-            placeholder: defaultValue,
-            onSubmit: (value) => {
-              resolve(value || defaultValue);
-              app.unmount();
-              app.clear();
-            }
-          }
-        )
-      ] })
+    const app = render2(
+      ui((value) => {
+        resolve(value);
+        app.unmount();
+      })
     );
   });
 }
-async function askEnter(message) {
-  return new Promise((resolve) => {
-    const app = render(
-      /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsx(Text, { color: COLORS.interactive, children: message }),
-        /* @__PURE__ */ jsx(
-          TextInput,
-          {
-            placeholder: "",
-            onSubmit: () => {
-              resolve();
-              app.unmount();
-            }
-          }
-        )
-      ] })
-    );
-  });
+function askPassword(message) {
+  return inkPrompt((done) => /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      message,
+      ": "
+    ] }),
+    /* @__PURE__ */ jsx2(PasswordInput, { onSubmit: done })
+  ] }));
+}
+function askText(message, defaultValue) {
+  return inkPrompt((done) => /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: COLORS.interactive, children: [
+      message,
+      " \u203A "
+    ] }),
+    /* @__PURE__ */ jsx2(TextInput, { placeholder: defaultValue, onSubmit: (value) => done(value || defaultValue) })
+  ] }));
+}
+function askEnter(message) {
+  return inkPrompt((done) => /* @__PURE__ */ jsxs2(Box2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { color: COLORS.interactive, children: message }),
+    /* @__PURE__ */ jsx2(TextInput, { placeholder: "", onSubmit: () => done(void 0) })
+  ] }));
 }
 var init_prompts = __esm({
   "cli/_prompts.tsx"() {
     "use strict";
-    init_colors();
+    init_ink();
   }
 });
 
 // cli/_discover.ts
-var discover_exports = {};
-__export(discover_exports, {
-  DEFAULT_SERVER: () => DEFAULT_SERVER,
-  fileExists: () => fileExists,
-  generateSlug: () => generateSlug,
-  getApiKey: () => getApiKey,
-  isDevMode: () => isDevMode,
-  loadAgent: () => loadAgent,
-  readProjectConfig: () => readProjectConfig,
-  writeProjectConfig: () => writeProjectConfig
-});
-import { accessSync } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { humanId } from "human-id";
-function isDevMode() {
-  const script = process.argv[1] ?? "";
-  if (script.endsWith(".ts") || script.endsWith(".tsx")) return true;
-  if (script.includes("/dist/") && !script.includes("node_modules")) {
-    const dir = path.dirname(path.dirname(script));
-    try {
-      accessSync(path.join(dir, "sdk"));
-      accessSync(path.join(dir, "cli"));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  return false;
+function resolveCwd() {
+  return process.env.INIT_CWD || process.cwd();
+}
+function isDevMode(script) {
+  script ??= process.argv[1] ?? "";
+  return script.endsWith(".ts") || script.endsWith(".tsx");
 }
 function generateSlug() {
   return humanId({ separator: "-", capitalize: false });
@@ -284,6 +271,18 @@ async function writeProjectConfig(agentDir, data) {
   await fs.writeFile(path.join(aaiDir, "project.json"), `${JSON.stringify(data, null, 2)}
 `);
 }
+async function getServerInfo(cwd, explicitServer, explicitApiKey) {
+  const config = await readProjectConfig(cwd);
+  if (!config) {
+    throw new Error("No .aai/project.json found \u2014 deploy first with `aai deploy`");
+  }
+  const apiKey = explicitApiKey ?? await getApiKey();
+  const serverUrl = resolveServerUrl(explicitServer, config.serverUrl);
+  return { serverUrl, slug: config.slug, apiKey };
+}
+function resolveServerUrl(explicit, configUrl) {
+  return explicit || configUrl || (isDevMode() ? "http://localhost:3100" : DEFAULT_SERVER);
+}
 async function fileExists(p) {
   try {
     await fs.access(p);
@@ -316,90 +315,173 @@ var init_discover = __esm({
   }
 });
 
-// cli/_bundler.ts
+// cli/_init.ts
+var init_exports = {};
+__export(init_exports, {
+  listTemplates: () => listTemplates,
+  runInit: () => runInit
+});
 import fs2 from "node:fs/promises";
 import path2 from "node:path";
+async function listTemplates(dir) {
+  const templates = [];
+  const entries = await fs2.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 entries = await fs2.readdir(src, { recursive: true, withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const rel = path2.relative(src, path2.join(entry.parentPath, entry.name));
+    const destPath = path2.join(dest, rel);
+    await fs2.mkdir(path2.dirname(destPath), { recursive: true });
+    try {
+      await fs2.copyFile(path2.join(src, rel), destPath, fs2.constants.COPYFILE_EXCL);
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+  }
+}
+async function runInit(opts) {
+  const { targetDir, template, templatesDir } = opts;
+  const available = await listTemplates(templatesDir);
+  if (!available.includes(template)) {
+    throw new Error(`unknown template '${template}' -- available: ${available.join(", ")}`);
+  }
+  await fs2.cp(path2.join(templatesDir, template), targetDir, { recursive: true, force: true });
+  await copyDirNoOverwrite(path2.join(templatesDir, "_shared"), targetDir);
+  try {
+    await fs2.copyFile(path2.join(targetDir, ".env.example"), path2.join(targetDir, ".env"));
+  } catch {
+  }
+  const readmePath = path2.join(targetDir, "README.md");
+  const slug = path2.basename(path2.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.
+`;
+  try {
+    await fs2.writeFile(readmePath, readme, { flag: "wx" });
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+  return targetDir;
+}
+var init_init = __esm({
+  "cli/_init.ts"() {
+    "use strict";
+  }
+});
+
+// cli/_bundler.ts
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
 import preact from "@preact/preset-vite";
 import tailwindcss from "@tailwindcss/vite";
 import { build } from "vite";
-async function readDirRecursive(dir, base = dir) {
-  const files = {};
-  let names;
+function workerEntryPlugin() {
+  const virtualId = "virtual:worker-entry";
+  const resolvedId = `\0${virtualId}`;
+  return {
+    name: "aai-worker-entry",
+    resolveId(source) {
+      return source === virtualId ? resolvedId : null;
+    },
+    load(id) {
+      if (id !== resolvedId) return null;
+      return [
+        `import agent from "./agent.ts";`,
+        `import { initWorker } from "@alexkroman1/aai/worker-shim";`,
+        `initWorker(agent);`
+      ].join("\n");
+    }
+  };
+}
+async function readDirFiles(dir) {
+  let entries;
   try {
-    names = await fs2.readdir(dir);
+    entries = await fs3.readdir(dir, { recursive: true, withFileTypes: true });
   } catch {
-    return files;
-  }
-  for (const name of names) {
-    const full = path2.join(dir, name);
-    const stat = await fs2.stat(full);
-    const entry = { name, isDirectory: () => stat.isDirectory() };
-    if (entry.isDirectory()) {
-      Object.assign(files, await readDirRecursive(full, base));
-    } else {
-      const rel = path2.relative(base, full);
-      files[rel] = await fs2.readFile(full, "utf-8");
-    }
+    return {};
   }
+  const files = {};
+  await Promise.all(
+    entries.filter((e) => e.isFile()).map(async (e) => {
+      const full = path3.join(e.parentPath, e.name);
+      files[path3.relative(dir, full)] = await fs3.readFile(full, "utf-8");
+    })
+  );
   return files;
 }
 async function bundleAgent(agent, opts) {
-  const aaiDir = path2.join(agent.dir, ".aai");
-  const buildDir = path2.join(aaiDir, "build");
-  const clientDir = path2.join(aaiDir, "client");
-  await fs2.mkdir(aaiDir, { recursive: true });
-  const workerEntry = path2.join(aaiDir, "_worker_entry.ts");
-  await fs2.writeFile(
-    workerEntry,
-    [
-      `import agent from "../agent.ts";`,
-      `import { initWorker } from "@alexkroman1/aai/worker-shim";`,
-      `initWorker(agent);`
-    ].join("\n")
-  );
+  const aaiDir = path3.join(agent.dir, ".aai");
+  const buildDir = path3.join(aaiDir, "build");
+  const clientDir = path3.join(aaiDir, "client");
+  const devMode = isDevMode();
+  const devResolve = devMode ? { conditions: ["source"] } : {};
   try {
     await build({
       configFile: false,
       root: agent.dir,
       logLevel: "warn",
+      plugins: [workerEntryPlugin()],
+      resolve: devResolve,
       build: {
+        rollupOptions: {
+          input: "virtual:worker-entry",
+          output: { format: "es", entryFileNames: "worker.js" }
+        },
         outDir: buildDir,
         emptyOutDir: true,
         minify: true,
-        target: "es2022",
-        rollupOptions: {
-          input: workerEntry,
-          output: {
-            format: "es",
-            entryFileNames: "worker.js",
-            inlineDynamicImports: true
-          }
-        }
+        target: "es2022"
       }
     });
   } catch (err) {
-    throw new BundleError(err instanceof Error ? err.message : String(err));
+    throw new BundleError(errorMessage(err));
   }
   const skipClient = opts?.skipClient || !agent.clientEntry;
   if (!skipClient) {
-    const devAlias = {};
-    if (isDevMode()) {
-      const monorepoRoot = path2.resolve(import.meta.dirname ?? __dirname, "..");
-      devAlias["@alexkroman1/aai/ui/styles.css"] = path2.join(monorepoRoot, "ui/styles.css");
-      devAlias["@alexkroman1/aai/ui"] = path2.join(monorepoRoot, "ui/mod.ts");
-      devAlias["@alexkroman1/aai"] = path2.join(monorepoRoot, "sdk/mod.ts");
-      const userPreact = path2.join(agent.dir, "node_modules/preact");
-      const userSignals = path2.join(agent.dir, "node_modules/@preact/signals");
-      devAlias.preact = userPreact;
-      devAlias["@preact/signals"] = userSignals;
-    }
     try {
       await build({
         root: agent.dir,
         base: "./",
         logLevel: "warn",
         plugins: [preact(), tailwindcss()],
-        ...Object.keys(devAlias).length > 0 && { resolve: { alias: devAlias } },
+        resolve: {
+          ...devResolve,
+          ...devMode && { dedupe: ["preact", "@preact/signals"] }
+        },
         build: {
           outDir: clientDir,
           emptyOutDir: true,
@@ -408,11 +490,11 @@ async function bundleAgent(agent, opts) {
         }
       });
     } catch (err) {
-      throw new BundleError(err instanceof Error ? err.message : String(err));
+      throw new BundleError(errorMessage(err));
     }
   }
-  const worker = await fs2.readFile(path2.join(buildDir, "worker.js"), "utf-8");
-  const clientFiles = await readDirRecursive(clientDir);
+  const worker = await fs3.readFile(path3.join(buildDir, "worker.js"), "utf-8");
+  const clientFiles = await readDirFiles(clientDir);
   return {
     worker,
     clientFiles,
@@ -424,6 +506,7 @@ var BundleError;
 var init_bundler = __esm({
   "cli/_bundler.ts"() {
     "use strict";
+    init_utils();
     init_discover();
     BundleError = class extends Error {
       constructor(message) {
@@ -434,280 +517,68 @@ var init_bundler = __esm({
   }
 });
 
-// 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";
-function Step({ action, msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLORS.primary, children: action }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function StepInfo({ action, msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLORS.interactive, children: action }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function Info({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-    "  ",
-    msg
-  ] });
-}
-function Detail({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    "  ",
-    msg
-  ] });
-}
-function Warn({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLORS.warning, children: "\u25B2" }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function ErrorLine({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLORS.error, children: "\u2717" }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function StepLog({ items }) {
-  return /* @__PURE__ */ jsx2(Static, { items, children: (item) => /* @__PURE__ */ jsx2(Box2, { children: item.node }, item.id) });
-}
-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,
-  onError
-}) {
-  const { exit } = useApp();
-  const { items, log } = useStepLog();
-  const [spinning, setSpinning] = useState(true);
-  const [currentStep, setCurrentStep] = useState(null);
-  const [err, setErr] = useState(null);
-  const currentStepRef = useRef(null);
-  const wrappedLog = (node) => {
-    if (currentStepRef.current) {
-      log(currentStepRef.current);
-    }
-    currentStepRef.current = node;
-    setCurrentStep(node);
-  };
-  const started = useRef(false);
-  React.useEffect(() => {
-    if (started.current) return;
-    started.current = true;
-    (async () => {
-      try {
-        await run(wrappedLog);
-      } catch (e) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        setErr(error.message);
-        onError?.(error);
-      }
-      if (currentStepRef.current) {
-        log(currentStepRef.current);
-        currentStepRef.current = null;
-      }
-      setCurrentStep(null);
-      setSpinning(false);
-      setTimeout(() => exit(), 0);
-    })();
-  });
-  return /* @__PURE__ */ jsxs2(Fragment, { children: [
-    /* @__PURE__ */ jsx2(StepLog, { items }),
-    err && /* @__PURE__ */ jsx2(ErrorLine, { msg: err }),
-    spinning && currentStep && /* @__PURE__ */ jsxs2(Box2, { children: [
-      /* @__PURE__ */ jsx2(Spinner, {}),
-      /* @__PURE__ */ jsx2(Text2, { children: " " }),
-      currentStep
-    ] })
-  ] });
-}
-async function runWithInk(fn) {
-  let thrownError;
-  const app = render2(
-    /* @__PURE__ */ jsx2(
-      CommandRunner,
-      {
-        onError: (e) => {
-          thrownError = e;
-        },
-        run: fn
-      }
-    )
-  );
-  await app.waitUntilExit();
-  if (thrownError) process.exit(1);
-}
-var init_ink = __esm({
-  "cli/_ink.tsx"() {
-    "use strict";
-    init_colors();
-  }
+// cli/_build.tsx
+var build_exports = {};
+__export(build_exports, {
+  buildAgentBundle: () => buildAgentBundle,
+  runBuildCommand: () => runBuildCommand
 });
-
-// cli/_build.ts
-import React2 from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
 async function buildAgentBundle(cwd, log, opts) {
   const agent = await loadAgent(cwd);
   if (!agent) {
     throw new Error("No agent found \u2014 run `aai init` first");
   }
-  log(React2.createElement(Step, { action: "Bundle", msg: agent.slug }));
+  log(/* @__PURE__ */ jsx3(Step, { action: "Bundle", msg: agent.slug }));
   let bundle;
   try {
     bundle = await bundleAgent(agent);
   } catch (err) {
-    if (err instanceof BundleError) {
-      throw new Error(`Bundle failed: ${err.message}`);
-    }
-    throw err;
-  }
-  const kb = (bundle.workerBytes / 1024).toFixed(1);
-  const clientCount = Object.keys(bundle.clientFiles).length;
-  log(React2.createElement(Info, { msg: `worker: ${kb} KB, client: ${clientCount} file(s)` }));
-  if (agent.clientEntry && !opts?.skipRenderCheck) {
-    try {
-      const renderCheckPath = "../sdk/_render_check.ts";
-      const { renderCheck } = await import(
-        /* @vite-ignore */
-        renderCheckPath
-      );
-      log(React2.createElement(Step, { action: "Render", msg: "check" }));
-      await renderCheck(agent.clientEntry, cwd);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      if (msg.includes("linkedom") || msg.includes("_render_check")) return bundle;
-      throw new Error(`Render check failed: ${msg}`);
-    }
-  }
-  return bundle;
-}
-var init_build = __esm({
-  "cli/_build.ts"() {
-    "use strict";
-    init_bundler();
-    init_discover();
-    init_ink();
-  }
-});
-
-// cli/_init.ts
-var init_exports = {};
-__export(init_exports, {
-  listTemplates: () => listTemplates,
-  runInit: () => runInit
-});
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
-import glob from "fast-glob";
-import fsExtra from "fs-extra";
-async function listTemplates(dir) {
-  const templates = [];
-  const entries = await fs3.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 = path3.join(dest, file);
-    try {
-      await fs3.access(destPath);
-    } catch {
-      await fs3.mkdir(path3.dirname(destPath), { recursive: true });
-      await fs3.copyFile(path3.join(src, file), destPath);
-    }
-  }
-}
-async function runInit(opts) {
-  const { targetDir, template, templatesDir } = opts;
-  const available = await listTemplates(templatesDir);
-  if (!available.includes(template)) {
-    throw new Error(`unknown template '${template}' -- available: ${available.join(", ")}`);
-  }
-  await fsExtra.copy(path3.join(templatesDir, template), targetDir, { overwrite: true });
-  await copyDirNoOverwrite(path3.join(templatesDir, "_shared"), targetDir);
-  try {
-    await fs3.copyFile(path3.join(targetDir, ".env.example"), path3.join(targetDir, ".env"));
-  } catch {
-  }
-  const readmePath = path3.join(targetDir, "README.md");
-  try {
-    await fs3.access(readmePath);
-  } catch {
-    const slug = path3.basename(path3.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 fs3.writeFile(readmePath, readme);
+    if (err instanceof BundleError) {
+      throw new Error(`Bundle failed: ${err.message}`);
+    }
+    throw err;
   }
-  return targetDir;
+  const kb = (bundle.workerBytes / 1024).toFixed(1);
+  const clientCount = Object.keys(bundle.clientFiles).length;
+  log(/* @__PURE__ */ jsx3(Info, { msg: `worker: ${kb} KB, client: ${clientCount} file(s)` }));
+  if (agent.clientEntry && !opts?.skipRenderCheck) {
+    const renderCheckPath = "../sdk/_render_check.ts";
+    const mod = await import(
+      /* @vite-ignore */
+      renderCheckPath
+    ).catch(() => null);
+    if (mod) {
+      log(/* @__PURE__ */ jsx3(Step, { action: "Render", msg: "check" }));
+      try {
+        await mod.renderCheck(agent.clientEntry, cwd);
+      } catch (err) {
+        throw new Error(`Render check failed: ${errorMessage(err)}`);
+      }
+    }
+  }
+  return bundle;
 }
-var init_init = __esm({
-  "cli/_init.ts"() {
+async function runBuildCommand(cwd) {
+  await runWithInk(async ({ log }) => {
+    await buildAgentBundle(cwd, log);
+    log(/* @__PURE__ */ jsx3(Step, { action: "Build", msg: "ok" }));
+  });
+}
+var init_build = __esm({
+  "cli/_build.tsx"() {
     "use strict";
+    init_utils();
+    init_bundler();
+    init_discover();
+    init_ink();
   }
 });
 
 // cli/_deploy.ts
-async function attemptDeploy(url, slug, apiKey, env, worker, clientFiles) {
+async function attemptDeploy(fetchFn, url, slug, apiKey, env, worker, clientFiles) {
   try {
-    return await _internals.fetch(`${url}/${slug}/deploy`, {
+    return await fetchFn(`${url}/${slug}/deploy`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -724,37 +595,36 @@ async function attemptDeploy(url, slug, apiKey, env, worker, clientFiles) {
   }
 }
 async function runDeploy(opts) {
-  const worker = opts.bundle.worker;
-  const clientFiles = opts.bundle.clientFiles;
+  const { worker, clientFiles } = opts.bundle;
+  const fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
   let slug = opts.slug;
-  if (opts.dryRun) {
-    return { slug };
-  }
   for (let i = 0; i < MAX_RETRIES; i++) {
-    const resp = await attemptDeploy(opts.url, slug, opts.apiKey, opts.env, worker, clientFiles);
+    const resp = await attemptDeploy(
+      fetchFn,
+      opts.url,
+      slug,
+      opts.apiKey,
+      opts.env,
+      worker,
+      clientFiles
+    );
     if (resp.ok) {
       return { slug };
     }
-    if (resp.status === 403) {
-      const text2 = await resp.text();
-      if (text2.includes("Slug")) {
-        slug = generateSlug();
-        continue;
-      }
-    }
     const text = await resp.text();
+    if (resp.status === 403 && text.includes("Slug")) {
+      slug = generateSlug();
+      continue;
+    }
     throw new Error(`deploy failed (${resp.status}): ${text}`);
   }
   throw new Error(`deploy failed: could not find available slug after ${MAX_RETRIES} attempts`);
 }
-var _internals, MAX_RETRIES;
+var MAX_RETRIES;
 var init_deploy = __esm({
   "cli/_deploy.ts"() {
     "use strict";
     init_discover();
-    _internals = {
-      fetch: globalThis.fetch.bind(globalThis)
-    };
     MAX_RETRIES = 20;
   }
 });
@@ -764,103 +634,73 @@ var deploy_exports = {};
 __export(deploy_exports, {
   runDeployCommand: () => runDeployCommand
 });
-import path4 from "node:path";
-import minimist from "minimist";
-import { jsx as jsx3 } from "react/jsx-runtime";
-function resolveServerUrl(parsed) {
-  return parsed.server || (isDevMode() ? "http://localhost:3100" : DEFAULT_SERVER);
-}
+import { jsx as jsx4 } from "react/jsx-runtime";
 async function deployBundle(opts) {
   const { bundle, serverUrl, apiKey, cwd, log } = opts;
   let { slug } = opts;
-  log(/* @__PURE__ */ jsx3(Step, { action: "Deploy", msg: slug }));
+  log(/* @__PURE__ */ jsx4(Step, { action: "Deploy", msg: slug }));
   const deployed = await runDeploy({
     url: serverUrl,
     bundle,
     env: { ASSEMBLYAI_API_KEY: apiKey },
     slug,
-    dryRun: false,
     apiKey
   });
   slug = deployed.slug;
   await writeProjectConfig(cwd, { slug, serverUrl });
   const agentUrl = `${serverUrl}/${slug}`;
-  log(/* @__PURE__ */ jsx3(Step, { action: "Ready", msg: agentUrl }));
+  log(/* @__PURE__ */ jsx4(Step, { action: "Ready", msg: agentUrl }));
   return agentUrl;
 }
-async function runDeployCommand(args, version) {
-  const parsed = minimist(args, {
-    string: ["server"],
-    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(path4.join(cwd, "agent.ts"))) {
-    await runInitCommand(parsed.yes ? ["-y"] : [], version, { quiet: true });
-  }
-  const serverUrl = resolveServerUrl(parsed);
-  const dryRun = parsed["dry-run"] ?? false;
+async function runDeployCommand(opts) {
+  const { cwd } = opts;
+  const dryRun = opts.dryRun ?? false;
   const apiKey = dryRun ? "" : await getApiKey();
   const projectConfig = await readProjectConfig(cwd);
+  const serverUrl = resolveServerUrl(opts.server, projectConfig?.serverUrl);
   const slug = projectConfig?.slug ?? generateSlug();
   let agentUrl = "";
-  await runWithInk(async (log) => {
+  await runWithInk(async ({ log }) => {
     const bundle = await buildAgentBundle(cwd, log);
     if (dryRun) {
-      log(/* @__PURE__ */ jsx3(StepInfo, { action: "Dry run", msg: `would deploy as ${slug}` }));
+      log(/* @__PURE__ */ jsx4(StepInfo, { action: "Dry run", msg: `would deploy as ${slug}` }));
       return;
     }
     agentUrl = await deployBundle({ bundle, serverUrl, apiKey, slug, cwd, log });
   });
-  if (agentUrl && !dryRun) {
+  if (agentUrl) {
     await askEnter("Press enter to open in browser");
     const { exec } = await import("node:child_process");
     exec(`open "${agentUrl}"`);
   }
 }
-var deployCommandDef;
 var init_deploy2 = __esm({
   "cli/deploy.tsx"() {
     "use strict";
     init_build();
     init_deploy();
     init_discover();
-    init_help();
     init_ink();
     init_prompts();
-    init_init2();
-    deployCommandDef = {
-      name: "deploy",
-      description: "Bundle and deploy to production",
-      options: [
-        { flags: "-s, --server <url>", description: "Server URL" },
-        {
-          flags: "--dry-run",
-          description: "Validate and bundle without deploying"
-        },
-        { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
-      ]
-    };
   }
 });
 
 // cli/init.tsx
+var init_exports2 = {};
+__export(init_exports2, {
+  runInitCommand: () => runInitCommand
+});
 import { execFile } from "node:child_process";
 import fs4 from "node:fs/promises";
-import path5 from "node:path";
+import path4 from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
-import minimist2 from "minimist";
-import { jsx as jsx4 } from "react/jsx-runtime";
+import { jsx as jsx5 } from "react/jsx-runtime";
 async function rewriteDevDeps(cwd, cliDir2) {
-  const monorepoRoot = path5.join(cliDir2, "..");
-  const pkgJsonPath2 = path5.join(cwd, "package.json");
+  const monorepoRoot = path4.join(cliDir2, "..");
+  const pkgJsonPath2 = path4.join(cwd, "package.json");
   const pkgJson2 = JSON.parse(await fs4.readFile(pkgJsonPath2, "utf-8"));
-  const rootPkg = JSON.parse(await fs4.readFile(path5.join(monorepoRoot, "package.json"), "utf-8"));
+  const rootPkg = JSON.parse(await fs4.readFile(path4.join(monorepoRoot, "package.json"), "utf-8"));
   const rootPkgName = rootPkg.name;
   if (pkgJson2.dependencies[rootPkgName]) {
     pkgJson2.dependencies[rootPkgName] = `file:${monorepoRoot}`;
@@ -869,56 +709,45 @@ async function rewriteDevDeps(cwd, cliDir2) {
 `);
 }
 async function installDeps(cwd, log) {
-  if (await fileExists(path5.join(cwd, "node_modules"))) return;
+  if (await fileExists(path4.join(cwd, "node_modules"))) return;
   let pkgJson2;
   try {
-    pkgJson2 = JSON.parse(await fs4.readFile(path5.join(cwd, "package.json"), "utf-8"));
+    pkgJson2 = JSON.parse(await fs4.readFile(path4.join(cwd, "package.json"), "utf-8"));
   } catch {
     pkgJson2 = {};
   }
   const deps = Object.keys(pkgJson2.dependencies ?? {});
   const devDeps = Object.keys(pkgJson2.devDependencies ?? {});
   if (deps.length > 0) {
-    log(/* @__PURE__ */ jsx4(Step, { action: "Install", msg: deps.join(", ") }));
+    log(/* @__PURE__ */ jsx5(Step, { action: "Install", msg: deps.join(", ") }));
   }
   if (devDeps.length > 0) {
-    log(/* @__PURE__ */ jsx4(Step, { action: "Install", msg: `dev: ${devDeps.join(", ")}` }));
+    log(/* @__PURE__ */ jsx5(Step, { action: "Install", msg: `dev: ${devDeps.join(", ")}` }));
   }
   try {
     await execFileAsync("npm", ["install"], { cwd });
   } catch {
-    log(/* @__PURE__ */ jsx4(Warn, { msg: "npm install failed" }));
+    log(/* @__PURE__ */ jsx5(Warn, { msg: "npm install failed" }));
   }
 }
-async function runInitCommand(args, version, opts) {
-  const parsed = minimist2(args, {
-    string: ["template"],
-    boolean: ["force", "help"],
-    alias: { t: "template", f: "force", h: "help" }
-  });
-  if (parsed.help) {
-    console.log(subcommandHelp(initCommandDef, version));
-    return "";
-  }
-  const { getApiKey: getApiKey2 } = await Promise.resolve().then(() => (init_discover(), discover_exports));
-  await getApiKey2();
-  let dir = parsed._[0];
+async function runInitCommand(opts, extra) {
+  await getApiKey();
+  let dir = opts.dir;
   if (!dir) {
     dir = await askText("What is your project named?", "my-voice-agent");
   }
-  const cwd = path5.resolve(process.env.INIT_CWD || process.cwd(), dir);
-  if (!parsed.force && await fileExists(path5.join(cwd, "agent.ts"))) {
-    console.log(
+  const cwd = path4.resolve(resolveCwd(), dir);
+  if (!opts.force && await fileExists(path4.join(cwd, "agent.ts"))) {
+    throw new Error(
       `agent.ts already exists in this directory. Use ${interactive("--force")} to overwrite.`
     );
-    process.exit(1);
   }
-  const cliDir2 = path5.dirname(fileURLToPath(import.meta.url));
-  const templatesDir = path5.join(cliDir2, "..", "templates");
+  const cliDir2 = path4.dirname(fileURLToPath(import.meta.url));
+  const templatesDir = path4.join(cliDir2, "..", "templates");
   const { runInit: runInit2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-  const template = parsed.template || "simple";
-  await runWithInk(async (log) => {
-    log(/* @__PURE__ */ jsx4(Step, { action: "Create", msg: dir }));
+  const template = opts.template || "simple";
+  await runWithInk(async ({ log }) => {
+    log(/* @__PURE__ */ jsx5(Step, { action: "Create", msg: dir }));
     await runInit2({ targetDir: cwd, template, templatesDir });
     if (isDevMode()) {
       await rewriteDevDeps(cwd, cliDir2);
@@ -927,60 +756,32 @@ async function runInitCommand(args, version, opts) {
   });
   process.chdir(cwd);
   delete process.env.INIT_CWD;
-  if (!opts?.quiet) {
+  if (!extra?.quiet) {
     const { runDeployCommand: runDeployCommand2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
-    await runDeployCommand2(["-y"], version);
+    await runDeployCommand2({ cwd });
   }
   return cwd;
 }
-var execFileAsync, initCommandDef;
+var execFileAsync;
 var init_init2 = __esm({
   "cli/init.tsx"() {
     "use strict";
-    init_colors();
     init_discover();
-    init_help();
     init_ink();
     init_prompts();
     execFileAsync = promisify(execFile);
-    initCommandDef = {
-      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" }
-      ]
-    };
   }
 });
 
 // sdk/protocol.ts
 import { z } from "zod";
-var DEFAULT_TTS_SAMPLE_RATE, AUDIO_FORMAT, _bitsPerSample, _channels, AudioFrameSpec, KvRequestBaseSchema, HOOK_TIMEOUT_MS, SessionErrorCodeSchema, TranscriptEventSchema, ClientEventSchema, ClientMessageSchema;
+var DEFAULT_TTS_SAMPLE_RATE, AUDIO_FORMAT, KvRequestSchema, VectorRequestSchema, HOOK_TIMEOUT_MS, TOOL_EXECUTION_TIMEOUT_MS, SessionErrorCodeSchema, ev, textEv, turnOrder, ClientEventSchema, ClientMessageSchema;
 var init_protocol = __esm({
   "sdk/protocol.ts"() {
     "use strict";
     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", [
+    KvRequestSchema = z.discriminatedUnion("op", [
       z.object({ op: z.literal("get"), key: z.string().min(1) }),
       z.object({
         op: z.literal("set"),
@@ -994,9 +795,29 @@ var init_protocol = __esm({
         prefix: z.string(),
         limit: z.number().int().positive().optional(),
         reverse: z.boolean().optional()
+      }),
+      z.object({ op: z.literal("keys"), pattern: z.string().optional() })
+    ]);
+    VectorRequestSchema = z.discriminatedUnion("op", [
+      z.object({
+        op: z.literal("upsert"),
+        id: z.string().min(1),
+        data: z.string().min(1),
+        metadata: z.record(z.string(), z.unknown()).optional()
+      }),
+      z.object({
+        op: z.literal("query"),
+        text: z.string().min(1),
+        topK: z.number().int().positive().max(100).optional(),
+        filter: z.string().optional()
+      }),
+      z.object({
+        op: z.literal("remove"),
+        ids: z.array(z.string().min(1)).min(1)
       })
     ]);
     HOOK_TIMEOUT_MS = 5e3;
+    TOOL_EXECUTION_TIMEOUT_MS = 3e4;
     SessionErrorCodeSchema = z.enum([
       "stt",
       "llm",
@@ -1007,23 +828,16 @@ var init_protocol = __esm({
       "audio",
       "internal"
     ]);
-    TranscriptEventSchema = z.object({
-      type: z.literal("transcript"),
-      text: z.string(),
-      isFinal: z.boolean(),
-      turnOrder: z.number().int().nonnegative().optional()
-    });
+    ev = (t) => z.object({ type: z.literal(t) });
+    textEv = (t) => z.object({ type: z.literal(t), text: z.string() });
+    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("chat_delta"), text: z.string() }),
+      ev("speech_started"),
+      ev("speech_stopped"),
+      z.object({ type: z.literal("transcript"), text: z.string(), isFinal: z.boolean(), turnOrder }),
+      textEv("turn").extend({ turnOrder }),
+      textEv("chat"),
+      textEv("chat_delta"),
       z.object({
         type: z.literal("tool_call_start"),
         toolCallId: z.string(),
@@ -1035,55 +849,35 @@ var init_protocol = __esm({
         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()
-      })
+      ev("tts_done"),
+      ev("cancelled"),
+      ev("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") }),
+      ev("audio_ready"),
+      ev("cancel"),
+      ev("reset"),
       z.object({
         type: z.literal("history"),
-        messages: z.array(
-          z.object({
-            role: z.enum(["user", "assistant"]),
-            text: z.string().max(1e5)
-          })
-        ).max(200)
+        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 _log, consoleLogger, noopMetrics, DEFAULT_S2S_CONFIG;
 var init_runtime = __esm({
   "sdk/runtime.ts"() {
     "use strict";
     init_protocol();
+    _log = (m) => (msg, ctx) => console[m](msg, ...ctx ? [ctx] : []);
     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);
-      }
+      info: _log("log"),
+      warn: _log("warn"),
+      error: _log("error"),
+      debug: _log("debug")
     };
     noopMetrics = {
       sessionsTotal: { inc() {
@@ -1100,20 +894,230 @@ var init_runtime = __esm({
   }
 });
 
-// sdk/_internal_types.ts
+// sdk/s2s.ts
+var s2s_exports = {};
+__export(s2s_exports, {
+  connectS2s: () => connectS2s,
+  wrapOnStyleWebSocket: () => wrapOnStyleWebSocket
+});
 import { z as z2 } from "zod";
+function uint8ToBase64(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+}
+function base64ToUint8(base64) {
+  const buf = Buffer.from(base64, "base64");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function wrapOnStyleWebSocket(ws) {
+  const target = new EventTarget();
+  ws.on("open", () => target.dispatchEvent(new Event("open")));
+  ws.on("message", (data) => target.dispatchEvent(new MessageEvent("message", { data })));
+  ws.on("close", (code, reason) => {
+    const init = { reason: String(reason ?? "") };
+    if (typeof code === "number") init.code = code;
+    target.dispatchEvent(new CloseEvent("close", init));
+  });
+  ws.on(
+    "error",
+    (err) => target.dispatchEvent(
+      new ErrorEvent("error", {
+        message: errorMessage(err)
+      })
+    )
+  );
+  Object.defineProperties(target, {
+    readyState: { get: () => ws.readyState, enumerable: true },
+    send: { value: (data) => ws.send(data), enumerable: true },
+    close: { value: () => ws.close(), enumerable: true }
+  });
+  return target;
+}
+function dispatchS2sMessage(target, msg) {
+  const entry = S2S_DISPATCH[msg.type]?.(msg);
+  if (entry) target.dispatchEvent(new CustomEvent(entry[0], { detail: entry[1] }));
+}
+function connectS2s(opts) {
+  const { apiKey, config, createWebSocket, logger: log = consoleLogger } = opts;
+  return new Promise((resolve, reject) => {
+    log.info("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 json = JSON.stringify(msg);
+      if (msg.type !== "input.audio") {
+        log.info(
+          `S2S >> ${msg.type}`,
+          msg.type === "session.update" ? { payload: json } : void 0
+        );
+      }
+      ws.send(json);
+    }
+    const handle = Object.assign(target, {
+      sendAudio(audio) {
+        if (ws.readyState !== WS_OPEN) return;
+        ws.send(`{"type":"input.audio","audio":"${uint8ToBase64(audio)}"}`);
+      },
+      sendToolResult(callId, result) {
+        const msg = { type: "tool.result", call_id: callId, result };
+        log.info("S2S >> tool.result", { call_id: callId, resultLength: result.length });
+        send(msg);
+      },
+      updateSession(sessionConfig) {
+        send({ type: "session.update", session: sessionConfig });
+      },
+      resumeSession(sessionId) {
+        send({ type: "session.resume", session_id: sessionId });
+      },
+      close() {
+        log.info("S2S closing");
+        ws.close();
+      }
+    });
+    ws.addEventListener("open", () => {
+      opened = true;
+      log.info("S2S WebSocket open");
+      resolve(handle);
+    });
+    function handleS2sMessage(ev2) {
+      const data = ev2.data;
+      let raw;
+      try {
+        raw = JSON.parse(String(data));
+      } catch {
+        log.warn("S2S << invalid JSON", { data: String(data).slice(0, 200) });
+        return;
+      }
+      const obj = raw;
+      if (obj.type !== "reply.audio" && obj.type !== "input.audio") {
+        log.info(
+          `S2S << ${obj.type}`,
+          obj.type === "transcript.agent.delta" ? { delta: obj.delta } : void 0
+        );
+      }
+      if (obj.type === "reply.audio" && typeof obj.data === "string") {
+        const audioBytes = base64ToUint8(obj.data);
+        target.dispatchEvent(new CustomEvent("audio", { detail: { audio: audioBytes } }));
+        return;
+      }
+      const parsed = S2sServerMessageSchema.safeParse(raw);
+      if (!parsed.success) {
+        log.warn(
+          `S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`
+        );
+        return;
+      }
+      dispatchS2sMessage(target, parsed.data);
+    }
+    ws.addEventListener("message", handleS2sMessage);
+    ws.addEventListener("close", ((ev2) => {
+      log.info("S2S WebSocket closed", {
+        code: ev2.code ?? 0,
+        reason: ev2.reason ?? ""
+      });
+      target.dispatchEvent(new CustomEvent("close"));
+    }));
+    ws.addEventListener("error", ((ev2) => {
+      const message = ev2 instanceof ErrorEvent ? ev2.message : "WebSocket error";
+      const errObj = new Error(message);
+      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, S2sServerMessageSchema, S2S_DISPATCH;
+var init_s2s = __esm({
+  "sdk/s2s.ts"() {
+    "use strict";
+    init_utils();
+    init_runtime();
+    WS_OPEN = 1;
+    S2sServerMessageSchema = z2.discriminatedUnion("type", [
+      z2.object({ type: z2.literal("session.ready"), session_id: z2.string() }),
+      z2.object({ type: z2.literal("session.updated") }).passthrough(),
+      z2.object({ type: z2.literal("input.speech.started") }),
+      z2.object({ type: z2.literal("input.speech.stopped") }),
+      z2.object({ type: z2.literal("transcript.user.delta"), text: z2.string() }),
+      z2.object({
+        type: z2.literal("transcript.user"),
+        item_id: z2.string(),
+        text: z2.string()
+      }),
+      z2.object({ type: z2.literal("reply.started"), reply_id: z2.string() }),
+      // reply.audio is handled on the fast path before Zod.
+      z2.object({ type: z2.literal("transcript.agent.delta"), delta: z2.string() }).passthrough(),
+      z2.object({ type: z2.literal("transcript.agent"), text: z2.string() }),
+      z2.object({ type: z2.literal("reply.content_part.started") }).passthrough(),
+      z2.object({ type: z2.literal("reply.content_part.done") }).passthrough(),
+      z2.object({
+        type: z2.literal("tool.call"),
+        call_id: z2.string(),
+        name: z2.string(),
+        args: z2.record(z2.string(), z2.unknown()).optional().default({})
+      }),
+      z2.object({
+        type: z2.literal("reply.done"),
+        status: z2.string().optional()
+      }),
+      z2.object({
+        type: z2.literal("session.error"),
+        code: z2.string(),
+        message: z2.string()
+      }),
+      // Connection-level error (bare "error" without "session." prefix).
+      z2.object({
+        type: z2.literal("error"),
+        message: z2.string()
+      })
+    ]);
+    S2S_DISPATCH = {
+      "session.ready": (m) => ["ready", { session_id: m.session_id }],
+      "session.updated": (m) => ["session_updated", m],
+      "input.speech.started": () => ["speech_started", void 0],
+      "input.speech.stopped": () => ["speech_stopped", void 0],
+      "transcript.user.delta": (m) => ["user_transcript_delta", { text: m.text }],
+      "transcript.user": (m) => ["user_transcript", { item_id: m.item_id, text: m.text }],
+      "reply.started": (m) => ["reply_started", { reply_id: m.reply_id }],
+      "transcript.agent.delta": (m) => ["agent_transcript_delta", { text: m.delta }],
+      "transcript.agent": (m) => ["agent_transcript", { text: m.text }],
+      "tool.call": (m) => ["tool_call", { call_id: m.call_id, name: m.name, args: m.args }],
+      "reply.done": (m) => ["reply_done", { status: m.status }],
+      "session.error": (m) => [
+        m.code === "session_not_found" || m.code === "session_forbidden" ? "session_expired" : "error",
+        { code: m.code, message: m.message }
+      ],
+      error: (m) => ["error", { code: "connection", message: m.message }],
+      "reply.content_part.started": () => void 0,
+      "reply.content_part.done": () => void 0
+    };
+  }
+});
+
+// sdk/_internal_types.ts
+import { z as z3 } from "zod";
 function agentToolsToSchemas(tools) {
   return Object.entries(tools).map(([name, def]) => ({
     name,
     description: def.description,
-    parameters: z2.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
+    parameters: z3.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
   }));
 }
 var EMPTY_PARAMS;
 var init_internal_types = __esm({
   "sdk/_internal_types.ts"() {
     "use strict";
-    EMPTY_PARAMS = z2.object({});
+    EMPTY_PARAMS = z3.object({});
   }
 });
 
@@ -1139,68 +1143,16 @@ Voice-First Rules:
   }
 });
 
-// sdk/memory_tools.ts
-import { z as z3 } from "zod";
-function memoryTools() {
-  return {
-    save_memory: tool({
-      description: "Save a piece of information to persistent memory. Use a descriptive key like 'user:name' or 'project:status'.",
-      parameters: z3.object({
-        key: z3.string().describe("A descriptive key for this memory (e.g. 'user:name', 'preference:color')"),
-        value: z3.string().describe("The information to remember")
-      }),
-      execute: async ({ key, value }, ctx) => {
-        await ctx.kv.set(key, value);
-        return { saved: key };
-      }
-    }),
-    recall_memory: tool({
-      description: "Retrieve a previously saved memory by its key.",
-      parameters: z3.object({
-        key: z3.string().describe("The key to look up")
-      }),
-      execute: async ({ key }, ctx) => {
-        const value = await ctx.kv.get(key);
-        if (value === null) return { found: false, key };
-        return { found: true, key, value };
-      }
-    }),
-    list_memories: tool({
-      description: "List all saved memory keys, optionally filtered by a prefix (e.g. 'user:').",
-      parameters: z3.object({
-        prefix: z3.string().describe("Prefix to filter keys (e.g. 'user:'). Use empty string for all.").optional()
-      }),
-      execute: async ({ prefix }, ctx) => {
-        const entries = await ctx.kv.list(prefix ?? "");
-        return { count: entries.length, keys: entries.map((e) => e.key) };
-      }
-    }),
-    forget_memory: tool({
-      description: "Delete a previously saved memory by its key.",
-      parameters: z3.object({
-        key: z3.string().describe("The key to delete")
-      }),
-      execute: async ({ key }, ctx) => {
-        await ctx.kv.delete(key);
-        return { deleted: key };
-      }
-    })
-  };
-}
-var init_memory_tools = __esm({
-  "sdk/memory_tools.ts"() {
-    "use strict";
-    init_types();
-  }
-});
-
 // sdk/builtin_tools.ts
 import { convert } from "html-to-text";
 import { z as z4 } from "zod";
+function fetchSignal(toolSignal) {
+  return AbortSignal.any([toolSignal, AbortSignal.timeout(FETCH_TIMEOUT_MS)]);
+}
 function htmlToText(html) {
   return convert(html, { wordwrap: false });
 }
-function createWebSearch() {
+function createWebSearch(fetchFn = globalThis.fetch) {
   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,
@@ -1215,9 +1167,9 @@ function createWebSearch() {
         count: String(maxResults),
         text_decorations: "false"
       })}`;
-      const resp = await fetch(url, {
+      const resp = await fetchFn(url, {
         headers: { "X-Subscription-Token": apiKey },
-        signal: ctx.abortSignal ?? AbortSignal.timeout(15e3)
+        signal: fetchSignal(ctx.abortSignal)
       });
       if (!resp.ok) return [];
       const raw = await resp.json();
@@ -1231,19 +1183,19 @@ function createWebSearch() {
     }
   };
 }
-function createVisitWebpage() {
+function createVisitWebpage(fetchFn = globalThis.fetch) {
   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, {
+      const resp = await fetchFn(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)
+        signal: fetchSignal(ctx.abortSignal)
       });
       if (!resp.ok) {
         return { error: `Failed to fetch: ${resp.status} ${resp.statusText}`, url };
@@ -1261,15 +1213,15 @@ function createVisitWebpage() {
     }
   };
 }
-function createFetchJson() {
+function createFetchJson(fetchFn = globalThis.fetch) {
   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, {
+      const resp = await fetchFn(url, {
         ...headers && { headers },
-        signal: ctx.abortSignal ?? AbortSignal.timeout(15e3)
+        signal: fetchSignal(ctx.abortSignal)
       });
       if (!resp.ok) {
         return { error: `HTTP ${resp.status} ${resp.statusText}`, url };
@@ -1299,7 +1251,6 @@ function createRunCode() {
         error: capture,
         debug: capture
       };
-      const RUN_CODE_TIMEOUT = 5e3;
       const AsyncFunction = Object.getPrototypeOf(async () => {
       }).constructor;
       try {
@@ -1313,7 +1264,7 @@ function createRunCode() {
         const result = output.join("\n").trim();
         return result || "Code ran successfully (no output)";
       } catch (err) {
-        return { error: err instanceof Error ? err.message : String(err) };
+        return { error: errorMessage(err) };
       }
     }
   };
@@ -1328,66 +1279,84 @@ function createVectorSearch(vectorSearchFn) {
     }
   };
 }
+function resolveBuiltin(name, opts) {
+  const entry = TOOL_REGISTRY[name];
+  if (!entry) return [];
+  if ("multi" in entry) return Object.entries(entry.multi());
+  if (name === "vector_search" && !opts?.vectorSearch) return [];
+  return [[name, entry.create(opts)]];
+}
 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;
-      case "memory": {
-        const mt = memoryTools();
-        for (const [toolName, toolDef] of Object.entries(mt)) {
-          defs[toolName] = toolDef;
-        }
-        break;
+    for (const [k, v] of resolveBuiltin(name, opts)) defs[k] = v;
+  }
+  return defs;
+}
+function getBuiltinToolSchemas(names) {
+  return names.flatMap(
+    (name) => resolveBuiltin(name, { vectorSearch: async () => "" }).map(([toolName, def]) => ({
+      name: toolName,
+      description: def.description,
+      parameters: z4.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
+    }))
+  );
+}
+function memoryTools() {
+  return {
+    save_memory: tool({
+      description: "Save a piece of information to persistent memory. Use a descriptive key like 'user:name' or 'project:status'.",
+      parameters: z4.object({
+        key: z4.string().describe("A descriptive key for this memory (e.g. 'user:name', 'preference:color')"),
+        value: z4.string().describe("The information to remember")
+      }),
+      execute: async ({ key, value }, ctx) => {
+        await ctx.kv.set(key, value);
+        return { saved: key };
+      }
+    }),
+    recall_memory: tool({
+      description: "Retrieve a previously saved memory by its key.",
+      parameters: z4.object({
+        key: z4.string().describe("The key to look up")
+      }),
+      execute: async ({ key }, ctx) => {
+        const value = await ctx.kv.get(key);
+        if (value === null) return { found: false, key };
+        return { found: true, key, value };
+      }
+    }),
+    list_memories: tool({
+      description: "List all saved memory keys, optionally filtered by a prefix (e.g. 'user:').",
+      parameters: z4.object({
+        prefix: z4.string().describe("Prefix to filter keys (e.g. 'user:'). Use empty string for all.").optional()
+      }),
+      execute: async ({ prefix }, ctx) => {
+        const entries = await ctx.kv.list(prefix ?? "");
+        return { count: entries.length, keys: entries.map((e) => e.key) };
       }
-    }
-  }
-  return defs;
-}
-function getBuiltinToolSchemas(names) {
-  return names.flatMap((name) => {
-    const multiCreator = MULTI_TOOL_BUILTINS[name];
-    if (multiCreator) {
-      return Object.entries(multiCreator()).map(([toolName, def2]) => ({
-        name: toolName,
-        description: def2.description,
-        parameters: z4.toJSONSchema(def2.parameters ?? EMPTY_PARAMS)
-      }));
-    }
-    const creator = TOOL_CREATORS[name];
-    if (!creator) return [];
-    const def = creator();
-    return [
-      {
-        name,
-        description: def.description,
-        parameters: z4.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
+    }),
+    forget_memory: tool({
+      description: "Delete a previously saved memory by its key.",
+      parameters: z4.object({
+        key: z4.string().describe("The key to delete")
+      }),
+      execute: async ({ key }, ctx) => {
+        await ctx.kv.delete(key);
+        return { deleted: key };
       }
-    ];
-  });
+    })
+  };
 }
-var webSearchParams, BRAVE_SEARCH_URL, BraveSearchResponseSchema, MAX_PAGE_CHARS, MAX_HTML_BYTES, visitWebpageParams, fetchJsonParams, runCodeParams, vectorSearchParams, TOOL_CREATORS, MULTI_TOOL_BUILTINS;
+var FETCH_TIMEOUT_MS, RUN_CODE_TIMEOUT, webSearchParams, BRAVE_SEARCH_URL, BraveSearchResponseSchema, MAX_PAGE_CHARS, MAX_HTML_BYTES, visitWebpageParams, fetchJsonParams, runCodeParams, vectorSearchParams, TOOL_REGISTRY;
 var init_builtin_tools = __esm({
   "sdk/builtin_tools.ts"() {
     "use strict";
     init_internal_types();
-    init_memory_tools();
+    init_utils();
+    init_types();
+    FETCH_TIMEOUT_MS = 15e3;
+    RUN_CODE_TIMEOUT = 5e3;
     webSearchParams = z4.object({
       query: z4.string().describe("The search query"),
       max_results: z4.number().describe("Maximum number of results to return (default 5)").optional()
@@ -1422,16 +1391,13 @@ var init_builtin_tools = __esm({
       ),
       topK: z4.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 () => "")
-    };
-    MULTI_TOOL_BUILTINS = {
-      memory: memoryTools
+    TOOL_REGISTRY = {
+      web_search: { create: (opts) => createWebSearch(opts?.fetch) },
+      visit_webpage: { create: (opts) => createVisitWebpage(opts?.fetch) },
+      fetch_json: { create: (opts) => createFetchJson(opts?.fetch) },
+      run_code: { create: createRunCode },
+      vector_search: { create: (opts) => createVectorSearch(opts?.vectorSearch ?? (async () => "")) },
+      memory: { multi: memoryTools }
     };
   }
 });
@@ -1502,291 +1468,6 @@ var init_kv = __esm({
   }
 });
 
-// sdk/s2s.ts
-import { z as z5 } from "zod";
-function uint8ToBase64(bytes) {
-  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
-}
-function base64ToUint8(base64) {
-  const buf = Buffer.from(base64, "base64");
-  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-function dispatchS2sMessage(target, msg) {
-  switch (msg.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;
-    // reply.audio handled on the fast path — never reaches dispatch.
-    case "transcript.agent.delta":
-      target.dispatchEvent(
-        new CustomEvent("agent_transcript_delta", {
-          detail: { text: msg.delta }
-        })
-      );
-      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 }
-        })
-      );
-      break;
-    case "session.error": {
-      const isExpired = msg.code === "session_not_found" || msg.code === "session_forbidden";
-      target.dispatchEvent(
-        new CustomEvent(isExpired ? "session_expired" : "error", {
-          detail: { code: msg.code, message: msg.message }
-        })
-      );
-      break;
-    }
-    case "reply.content_part.started":
-    case "reply.content_part.done":
-      break;
-    case "error":
-      target.dispatchEvent(
-        new CustomEvent("error", {
-          detail: { code: "connection", message: msg.message }
-        })
-      );
-      break;
-  }
-}
-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 json = JSON.stringify(msg);
-      if (msg.type !== "input.audio") {
-        log.debug(
-          `S2S >> ${msg.type}`,
-          msg.type === "session.update" ? { payload: json } : void 0
-        );
-      }
-      ws.send(json);
-    }
-    const handle = Object.assign(target, {
-      sendAudio(audio) {
-        if (ws.readyState !== WS_OPEN) return;
-        if (ws.sendBinary) {
-          const ab = audio.buffer.slice(
-            audio.byteOffset,
-            audio.byteOffset + audio.byteLength
-          );
-          ws.sendBinary(ab);
-        } else {
-          ws.send(`{"type":"input.audio","audio":"${uint8ToBase64(audio)}"}`);
-        }
-      },
-      sendToolResult(callId, result) {
-        const msg = { type: "tool.result", call_id: callId, result };
-        log.debug("S2S >> tool.result", { call_id: callId, resultLength: result.length });
-        send(msg);
-      },
-      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("audio", (data) => {
-      const ab = data;
-      target.dispatchEvent(new CustomEvent("audio", { detail: { audio: new Uint8Array(ab) } }));
-    });
-    ws.on("message", (data) => {
-      let raw;
-      try {
-        raw = JSON.parse(String(data));
-      } catch {
-        return;
-      }
-      const obj = raw;
-      if (obj.type !== "reply.audio" && obj.type !== "input.audio" && obj.type !== "transcript.agent.delta") {
-        log.info(`S2S << ${obj.type}`);
-      }
-      if (obj.type === "reply.audio" && typeof obj.data === "string") {
-        const audioBytes = base64ToUint8(obj.data);
-        target.dispatchEvent(new CustomEvent("audio", { detail: { audio: audioBytes } }));
-        return;
-      }
-      const parsed = S2sServerMessageSchema.safeParse(raw);
-      if (!parsed.success) {
-        log.warn(
-          `S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`
-        );
-        return;
-      }
-      const msg = parsed.data;
-      dispatchS2sMessage(target, msg);
-    });
-    ws.on("close", (code, reason) => {
-      log.info("S2S WebSocket closed", {
-        code: typeof code === "number" ? code : 0,
-        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, S2sServerMessageSchema;
-var init_s2s = __esm({
-  "sdk/s2s.ts"() {
-    "use strict";
-    init_runtime();
-    WS_OPEN = 1;
-    S2sServerMessageSchema = z5.discriminatedUnion("type", [
-      z5.object({ type: z5.literal("session.ready"), session_id: z5.string() }),
-      z5.object({ type: z5.literal("session.updated") }).passthrough(),
-      z5.object({ type: z5.literal("input.speech.started") }),
-      z5.object({ type: z5.literal("input.speech.stopped") }),
-      z5.object({ type: z5.literal("transcript.user.delta"), text: z5.string() }),
-      z5.object({
-        type: z5.literal("transcript.user"),
-        item_id: z5.string(),
-        text: z5.string()
-      }),
-      z5.object({ type: z5.literal("reply.started"), reply_id: z5.string() }),
-      // reply.audio is handled on the fast path before Zod — see message handler.
-      z5.object({ type: z5.literal("transcript.agent.delta"), delta: z5.string() }).passthrough(),
-      z5.object({ type: z5.literal("transcript.agent"), text: z5.string() }),
-      z5.object({ type: z5.literal("reply.content_part.started") }).passthrough(),
-      z5.object({ type: z5.literal("reply.content_part.done") }).passthrough(),
-      z5.object({
-        type: z5.literal("tool.call"),
-        call_id: z5.string(),
-        name: z5.string(),
-        args: z5.record(z5.string(), z5.unknown()).optional().default({})
-      }),
-      z5.object({
-        type: z5.literal("reply.done"),
-        status: z5.string().optional()
-      }),
-      z5.object({
-        type: z5.literal("session.error"),
-        code: z5.string(),
-        message: z5.string()
-      }),
-      // Connection-level error (bare "error" without "session." prefix).
-      z5.object({
-        type: z5.literal("error"),
-        message: z5.string()
-      })
-    ]);
-  }
-});
-
-// sdk/system_prompt.ts
-function buildSystemPrompt(config, opts) {
-  const { hasTools } = opts;
-  const agentInstructions = config.instructions && config.instructions !== DEFAULT_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 {
@@ -1817,7 +1498,6 @@ function createS2sSession(opts) {
   }));
   let s2s = null;
   const sessionAbort = new AbortController();
-  let audioReady = false;
   let toolCallCount = 0;
   let turnPromise = null;
   let conversationMessages = [];
@@ -1829,36 +1509,21 @@ function createS2sSession(opts) {
     if (!hookInvoker) return null;
     try {
       return await hookInvoker.resolveTurnConfig(id, HOOK_TIMEOUT_MS);
-    } catch {
+    } catch (err) {
+      log.warn("resolveTurnConfig hook failed", { err: errorMessage(err) });
       return null;
     }
   }
   function invokeHook(hook, arg) {
     if (!hookInvoker) return;
-    const run = async () => {
-      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, arg, HOOK_TIMEOUT_MS);
-          break;
-        case "onError":
-          await hookInvoker.onError(id, arg, HOOK_TIMEOUT_MS);
-          break;
-        case "onStep":
-          await hookInvoker.onStep(id, arg, HOOK_TIMEOUT_MS);
-          break;
-      }
-    };
-    run().catch((err) => {
-      log.warn(`${hook} hook failed`, {
-        err: err instanceof Error ? err.message : String(err)
+    try {
+      const h = hookInvoker[hook];
+      Promise.resolve(h.call(hookInvoker, id, arg, HOOK_TIMEOUT_MS)).catch((err) => {
+        log.warn(`${hook} hook failed`, { err: errorMessage(err) });
       });
-    });
+    } catch (err) {
+      log.warn(`${hook} hook failed`, { err: errorMessage(err) });
+    }
   }
   function checkTurnLimits(turnConfig, name) {
     const maxSteps = turnConfig?.maxSteps ?? agentConfig.maxSteps;
@@ -1898,7 +1563,7 @@ function createS2sSession(opts) {
     try {
       result = await executeTool(name, parsedArgs, id, conversationMessages);
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = errorMessage(err);
       log.error("Tool execution failed", { tool: name, error: msg });
       result = JSON.stringify({ error: msg });
     }
@@ -1913,6 +1578,79 @@ function createS2sSession(opts) {
   function on(target, event, handler) {
     target.addEventListener(event, handler);
   }
+  function setupListeners(handle) {
+    on(handle, "ready", (e) => {
+      s2sSessionId = e.detail.session_id;
+      log.info("S2S session ready", { session_id: s2sSessionId });
+    });
+    on(handle, "session_expired", () => {
+      log.info("S2S session expired, reconnecting fresh");
+      s2sSessionId = null;
+      handle.close();
+    });
+    for (const type of ["speech_started", "speech_stopped"]) {
+      handle.addEventListener(type, () => client.event({ type }));
+    }
+    on(handle, "user_transcript_delta", (e) => {
+      client.event({ type: "transcript", text: e.detail.text, isFinal: false });
+    });
+    on(handle, "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;
+    });
+    on(handle, "audio", (e) => {
+      client.playAudioChunk(e.detail.audio);
+    });
+    on(handle, "agent_transcript_delta", (e) => {
+      client.event({ type: "chat_delta", text: e.detail.text });
+    });
+    on(handle, "agent_transcript", (e) => {
+      const { text } = e.detail;
+      client.event({ type: "chat", text });
+      conversationMessages.push({ role: "assistant", content: text });
+    });
+    on(handle, "tool_call", (e) => {
+      const p = handleToolCall(e.detail).catch((err) => {
+        log.error("Tool call handler failed", { err: errorMessage(err) });
+      });
+      turnPromise = (turnPromise ?? Promise.resolve()).then(() => p);
+    });
+    on(handle, "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 tool2 of pendingTools) s2s?.sendToolResult(tool2.call_id, tool2.result);
+        pendingTools = [];
+      } else {
+        client.playAudioDone();
+        client.event({ type: "tts_done" });
+      }
+    });
+    on(handle, "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.close();
+    });
+    handle.addEventListener("close", () => {
+      log.info("S2S closed");
+      s2s = null;
+      if (!sessionAbort.signal.aborted) {
+        log.info("Attempting S2S reconnect");
+        connectAndSetup().catch((err) => {
+          log.error("S2S reconnect failed", { error: errorMessage(err) });
+        });
+      }
+    });
+  }
   async function connectAndSetup() {
     if (connecting) {
       pendingReconnect = true;
@@ -1920,106 +1658,15 @@ function createS2sSession(opts) {
     }
     connecting = true;
     try {
-      const handle = await _internals2.connectS2s({
+      const handle = await _internals.connectS2s({
         apiKey,
         config: s2sConfig,
         createWebSocket,
         logger: log
       });
-      on(handle, "ready", (e) => {
-        s2sSessionId = e.detail.session_id;
-        log.info("S2S session ready", { session_id: s2sSessionId });
-      });
-      on(handle, "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" });
-      });
-      on(handle, "user_transcript_delta", (e) => {
-        client.event({
-          type: "transcript",
-          text: e.detail.text,
-          isFinal: false
-        });
-      });
-      on(handle, "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;
-      });
-      on(handle, "audio", (e) => {
-        client.playAudioChunk(e.detail.audio);
-      });
-      on(handle, "agent_transcript_delta", (e) => {
-        client.event({ type: "chat_delta", text: e.detail.text });
-      });
-      on(handle, "agent_transcript", (e) => {
-        const { text } = e.detail;
-        client.event({ type: "chat", text });
-        conversationMessages.push({ role: "assistant", content: text });
-      });
-      on(handle, "tool_call", (e) => {
-        const p = handleToolCall(e.detail).catch((err) => {
-          log.error("Tool call handler failed", {
-            err: err instanceof Error ? err.message : String(err)
-          });
-        });
-        turnPromise = (turnPromise ?? Promise.resolve()).then(() => p);
-      });
-      on(handle, "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 tool2 of pendingTools) {
-            s2s?.sendToolResult(tool2.call_id, tool2.result);
-          }
-          pendingTools = [];
-        } else {
-          client.playAudioDone();
-          client.event({ type: "tts_done" });
-        }
-      });
-      on(handle, "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.close();
-      });
-      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 });
-          });
-        }
-      });
+      setupListeners(handle);
       if (s2sSessionId) {
-        log.info("Attempting S2S session resume", {
-          session_id: s2sSessionId
-        });
+        log.info("Attempting S2S session resume", { session_id: s2sSessionId });
         handle.resumeSession(s2sSessionId);
       } else {
         handle.updateSession({
@@ -2030,7 +1677,7 @@ function createS2sSession(opts) {
       }
       s2s = handle;
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
+      const msg = errorMessage(err);
       log.error("S2S connect failed", { error: msg });
       client.event({ type: "error", code: "internal", message: msg });
     } finally {
@@ -2038,8 +1685,7 @@ function createS2sSession(opts) {
       if (pendingReconnect && !sessionAbort.signal.aborted) {
         pendingReconnect = false;
         connectAndSetup().catch((err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          log.error("S2S deferred reconnect failed", { error: msg });
+          log.error("S2S deferred reconnect failed", { error: errorMessage(err) });
         });
       }
     }
@@ -2063,8 +1709,6 @@ function createS2sSession(opts) {
       s2s?.sendAudio(data);
     },
     onAudioReady() {
-      if (audioReady) return;
-      audioReady = true;
     },
     onCancel() {
       client.event({ type: "cancelled" });
@@ -2088,17 +1732,36 @@ function createS2sSession(opts) {
     }
   };
 }
-var _internals2;
+function buildSystemPrompt(config, opts) {
+  const { hasTools } = opts;
+  const agentInstructions = config.instructions && config.instructions !== DEFAULT_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 _internals, VOICE_RULES;
 var init_session = __esm({
   "sdk/session.ts"() {
     "use strict";
+    init_utils();
     init_protocol();
     init_runtime();
     init_s2s();
-    init_system_prompt();
-    _internals2 = {
+    init_types();
+    _internals = {
       connectS2s
     };
+    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';
   }
 });
 
@@ -2149,11 +1812,10 @@ var init_vector = __esm({
 
 // sdk/worker_entry.ts
 function buildToolContext(opts) {
-  const { env, sessionId, state, kv, vector, messages } = opts;
+  const { env, state, kv, vector, messages } = opts;
   return {
-    sessionId: sessionId ?? "",
     env: { ...env },
-    abortSignal: AbortSignal.timeout(TOOL_HANDLER_TIMEOUT),
+    abortSignal: AbortSignal.timeout(TOOL_EXECUTION_TIMEOUT_MS),
     state: state ?? {},
     get kv() {
       if (!kv) throw new Error("KV not available");
@@ -2182,21 +1844,18 @@ async function executeToolCall(name, args, options) {
     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)}`;
+    return `Error: ${errorMessage(err)}`;
   }
 }
-var yieldTick, TOOL_HANDLER_TIMEOUT;
+var yieldTick;
 var init_worker_entry = __esm({
   "sdk/worker_entry.ts"() {
     "use strict";
     init_internal_types();
+    init_utils();
+    init_protocol();
     yieldTick = () => new Promise((r) => setTimeout(r, 0));
-    TOOL_HANDLER_TIMEOUT = 3e4;
   }
 });
 
@@ -2248,7 +1907,6 @@ function createDirectExecutor(opts) {
   }
   function makeHookContext(sessionId) {
     return {
-      sessionId,
       env: frozenEnv,
       state: getState(sessionId),
       get kv() {
@@ -2265,7 +1923,6 @@ function createDirectExecutor(opts) {
     return executeToolCall(name, args, {
       tool: tool2,
       env: frozenEnv,
-      sessionId,
       state: getState(sessionId ?? ""),
       kv,
       vector,
@@ -2344,9 +2001,6 @@ var init_direct_executor = __esm({
 });
 
 // sdk/ws_handler.ts
-function isValidAudioChunk(data) {
-  return data.byteLength > 0 && data.byteLength <= MAX_AUDIO_CHUNK_BYTES && data.byteLength % 2 === 0;
-}
 function createClientSink(ws) {
   function safeSend(data) {
     try {
@@ -2378,19 +2032,9 @@ function toUint8Array(data) {
   const buf = data;
   return new Uint8Array(buf.buffer ?? data, buf.byteOffset ?? 0, buf.byteLength);
 }
-function handleBinaryAudio(data, session, log, ctx, sid) {
+function handleBinaryAudio(data, session) {
   if (!isBinaryData(data)) return false;
-  const chunk = toUint8Array(data);
-  if (!isValidAudioChunk(chunk)) {
-    log.warn("Invalid audio chunk, dropping", {
-      ...ctx,
-      sid,
-      bytes: chunk.byteLength,
-      aligned: chunk.byteLength % 2 === 0
-    });
-    return true;
-  }
-  session.onAudio(chunk);
+  session.onAudio(toUint8Array(data));
   return true;
 }
 function handleTextMessage(data, session, log, ctx, sid) {
@@ -2425,7 +2069,7 @@ function handleTextMessage(data, session, log, ctx, sid) {
 }
 function wireSessionSocket(ws, opts) {
   const { sessions, logger: log = consoleLogger } = opts;
-  const sessionId = opts.uid ?? crypto.randomUUID();
+  const sessionId = crypto.randomUUID();
   const sid = sessionId.slice(0, 8);
   const ctx = opts.logContext ?? {};
   let session = null;
@@ -2436,8 +2080,11 @@ function wireSessionSocket(ws, opts) {
     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 });
+    session.start().then(() => {
+      log.info("Session ready", { ...ctx, sid });
+    }).catch((err) => {
+      log.error("Session start failed", { ...ctx, sid, error: errorMessage(err) });
+    });
   }
   if (ws.readyState === 1) {
     onOpen();
@@ -2447,7 +2094,7 @@ function wireSessionSocket(ws, opts) {
   ws.addEventListener("message", (event) => {
     if (!session) return;
     const { data } = event;
-    if (handleBinaryAudio(data, session, log, ctx, sid)) return;
+    if (handleBinaryAudio(data, session)) return;
     handleTextMessage(data, session, log, ctx, sid);
   });
   ws.addEventListener("close", () => {
@@ -2464,13 +2111,12 @@ function wireSessionSocket(ws, opts) {
     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_utils();
     init_protocol();
     init_runtime();
-    MAX_AUDIO_CHUNK_BYTES = 1048576;
   }
 });
 
@@ -2529,8 +2175,7 @@ function createWintercServer(options) {
           skipGreeting: wsOpts?.skipGreeting ?? false
         }),
         readyConfig,
-        logger,
-        uid: wsOpts?.uid
+        logger
       });
     },
     async close() {
@@ -2565,7 +2210,7 @@ async function loadWsFactory() {
   try {
     const mod = await import("ws");
     const WS = mod.default ?? mod;
-    return (url, opts) => new WS(url, { headers: opts.headers });
+    return (url, opts) => wrapOnStyleWebSocket(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."
@@ -2573,11 +2218,7 @@ async function loadWsFactory() {
   }
 }
 function resolveEnv(env) {
-  const resolved = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (value !== void 0) resolved[key] = value;
-  }
-  return resolved;
+  return Object.fromEntries(Object.entries(env).filter(([, v]) => v !== void 0));
 }
 function createServer(options) {
   const {
@@ -2624,6 +2265,23 @@ function createServer(options) {
       await getWsFactory();
       const wintercServer = getWinterc();
       const app = new Hono2();
+      app.onError((err, c) => {
+        logger.error(`${c.req.method} ${new URL(c.req.url).pathname} error: ${err.message}`);
+        return c.json({ error: "Internal Server Error" }, 500);
+      });
+      app.use("/*", async (c, next) => {
+        const start = Date.now();
+        await next();
+        const ms = Date.now() - start;
+        const status = c.res.status;
+        const method = c.req.method;
+        const path8 = new URL(c.req.url).pathname;
+        if (status >= 400) {
+          logger.error(`${method} ${path8} ${status} ${ms}ms`);
+        } else {
+          logger.info(`${method} ${path8} ${status} ${ms}ms`);
+        }
+      });
       if (clientDir) {
         app.use("/*", serveStatic({ root: clientDir }));
       }
@@ -2636,11 +2294,12 @@ function createServer(options) {
         const wsMod = await import("ws");
         const wss = new wsMod.WebSocketServer({ noServer: true });
         nodeServer.on("upgrade", (req, socket, head) => {
+          const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
+          const resume = reqUrl.searchParams.has("resume");
+          logger.info(`WS upgrade ${reqUrl.pathname}${resume ? " (resume)" : ""}`);
           wss.handleUpgrade(req, socket, head, (ws) => {
-            const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
             wintercServer.handleWebSocket(ws, {
-              skipGreeting: reqUrl.searchParams.has("resume"),
-              uid: reqUrl.searchParams.get("uid") ?? void 0
+              skipGreeting: resume
             });
           });
         });
@@ -2665,88 +2324,30 @@ var init_server = __esm({
   "sdk/server.ts"() {
     "use strict";
     init_runtime();
+    init_s2s();
     init_winterc_server();
   }
 });
 
-// cli/cli.ts
-init_help();
-import { readFileSync } from "node:fs";
-import path11 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import minimist8 from "minimist";
-
-// cli/build.tsx
-init_build();
-init_discover();
-init_help();
-init_ink();
-init_init2();
-import path6 from "node:path";
-import minimist3 from "minimist";
-import { jsx as jsx5 } from "react/jsx-runtime";
-var buildCommandDef = {
-  name: "build",
-  description: "Bundle agent and client (validates code without deploying or starting a server)",
-  options: [{ flags: "-y, --yes", description: "Accept defaults (no prompts)" }]
-};
-async function runBuildCommand(args, version) {
-  const parsed = minimist3(args, {
-    boolean: ["help", "yes"],
-    alias: { h: "help", y: "yes" }
-  });
-  if (parsed.help) {
-    console.log(subcommandHelp(buildCommandDef, version));
-    return;
-  }
-  const cwd = process.env.INIT_CWD || process.cwd();
-  if (!await fileExists(path6.join(cwd, "agent.ts"))) {
-    await runInitCommand(parsed.yes ? ["-y"] : [], version, { quiet: true });
-  }
-  await runWithInk(async (log) => {
-    await buildAgentBundle(cwd, log);
-    log(/* @__PURE__ */ jsx5(Step, { action: "Build", msg: "ok" }));
-  });
-}
-
-// cli/cli.ts
-init_deploy2();
-
-// cli/dev.tsx
-import path8 from "node:path";
-import minimist4 from "minimist";
-
-// cli/_dev.ts
-init_build();
-init_ink();
-import React3 from "react";
-
 // cli/_server_common.ts
-init_discover();
 import fs5 from "node:fs/promises";
-import path7 from "node:path";
-import { createServer as createViteServer } from "vite";
+import path5 from "node:path";
+import { tsImport } from "tsx/esm/api";
 async function loadAgentDef(cwd) {
-  const agentPath = path7.resolve(cwd, "agent.ts");
-  const vite = await createViteServer({
-    root: cwd,
-    logLevel: "silent",
-    server: { middlewareMode: true }
-  });
-  try {
-    const agentModule = await vite.ssrLoadModule(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;
-  } finally {
-    await vite.close();
+  const agentPath = path5.resolve(cwd, "agent.ts");
+  const agentModule = await tsImport(agentPath, cwd);
+  let agentDef = agentModule.default;
+  if (agentDef?.__esModule && agentDef.default) {
+    agentDef = agentDef.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() {
+async function resolveServerEnv(baseEnv) {
   const env = Object.fromEntries(
-    Object.entries(process.env).filter((e) => e[1] !== void 0)
+    Object.entries(baseEnv ?? process.env).filter((e) => e[1] !== void 0)
   );
   if (!env.ASSEMBLYAI_API_KEY) {
     env.ASSEMBLYAI_API_KEY = await getApiKey();
@@ -2754,10 +2355,11 @@ async function resolveServerEnv() {
   return env;
 }
 async function bootServer(agentDef, clientDir, env, port) {
+  const { wrapOnStyleWebSocket: wrapOnStyleWebSocket2 } = await Promise.resolve().then(() => (init_s2s(), s2s_exports));
   const wsMod = await import("ws");
   const WS = wsMod.default ?? wsMod;
-  const createWebSocket = (url, opts) => new WS(url, { headers: opts.headers });
-  const clientHtml = await fs5.readFile(path7.join(clientDir, "index.html"), "utf-8");
+  const createWebSocket = (url, opts) => wrapOnStyleWebSocket2(new WS(url, { headers: opts.headers }));
+  const clientHtml = await fs5.readFile(path5.join(clientDir, "index.html"), "utf-8");
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = createServer2({
     agent: agentDef,
@@ -2768,155 +2370,186 @@ async function bootServer(agentDef, clientDir, env, port) {
   });
   await server.listen(port);
 }
+var init_server_common = __esm({
+  "cli/_server_common.ts"() {
+    "use strict";
+    init_discover();
+  }
+});
 
-// cli/_dev.ts
+// cli/dev.tsx
+var dev_exports = {};
+__export(dev_exports, {
+  _startDevServer: () => _startDevServer,
+  runDevCommand: () => runDevCommand
+});
+import { jsx as jsx6 } from "react/jsx-runtime";
 async function _startDevServer(cwd, port, log) {
   const bundle = await buildAgentBundle(cwd, log, { skipRenderCheck: true });
   const agentDef = await loadAgentDef(cwd);
   const env = await resolveServerEnv();
   await bootServer(agentDef, bundle.clientDir, env, port);
-  log(React3.createElement(Step, { action: "Ready", msg: `http://localhost:${port}` }));
+  log(/* @__PURE__ */ jsx6(Step, { action: "Ready", msg: `http://localhost:${port}` }));
 }
-
-// cli/dev.tsx
-init_discover();
-init_help();
-init_ink();
-init_init2();
-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 = minimist4(args, {
-    string: ["port"],
-    boolean: ["help", "yes"],
-    alias: { p: "port", h: "help", y: "yes" }
+async function runDevCommand(opts) {
+  const port = Number.parseInt(opts.port, 10);
+  await runWithInk(async ({ log }) => {
+    await _startDevServer(opts.cwd, port, log);
   });
-  if (parsed.help) {
-    console.log(subcommandHelp(devCommandDef, version));
-    return;
+}
+var init_dev = __esm({
+  "cli/dev.tsx"() {
+    "use strict";
+    init_build();
+    init_ink();
+    init_server_common();
   }
-  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 runInitCommand(parsed.yes ? ["-y"] : [], version, { quiet: true });
+});
+
+// cli/start.tsx
+var start_exports = {};
+__export(start_exports, {
+  _startProductionServer: () => _startProductionServer,
+  runStartCommand: () => runStartCommand
+});
+import path6 from "node:path";
+import { jsx as jsx7 } from "react/jsx-runtime";
+async function _startProductionServer(cwd, port, log) {
+  const clientDir = path6.join(cwd, ".aai", "client");
+  log(/* @__PURE__ */ jsx7(Step, { action: "Start", msg: "loading agent" }));
+  const agentDef = await loadAgentDef(cwd);
+  const env = await resolveServerEnv();
+  await bootServer(agentDef, clientDir, env, port);
+  log(/* @__PURE__ */ jsx7(Step, { action: "Ready", msg: `http://localhost:${port}` }));
+}
+async function runStartCommand(opts) {
+  const port = Number.parseInt(opts.port, 10);
+  const buildDir = path6.join(opts.cwd, ".aai", "build");
+  if (!await fileExists(path6.join(buildDir, "worker.js"))) {
+    throw new Error("No build found \u2014 run `aai build` first");
   }
-  await getApiKey();
-  await runWithInk(async (log) => {
-    await _startDevServer(cwd, port, log);
+  await runWithInk(async ({ log }) => {
+    log(/* @__PURE__ */ jsx7(Step, { action: "Start", msg: `production server on port ${port}` }));
+    await _startProductionServer(opts.cwd, port, log);
   });
 }
+var init_start = __esm({
+  "cli/start.tsx"() {
+    "use strict";
+    init_discover();
+    init_ink();
+    init_server_common();
+  }
+});
 
-// cli/cli.ts
-init_init2();
+// cli/secret.tsx
+var secret_exports = {};
+__export(secret_exports, {
+  runSecretDelete: () => runSecretDelete,
+  runSecretList: () => runSecretList,
+  runSecretPut: () => runSecretPut
+});
+import { jsx as jsx8 } from "react/jsx-runtime";
+async function apiFetch(cwd, pathSuffix, init) {
+  const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
+  const resp = await fetch(`${serverUrl}/${slug}/secret${pathSuffix}`, {
+    ...init,
+    headers: { Authorization: `Bearer ${apiKey}`, ...init?.headers }
+  });
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`Secret operation failed: ${text}`);
+  }
+  return { resp, slug };
+}
+async function runSecretPut(cwd, name) {
+  const value = await askPassword(`Enter value for ${name}`);
+  if (!value) throw new Error("No value provided");
+  await runWithInk(async ({ log }) => {
+    const { slug } = await apiFetch(cwd, "", {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ [name]: value })
+    });
+    log(/* @__PURE__ */ jsx8(Step, { action: "Set", msg: `${name} for ${slug}` }));
+  });
+}
+async function runSecretDelete(cwd, name) {
+  await runWithInk(async ({ log }) => {
+    const { slug } = await apiFetch(cwd, `/${name}`, { method: "DELETE" });
+    log(/* @__PURE__ */ jsx8(Step, { action: "Deleted", msg: `${name} from ${slug}` }));
+  });
+}
+async function runSecretList(cwd) {
+  await runWithInk(async ({ log }) => {
+    const { resp } = await apiFetch(cwd, "");
+    const { vars } = await resp.json();
+    if (vars.length === 0) {
+      log(/* @__PURE__ */ jsx8(StepInfo, { action: "Secrets", msg: "none set" }));
+    } else {
+      for (const name of vars) {
+        log(/* @__PURE__ */ jsx8(Detail, { msg: name }));
+      }
+    }
+  });
+}
+var init_secret = __esm({
+  "cli/secret.tsx"() {
+    "use strict";
+    init_discover();
+    init_ink();
+    init_prompts();
+  }
+});
 
 // cli/rag.tsx
-init_discover();
-init_help();
-init_ink();
-import { render as render3, Text as Text3, useApp as useApp2 } from "ink";
-import minimist5 from "minimist";
+var rag_exports = {};
+__export(rag_exports, {
+  chunkPages: () => chunkPages,
+  parsePage: () => parsePage,
+  runRagCommand: () => runRagCommand,
+  slugify: () => slugify,
+  splitPages: () => splitPages,
+  stripNoise: () => stripNoise,
+  upsertChunks: () => upsertChunks
+});
+import { Text as Text3 } from "ink";
 import pLimit from "p-limit";
-import { useEffect, useState as useState2 } from "react";
-import { Fragment as Fragment2, jsx as jsx6, 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 PAD = 2;
-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 error = e instanceof Error ? e : new Error(String(e));
-        setErr(error.message);
-        onError?.(error);
-      }
-      setProgress(null);
-      exit();
-    })();
-  }, [apiKey, chunkSize, exit, log, onError, serverUrl, slug, url]);
-  return /* @__PURE__ */ jsxs3(Fragment2, { children: [
-    /* @__PURE__ */ jsx6(StepLog, { items }),
-    err && /* @__PURE__ */ jsx6(ErrorLine, { msg: err }),
-    progress && /* @__PURE__ */ jsxs3(Text3, { children: [
-      " ".repeat(PAD + 1),
-      "Upsert ",
-      progress.completed,
-      "/",
-      progress.total,
-      " (",
-      Math.round(progress.completed / progress.total * 100),
-      "%)"
-    ] })
-  ] });
-}
+import { jsx as jsx9, jsxs as jsxs3 } from "react/jsx-runtime";
 async function runRag(opts) {
-  const { url, apiKey, serverUrl, slug, chunkSize, log, setProgress } = opts;
-  log(/* @__PURE__ */ jsx6(Step, { action: "Fetch", msg: url }));
+  const { url, apiKey, serverUrl, slug, chunkSize, log, setStatus } = opts;
+  log(/* @__PURE__ */ jsx9(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)
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS2)
   });
   if (!resp.ok) {
     throw new Error(`Failed to fetch: ${resp.status} ${resp.statusText}`);
   }
   const content = await resp.text();
   if (content.length === 0) {
-    log(/* @__PURE__ */ jsx6(Warn, { msg: "File is empty" }));
+    log(/* @__PURE__ */ jsx9(Warn, { msg: "File is empty" }));
     return;
   }
-  log(/* @__PURE__ */ jsx6(Info, { msg: `${(content.length / 1024).toFixed(0)} KB` }));
+  log(/* @__PURE__ */ jsx9(Info, { msg: `${(content.length / 1024).toFixed(0)} KB` }));
   const origin = new URL(url).origin;
   const pages = splitPages(content);
-  log(/* @__PURE__ */ jsx6(Step, { action: "Parse", msg: `${pages.length} pages` }));
+  log(/* @__PURE__ */ jsx9(Step, { action: "Parse", msg: `${pages.length} pages` }));
   const { RecursiveChunker } = await import("@chonkiejs/core");
   const chunker = await RecursiveChunker.create({ chunkSize });
   const siteSlug = slugify(origin);
   const allChunks = await chunkPages(pages, chunker, origin, siteSlug);
-  log(/* @__PURE__ */ jsx6(Step, { action: "Chunk", msg: `${allChunks.length} chunks` }));
+  log(/* @__PURE__ */ jsx9(Step, { action: "Chunk", msg: `${allChunks.length} chunks` }));
   const vectorUrl = `${serverUrl}/${slug}/vector`;
-  log(/* @__PURE__ */ jsx6(Info, { msg: `target: ${vectorUrl}` }));
-  const result = await upsertChunks(allChunks, vectorUrl, apiKey, setProgress);
-  log(/* @__PURE__ */ jsx6(Step, { action: "Done", msg: `${result.upserted} chunks upserted` }));
+  log(/* @__PURE__ */ jsx9(Info, { msg: `target: ${vectorUrl}` }));
+  const result = await upsertChunks(allChunks, vectorUrl, apiKey, setStatus);
+  log(/* @__PURE__ */ jsx9(Step, { action: "Done", msg: `${result.upserted} chunks upserted` }));
   if (result.errors > 0) {
-    log(/* @__PURE__ */ jsx6(Warn, { msg: `${result.errors} failed` }));
-    if (result.lastError) log(/* @__PURE__ */ jsx6(Info, { msg: `last error: ${result.lastError}` }));
+    log(/* @__PURE__ */ jsx9(Warn, { msg: `${result.errors} failed` }));
+    if (result.lastError) log(/* @__PURE__ */ jsx9(Info, { msg: `last error: ${result.lastError}` }));
   }
-  log(/* @__PURE__ */ jsx6(Detail, { msg: `Agent: ${slug}` }));
+  log(/* @__PURE__ */ jsx9(Detail, { msg: `Agent: ${slug}` }));
 }
 async function chunkPages(pages, chunker, origin, siteSlug) {
   const allChunks = [];
@@ -2942,19 +2575,34 @@ ${c.text}` : c.text;
   }
   return allChunks;
 }
-async function upsertChunks(chunks, vectorUrl, apiKey, setProgress) {
+async function upsertChunks(chunks, vectorUrl, apiKey, setStatus, fetchFn = globalThis.fetch) {
   const total = chunks.length;
   let completed = 0;
   let upserted = 0;
   let errors = 0;
   let lastError = "";
-  setProgress({ completed: 0, total });
+  const updateStatus = () => {
+    const pct = Math.round(completed / total * 100);
+    setStatus(
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        "   ",
+        "Upsert ",
+        completed,
+        "/",
+        total,
+        " (",
+        pct,
+        "%)"
+      ] })
+    );
+  };
+  updateStatus();
   const limit = pLimit(5);
   await Promise.all(
     chunks.map(
       (chunk) => limit(async () => {
         try {
-          const r = await fetch(vectorUrl, {
+          const r = await fetchFn(vectorUrl, {
             method: "POST",
             headers: {
               "Content-Type": "application/json",
@@ -2974,65 +2622,29 @@ async function upsertChunks(chunks, vectorUrl, apiKey, setProgress) {
             upserted++;
           }
         } catch (err) {
-          lastError = err instanceof Error ? err.message : String(err);
+          lastError = errorMessage(err);
           errors++;
         }
         completed++;
-        setProgress({ completed, total });
+        updateStatus();
       })
     )
   );
+  setStatus(null);
   return { upserted, errors, lastError };
 }
-async function runRagCommand(args, version) {
-  const parsed = minimist5(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"
-    );
-  }
+async function runRagCommand(opts) {
+  const { url, cwd } = opts;
   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__ */ jsx6(
-      RagUI,
-      {
-        url,
-        apiKey,
-        serverUrl,
-        slug,
-        chunkSize,
-        onError: (e) => {
-          thrownError = e;
-        }
-      }
-    )
-  );
-  await app.waitUntilExit();
-  if (thrownError) throw thrownError;
+  const { apiKey, serverUrl, slug } = await getServerInfo(cwd, opts.server);
+  const chunkSize = Number.parseInt(opts.chunkSize ?? "512", 10);
+  await runWithInk(async ({ log, setStatus }) => {
+    await runRag({ url, apiKey, serverUrl, slug, chunkSize, log, setStatus });
+  });
 }
 function splitPages(content) {
   const raw = content.split(/^\*{3,}$/m);
@@ -3079,243 +2691,153 @@ function stripNoise(text) {
 function slugify(s) {
   return s.replace(/^https?:\/\//, "").replace(/^#+\s*/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 80);
 }
+var FETCH_TIMEOUT_MS2;
+var init_rag = __esm({
+  "cli/rag.tsx"() {
+    "use strict";
+    init_utils();
+    init_discover();
+    init_ink();
+    FETCH_TIMEOUT_MS2 = 6e4;
+  }
+});
 
-// cli/secret.tsx
+// cli/cli.ts
+init_utils();
 init_discover();
-init_help();
 init_ink();
-init_prompts();
-import minimist6 from "minimist";
-import { jsx as jsx7 } 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 = minimist6(args, {
-    boolean: ["help", "yes"],
-    alias: { h: "help", y: "yes" },
-    stopEarly: true
+import { readFileSync } from "node:fs";
+import path7 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import chalk2 from "chalk";
+import { Command } from "commander";
+var cliDir = path7.dirname(fileURLToPath2(import.meta.url));
+var pkgJsonPath = path7.join(cliDir, "..", "package.json");
+var pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+var VERSION = pkgJson.version;
+var banner = [
+  "",
+  `  ${primary(chalk2.bold(" \u2584\u2580\u2588 \u2584\u2580\u2588 \u2588"))}   ${chalk2.dim("Voice agent development kit")}`,
+  `  ${primary(chalk2.bold(" \u2588\u2580\u2588 \u2588\u2580\u2588 \u2588"))}   ${primary(`v${VERSION}`)}`,
+  ""
+].join("\n");
+var gettingStarted = [
+  "",
+  `  ${chalk2.bold(interactive("Getting started"))}`,
+  "",
+  `    ${chalk2.dim("$")} ${primary("aai init")} ${interactive("my-agent")}`,
+  `    ${chalk2.dim("$")} ${primary("cd")} ${interactive("my-agent")}`,
+  `    ${chalk2.dim("$")} ${primary("aai dev")}`,
+  ""
+].join("\n");
+async function ensureAgent(cwd, yes) {
+  if (!await fileExists(path7.join(cwd, "agent.ts"))) {
+    const { runInitCommand: runInitCommand2 } = await Promise.resolve().then(() => (init_init2(), init_exports2));
+    await runInitCommand2({ yes }, { quiet: true });
+  }
+}
+function withCwd(cmd) {
+  return cmd.hook("preAction", (thisCmd) => {
+    thisCmd.setOptionValue("cwd", resolveCwd());
   });
-  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(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__ */ jsx7(Step, { action: "Set", msg: `${name} for ${slug}` }));
+function withAgentGuard(cmd) {
+  return cmd.hook("preAction", async (thisCmd) => {
+    await ensureAgent(thisCmd.getOptionValue("cwd"), thisCmd.opts().yes);
   });
 }
-async function secretDelete(cwd, name) {
-  if (!name) throw new Error("Usage: aai secret delete <NAME>");
-  await runWithInk(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__ */ jsx7(Step, { action: "Deleted", msg: `${name} from ${slug}` }));
+function withApiKey(cmd) {
+  return cmd.hook("preAction", async () => {
+    await getApiKey();
   });
 }
-async function secretList(cwd) {
-  await runWithInk(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__ */ jsx7(StepInfo, { action: "Secrets", msg: "none set" }));
-    } else {
-      for (const name of vars) {
-        log(/* @__PURE__ */ jsx7(Detail, { msg: name }));
-      }
+function createProgram() {
+  const program = new Command();
+  program.name("aai").version(VERSION, "-V, --version").addHelpText("before", banner).addHelpText("after", gettingStarted);
+  program.command("init").description("Scaffold a new agent project").argument("[dir]", "Project directory").option("-t, --template <template>", "Template to use").option("-f, --force", "Overwrite existing agent.ts").option("-y, --yes", "Accept defaults (no prompts)").action(
+    async (dir, opts) => {
+      const { runInitCommand: runInitCommand2 } = await Promise.resolve().then(() => (init_init2(), init_exports2));
+      await runInitCommand2({ dir, ...opts });
     }
+  );
+  withApiKey(
+    withAgentGuard(
+      withCwd(
+        program.command("dev").description("Start a local development server").option("-p, --port <number>", "Port to listen on", "3000").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
+          const { runDevCommand: runDevCommand2 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
+          await runDevCommand2(opts);
+        })
+      )
+    )
+  );
+  withAgentGuard(
+    withCwd(
+      program.command("build").description("Bundle and validate (no server or deploy)").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
+        const { runBuildCommand: runBuildCommand2 } = await Promise.resolve().then(() => (init_build(), build_exports));
+        await runBuildCommand2(opts.cwd);
+      })
+    )
+  );
+  withAgentGuard(
+    withCwd(
+      program.command("deploy").description("Bundle and deploy to production").option("-s, --server <url>", "Server URL").option("--dry-run", "Validate and bundle without deploying").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
+        const { runDeployCommand: runDeployCommand2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
+        await runDeployCommand2(opts);
+      })
+    )
+  );
+  withApiKey(
+    withCwd(
+      program.command("start").description("Start production server from build").option("-p, --port <number>", "Port to listen on", "3000").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
+        const { runStartCommand: runStartCommand2 } = await Promise.resolve().then(() => (init_start(), start_exports));
+        await runStartCommand2(opts);
+      })
+    )
+  );
+  const secret = program.command("secret").description("Manage secrets").action(() => secret.help());
+  withApiKey(withCwd(secret));
+  secret.command("put").description("Create or update a secret").argument("<name>", "Secret name").action(async (name, _opts, cmd) => {
+    const cwd = cmd.parent?.getOptionValue("cwd");
+    const { runSecretPut: runSecretPut2 } = await Promise.resolve().then(() => (init_secret(), secret_exports));
+    await runSecretPut2(cwd, name);
   });
-}
-
-// cli/start.tsx
-init_discover();
-init_help();
-init_ink();
-import path10 from "node:path";
-import minimist7 from "minimist";
-
-// cli/_start.ts
-init_ink();
-import path9 from "node:path";
-import React4 from "react";
-async function _startProductionServer(cwd, port, log) {
-  const clientDir = path9.join(cwd, ".aai", "client");
-  log(React4.createElement(Step, { action: "Start", msg: "loading agent" }));
-  const agentDef = await loadAgentDef(cwd);
-  const env = await resolveServerEnv();
-  await bootServer(agentDef, clientDir, env, port);
-  log(React4.createElement(Step, { action: "Ready", msg: `http://localhost:${port}` }));
-}
-
-// cli/start.tsx
-import { jsx as jsx8 } 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 = minimist7(args, {
-    string: ["port"],
-    boolean: ["help", "yes"],
-    alias: { p: "port", h: "help", y: "yes" }
+  secret.command("delete").description("Delete a secret").argument("<name>", "Secret name").action(async (name, _opts, cmd) => {
+    const cwd = cmd.parent?.getOptionValue("cwd");
+    const { runSecretDelete: runSecretDelete2 } = await Promise.resolve().then(() => (init_secret(), secret_exports));
+    await runSecretDelete2(cwd, name);
   });
-  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(async (log) => {
-    log(/* @__PURE__ */ jsx8(Step, { action: "Start", msg: `production server on port ${port}` }));
-    await _startProductionServer(cwd, port, log);
+  secret.command("list").description("List secret names").action(async (_opts, cmd) => {
+    const cwd = cmd.parent?.getOptionValue("cwd");
+    const { runSecretList: runSecretList2 } = await Promise.resolve().then(() => (init_secret(), secret_exports));
+    await runSecretList2(cwd);
   });
+  withApiKey(
+    withCwd(
+      program.command("rag").description("Ingest a site's llms-full.txt into the vector store").argument("<url>", "URL to ingest").option("-s, --server <url>", "Server URL").option("--chunk-size <n>", "Max chunk size in tokens", "512").option("-y, --yes", "Accept defaults (no prompts)").action(async (url, opts) => {
+        const { runRagCommand: runRagCommand2 } = await Promise.resolve().then(() => (init_rag(), rag_exports));
+        await runRagCommand2({ url, ...opts });
+      })
+    )
+  );
+  return program;
 }
-
-// cli/cli.ts
-var cliDir = path11.dirname(fileURLToPath2(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 = minimist8(args, {
-    boolean: ["help", "version"],
-    alias: { h: "help", V: "version" },
-    stopEarly: true
-  });
-  if (parsed.version) {
-    console.log(VERSION);
+  if (args.length === 0) {
+    const { runInitCommand: runInitCommand2 } = await Promise.resolve().then(() => (init_init2(), init_exports2));
+    await runInitCommand2({});
     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":
-      await runInitCommand(subArgs, VERSION);
-      return;
-    case "build":
-      await runBuildCommand(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":
-      console.log(rootHelp(VERSION));
-      return;
-    case void 0:
-      await runInitCommand(subArgs, VERSION);
-      return;
-    default:
-      console.error(`Unknown command: ${subcommand}`);
-      console.log(rootHelp(VERSION));
-      process.exit(1);
-  }
+  const program = createProgram();
+  await program.parseAsync(args, { from: "user" });
 }
 if (process.env.VITEST !== "true") {
   process.on("SIGINT", () => process.exit(0));
   main(process.argv.slice(2)).catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
+    console.error(errorMessage(err));
     process.exit(1);
   });
 }
 export {
+  createProgram,
   main
 };