@alexkroman1/aai 0.7.8 → 0.7.10

package/dist/cli.js

@@ -12,206 +12,951 @@ var __export = (target, all) => {
 // cli/_colors.ts
 import chalk from "chalk";
 function primary(s) {
-  return chalk.hex("#fab283")(s);
+  return chalk.hex(COLORS.primary)(s);
 }
 function interactive(s) {
-  return chalk.hex("#56b6c2")(s);
-}
-function error(s) {
-  return chalk.hex("#e06c75")(s);
-}
-function warning(s) {
-  return chalk.hex("#f5a742")(s);
+  return chalk.hex(COLORS.interactive)(s);
 }
+var COLORS;
 var init_colors = __esm({
   "cli/_colors.ts"() {
     "use strict";
+    COLORS = {
+      primary: "#fab283",
+      interactive: "#56b6c2",
+      error: "#e06c75",
+      warning: "#f5a742",
+      success: "#7fd88f",
+      accent: "#9d7cd8",
+      muted: "#808080"
+    };
   }
 });
 
-// cli/_output.ts
-import chalk3 from "chalk";
-function fmt(action, color, msg) {
-  return `${color(chalk3.bold(action.padStart(PAD)))} ${msg}`;
-}
-function step(action, msg) {
-  console.log(fmt(action, primary, msg));
-}
-function stepInfo(action, msg) {
-  console.log(fmt(action, interactive, msg));
-}
-function info(msg) {
-  console.log(chalk3.dim(`${" ".repeat(PAD + 1)}${msg}`));
-}
-function warn(msg) {
-  console.error(fmt("warning", warning, msg));
+// 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"],
+    ["deploy", "", "Bundle and deploy to production"],
+    ["start", "", "Start production server from build"],
+    ["secret", "<cmd>", "Manage secrets"],
+    ["rag", "<url>", "Ingest a site's llms-full.txt into the vector store"]
+  ];
+  for (const [name, args, desc] of cmds) {
+    const nameStr = interactive(name.padEnd(8));
+    const argsStr = args ? primary(args.padEnd(6)) : "      ";
+    lines.push(`    ${nameStr} ${argsStr} ${chalk2.dim(desc)}`);
+  }
+  lines.push("");
+  lines.push(`  ${chalk2.bold(interactive("Options"))}`);
+  lines.push("");
+  lines.push(
+    `    ${interactive("-h")}${chalk2.dim(",")} ${interactive("--help")}      ${chalk2.dim(
+      "Show this help"
+    )}`
+  );
+  lines.push(
+    `    ${interactive("-V")}${chalk2.dim(",")} ${interactive("--version")}   ${chalk2.dim(
+      "Show the version number"
+    )}`
+  );
+  lines.push("");
+  lines.push(`  ${chalk2.bold(interactive("Getting started"))}`);
+  lines.push("");
+  lines.push(
+    `    ${chalk2.dim("$")} ${primary("aai init")} ${interactive("my-agent")}    ${chalk2.dim(
+      "Create a new agent"
+    )}`
+  );
+  lines.push(`    ${chalk2.dim("$")} ${primary("cd my-agent")}`);
+  lines.push(
+    `    ${chalk2.dim("$")} ${primary("aai deploy")}          ${chalk2.dim("Deploy to production")}`
+  );
+  lines.push("");
+  return lines.join("\n");
 }
-function error2(msg) {
-  console.error(`${error(chalk3.bold("error"))}: ${msg}`);
+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 PAD;
-var init_output = __esm({
-  "cli/_output.ts"() {
+var init_help = __esm({
+  "cli/_help.ts"() {
     "use strict";
     init_colors();
-    PAD = 9;
   }
 });
 
-// cli/_new.ts
-var new_exports = {};
-__export(new_exports, {
-  _internals: () => _internals2,
-  listTemplates: () => listTemplates,
-  runNew: () => runNew
-});
-import fs4 from "node:fs/promises";
-import path4 from "node:path";
-import glob from "fast-glob";
-import fsExtra from "fs-extra";
-async function listTemplates(dir) {
-  const templates = [];
-  const entries = await fs4.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isDirectory() && !entry.name.startsWith("_")) {
-      templates.push(entry.name);
-    }
+// cli/_bundler.ts
+import fs from "node:fs/promises";
+import path 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;
+  try {
+    names = await fs.readdir(dir);
+  } catch {
+    return files;
   }
-  return templates.sort();
-}
-async function copyDirNoOverwrite(src, dest) {
-  const files = await glob("**/*", { cwd: src, dot: true, onlyFiles: true });
-  for (const file of files) {
-    const destPath = path4.join(dest, file);
-    try {
-      await fs4.access(destPath);
-    } catch {
-      await fs4.mkdir(path4.dirname(destPath), { recursive: true });
-      await fs4.copyFile(path4.join(src, file), destPath);
+  for (const name of names) {
+    const full = path.join(dir, name);
+    const stat = await fs.stat(full);
+    const entry = { name, isDirectory: () => stat.isDirectory() };
+    if (entry.isDirectory()) {
+      Object.assign(files, await readDirRecursive(full, base));
+    } else {
+      const rel = path.relative(base, full);
+      files[rel] = await fs.readFile(full, "utf-8");
     }
   }
+  return files;
 }
-async function runNew(opts) {
-  const { targetDir, template, templatesDir } = opts;
-  const available = await listTemplates(templatesDir);
-  if (!available.includes(template)) {
-    throw new Error(`unknown template '${template}' -- available: ${available.join(", ")}`);
-  }
-  _internals2.step("Create", `from template '${template}'`);
-  await fsExtra.copy(path4.join(templatesDir, template), targetDir, { overwrite: true });
-  await copyDirNoOverwrite(path4.join(templatesDir, "_shared"), targetDir);
+async function bundleAgent(agent, opts) {
+  const aaiDir = path.join(agent.dir, ".aai");
+  const buildDir = path.join(aaiDir, "build");
+  const clientDir = path.join(aaiDir, "client");
+  await fs.mkdir(aaiDir, { recursive: true });
+  const workerEntry = path.join(aaiDir, "_worker_entry.ts");
+  await fs.writeFile(
+    workerEntry,
+    [
+      `import agent from "../agent.ts";`,
+      `import { initWorker } from "@alexkroman1/aai/worker-shim";`,
+      `initWorker(agent);`
+    ].join("\n")
+  );
   try {
-    await fs4.copyFile(path4.join(targetDir, ".env.example"), path4.join(targetDir, ".env"));
-  } catch {
+    await build({
+      configFile: false,
+      root: agent.dir,
+      logLevel: "warn",
+      build: {
+        outDir: buildDir,
+        emptyOutDir: true,
+        minify: true,
+        target: "es2022",
+        rollupOptions: {
+          input: workerEntry,
+          output: {
+            format: "es",
+            entryFileNames: "worker.js",
+            inlineDynamicImports: true
+          }
+        }
+      }
+    });
+  } catch (err) {
+    throw new BundleError(err instanceof Error ? err.message : String(err));
   }
-  const readmePath = path4.join(targetDir, "README.md");
-  try {
-    await fs4.access(readmePath);
-  } catch {
-    const slug = path4.basename(path4.resolve(targetDir));
-    const readme = `# ${slug}
-
-A voice agent built with [aai](https://github.com/anthropics/aai).
-
-## Getting started
-
-\`\`\`sh
-npm install        # Install dependencies
-npm run dev        # Run locally (opens browser)
-npm run deploy     # Deploy to production
-\`\`\`
-
-## Environment variables
-
-Secrets are managed on the server, not in local files:
-
-\`\`\`sh
-aai env add MY_KEY # Set a secret (prompts for value)
-aai env ls         # List secret names
-aai env pull       # Pull names into .env for reference
-aai env rm MY_KEY  # Remove a secret
-\`\`\`
-
-Access secrets in your agent via \`ctx.env.MY_KEY\`.
-
-## Learn more
-
-See \`CLAUDE.md\` for the full agent API reference.
-`;
-    await fs4.writeFile(readmePath, readme);
+  const skipClient = opts?.skipClient || !agent.clientEntry;
+  if (!skipClient) {
+    try {
+      await build({
+        root: agent.dir,
+        base: "./",
+        logLevel: "warn",
+        plugins: [preact(), tailwindcss()],
+        build: {
+          outDir: clientDir,
+          emptyOutDir: true,
+          minify: true,
+          target: "es2022"
+        }
+      });
+    } catch (err) {
+      throw new BundleError(err instanceof Error ? err.message : String(err));
+    }
   }
-  _internals2.step("Done", targetDir);
-  return targetDir;
+  const worker = await fs.readFile(path.join(buildDir, "worker.js"), "utf-8");
+  const clientFiles = await readDirRecursive(clientDir);
+  return {
+    worker,
+    clientFiles,
+    clientDir,
+    workerBytes: Buffer.byteLength(worker)
+  };
 }
-var _internals2;
-var init_new = __esm({
-  "cli/_new.ts"() {
+var BundleError;
+var init_bundler = __esm({
+  "cli/_bundler.ts"() {
     "use strict";
-    init_output();
-    _internals2 = {
-      step
+    BundleError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "BundleError";
+      }
     };
   }
 });
 
-// dist/sdk/protocol.js
-import { z } from "zod";
-var PROTOCOL_VERSION, DEFAULT_TTS_SAMPLE_RATE, AUDIO_FORMAT, _bitsPerSample, _channels, AudioFrameSpec, KvRequestBaseSchema, HOOK_TIMEOUT_MS, SessionErrorCodeSchema, TranscriptEventSchema, ClientEventSchema, ClientMessageSchema;
-var init_protocol = __esm({
-  "dist/sdk/protocol.js"() {
-    "use strict";
-    PROTOCOL_VERSION = 1;
-    DEFAULT_TTS_SAMPLE_RATE = 24e3;
-    AUDIO_FORMAT = "pcm16";
-    _bitsPerSample = 16;
-    _channels = 1;
-    AudioFrameSpec = {
-      /** Audio codec identifier sent in the `ready` message. */
-      format: AUDIO_FORMAT,
-      /** Signed 16-bit integer samples. */
-      bitsPerSample: _bitsPerSample,
-      /** Little-endian byte order. */
-      endianness: "little",
-      /** Mono audio. */
-      channels: _channels,
-      /** Bytes per sample — derived from bitsPerSample and channels. */
-      bytesPerSample: _bitsPerSample / 8 * _channels
-    };
-    KvRequestBaseSchema = z.discriminatedUnion("op", [
-      z.object({ op: z.literal("get"), key: z.string().min(1) }),
-      z.object({
-        op: z.literal("set"),
-        key: z.string().min(1),
-        value: z.string(),
-        ttl: z.number().int().positive().optional()
-      }),
-      z.object({ op: z.literal("del"), key: z.string().min(1) }),
-      z.object({
-        op: z.literal("list"),
-        prefix: z.string(),
-        limit: z.number().int().positive().optional(),
-        reverse: z.boolean().optional()
-      })
-    ]);
-    HOOK_TIMEOUT_MS = 5e3;
-    SessionErrorCodeSchema = z.enum([
-      "stt",
-      "llm",
-      "tts",
-      "tool",
-      "protocol",
-      "connection",
-      "audio",
-      "internal"
-    ]);
-    TranscriptEventSchema = z.object({
-      type: z.literal("transcript"),
-      text: z.string(),
-      isFinal: z.boolean(),
-      turnOrder: z.number().int().nonnegative().optional()
-    });
-    ClientEventSchema = z.discriminatedUnion("type", [
-      z.object({ type: z.literal("speech_started") }),
+// 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) {
+  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();
+            }
+          }
+        )
+      ] })
+    );
+  });
+}
+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();
+            }
+          }
+        )
+      ] })
+    );
+  });
+}
+var init_prompts = __esm({
+  "cli/_prompts.tsx"() {
+    "use strict";
+    init_colors();
+  }
+});
+
+// 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 fs2 from "node:fs/promises";
+import path2 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 = path2.dirname(path2.dirname(script));
+    try {
+      accessSync(path2.join(dir, "sdk"));
+      accessSync(path2.join(dir, "cli"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+function generateSlug() {
+  return humanId({ separator: "-", capitalize: false });
+}
+async function readAuthConfig() {
+  try {
+    return JSON.parse(await fs2.readFile(CONFIG_FILE, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function writeAuthConfig(config) {
+  await fs2.mkdir(CONFIG_DIR, { recursive: true });
+  await fs2.writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
+`);
+  if (process.platform !== "win32") {
+    await fs2.chmod(CONFIG_FILE, 384);
+  }
+}
+async function getApiKey() {
+  const config = await readAuthConfig();
+  if (config.assemblyai_api_key) {
+    process.env.ASSEMBLYAI_API_KEY = config.assemblyai_api_key;
+    return config.assemblyai_api_key;
+  }
+  let key;
+  while (!key) {
+    key = await askPassword("ASSEMBLYAI_API_KEY");
+  }
+  config.assemblyai_api_key = key;
+  process.env.ASSEMBLYAI_API_KEY = key;
+  await writeAuthConfig(config);
+  return key;
+}
+async function readProjectConfig(agentDir) {
+  try {
+    return JSON.parse(await fs2.readFile(path2.join(agentDir, ".aai", "project.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function writeProjectConfig(agentDir, data) {
+  const aaiDir = path2.join(agentDir, ".aai");
+  await fs2.mkdir(aaiDir, { recursive: true });
+  await fs2.writeFile(path2.join(aaiDir, "project.json"), `${JSON.stringify(data, null, 2)}
+`);
+}
+async function fileExists(p) {
+  try {
+    await fs2.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadAgent(dir) {
+  const hasAgentTs = await fileExists(path2.join(dir, "agent.ts"));
+  if (!hasAgentTs) return null;
+  const config = await readProjectConfig(dir);
+  const slug = config?.slug ?? generateSlug();
+  const clientEntry = await fileExists(path2.join(dir, "client.tsx")) ? path2.join(dir, "client.tsx") : "";
+  return {
+    slug,
+    dir,
+    entryPoint: path2.join(dir, "agent.ts"),
+    clientEntry
+  };
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_SERVER;
+var init_discover = __esm({
+  "cli/_discover.ts"() {
+    "use strict";
+    init_prompts();
+    CONFIG_DIR = path2.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "aai");
+    CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
+    DEFAULT_SERVER = "https://aai-agent.fly.dev";
+  }
+});
+
+// cli/_deploy.ts
+async function attemptDeploy(url, slug, apiKey, env, worker, clientFiles) {
+  return await _internals.fetch(`${url}/${slug}/deploy`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      env,
+      worker,
+      clientFiles
+    })
+  });
+}
+async function runDeploy(opts) {
+  const worker = opts.bundle.worker;
+  const clientFiles = opts.bundle.clientFiles;
+  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);
+    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();
+    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 init_deploy = __esm({
+  "cli/_deploy.ts"() {
+    "use strict";
+    init_discover();
+    _internals = {
+      fetch: globalThis.fetch.bind(globalThis)
+    };
+    MAX_RETRIES = 20;
+  }
+});
+
+// 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__ */ jsx2(Text2, { dimColor: true, children: msg });
+}
+function Detail({ msg }) {
+  return /* @__PURE__ */ jsx2(Text2, { children: msg });
+}
+function Warn({ msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLORS.warning, children: "warning" }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      " ",
+      msg
+    ] })
+  ] });
+}
+function ErrorLine({ msg }) {
+  return /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: COLORS.error, children: "error" }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      ": ",
+      msg
+    ] })
+  ] });
+}
+function StepLog({ items }) {
+  return /* @__PURE__ */ jsx2(Static, { items, children: (item) => /* @__PURE__ */ jsx2(Box2, { children: item.node }, item.id) });
+}
+function 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) throw thrownError;
+}
+var init_ink = __esm({
+  "cli/_ink.tsx"() {
+    "use strict";
+    init_colors();
+  }
+});
+
+// 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);
+  }
+  return targetDir;
+}
+var init_init = __esm({
+  "cli/_init.ts"() {
+    "use strict";
+  }
+});
+
+// cli/init.tsx
+import { execFile } from "node:child_process";
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import minimist from "minimist";
+import { jsx as jsx3 } from "react/jsx-runtime";
+async function rewriteDevDeps(cwd, cliDir2) {
+  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(path4.join(monorepoRoot, "package.json"), "utf-8"));
+  const rootPkgName = rootPkg.name;
+  if (pkgJson2.dependencies[rootPkgName]) {
+    pkgJson2.dependencies[rootPkgName] = `file:${monorepoRoot}`;
+  }
+  await fs4.writeFile(pkgJsonPath2, `${JSON.stringify(pkgJson2, null, 2)}
+`);
+}
+async function installDeps(cwd, log) {
+  if (await fileExists(path4.join(cwd, "node_modules"))) return;
+  let pkgJson2;
+  try {
+    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__ */ jsx3(Step, { action: "Install", msg: deps.join(", ") }));
+  }
+  if (devDeps.length > 0) {
+    log(/* @__PURE__ */ jsx3(Step, { action: "Install", msg: `dev: ${devDeps.join(", ")}` }));
+  }
+  try {
+    await execFileAsync("npm", ["install"], { cwd });
+  } catch {
+    log(/* @__PURE__ */ jsx3(Step, { action: "Skip", msg: "npm install failed" }));
+  }
+}
+async function runInitCommand(args, version, opts) {
+  const parsed = minimist(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];
+  if (!dir) {
+    dir = await askText("What is your project named?", "my-voice-agent");
+  }
+  const cwd = path4.resolve(process.env.INIT_CWD || process.cwd(), dir);
+  if (!parsed.force && await fileExists(path4.join(cwd, "agent.ts"))) {
+    console.log(
+      `agent.ts already exists in this directory. Use ${interactive("--force")} to overwrite.`
+    );
+    process.exit(1);
+  }
+  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__ */ jsx3(Step, { action: "Create", msg: dir }));
+    await runInit2({ targetDir: cwd, template, templatesDir });
+    if (isDevMode()) {
+      await rewriteDevDeps(cwd, cliDir2);
+    }
+    await installDeps(cwd, log);
+  });
+  process.chdir(cwd);
+  delete process.env.INIT_CWD;
+  if (!opts?.quiet) {
+    const { runDeployCommand: runDeployCommand2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
+    await runDeployCommand2(["-y"], version);
+  }
+  return cwd;
+}
+var execFileAsync, initCommandDef;
+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" }
+      ]
+    };
+  }
+});
+
+// cli/deploy.tsx
+var deploy_exports = {};
+__export(deploy_exports, {
+  runDeployCommand: () => runDeployCommand
+});
+import path5 from "node:path";
+import minimist2 from "minimist";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function resolveServerUrl(parsed) {
+  return parsed.server || (isDevMode() ? "http://localhost:3100" : DEFAULT_SERVER);
+}
+async function buildAgent(cwd, log) {
+  log(/* @__PURE__ */ jsx4(Step, { action: "Build", msg: "bundling agent" }));
+  const agent = await loadAgent(cwd);
+  if (!agent) {
+    throw new Error("No agent found \u2014 run `aai init` first");
+  }
+  let bundle;
+  try {
+    bundle = await bundleAgent(agent);
+  } catch (err) {
+    if (err instanceof BundleError) {
+      throw new Error(`Bundle failed: ${err.message}`);
+    }
+    throw err;
+  }
+  return bundle;
+}
+async function deployBundle(opts) {
+  const { bundle, serverUrl, apiKey, cwd, log } = opts;
+  let { slug } = opts;
+  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__ */ jsx4(Step, { action: "Ready", msg: agentUrl }));
+  return agentUrl;
+}
+async function runDeployCommand(args, version) {
+  const parsed = minimist2(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(path5.join(cwd, "agent.ts"))) {
+    await runInitCommand(parsed.yes ? ["-y"] : [], version, { quiet: true });
+  }
+  const serverUrl = resolveServerUrl(parsed);
+  const dryRun = parsed["dry-run"] ?? false;
+  const apiKey = dryRun ? "" : await getApiKey();
+  const projectConfig = await readProjectConfig(cwd);
+  const slug = projectConfig?.slug ?? generateSlug();
+  let agentUrl = "";
+  await runWithInk(async (log) => {
+    const bundle = await buildAgent(cwd, log);
+    if (dryRun) {
+      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) {
+    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_bundler();
+    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)" }
+      ]
+    };
+  }
+});
+
+// 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 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", [
+      z.object({ op: z.literal("get"), key: z.string().min(1) }),
+      z.object({
+        op: z.literal("set"),
+        key: z.string().min(1),
+        value: z.string(),
+        ttl: z.number().int().positive().optional()
+      }),
+      z.object({ op: z.literal("del"), key: z.string().min(1) }),
+      z.object({
+        op: z.literal("list"),
+        prefix: z.string(),
+        limit: z.number().int().positive().optional(),
+        reverse: z.boolean().optional()
+      })
+    ]);
+    HOOK_TIMEOUT_MS = 5e3;
+    SessionErrorCodeSchema = z.enum([
+      "stt",
+      "llm",
+      "tts",
+      "tool",
+      "protocol",
+      "connection",
+      "audio",
+      "internal"
+    ]);
+    TranscriptEventSchema = z.object({
+      type: z.literal("transcript"),
+      text: z.string(),
+      isFinal: z.boolean(),
+      turnOrder: z.number().int().nonnegative().optional()
+    });
+    ClientEventSchema = z.discriminatedUnion("type", [
+      z.object({ type: z.literal("speech_started") }),
       z.object({ type: z.literal("speech_stopped") }),
       TranscriptEventSchema,
       z.object({
@@ -246,45 +991,39 @@ var init_protocol = __esm({
       z.object({ type: z.literal("reset") }),
       z.object({
         type: z.literal("history"),
-        messages: z.array(z.object({
-          role: z.enum(["user", "assistant"]),
-          text: z.string().max(1e5)
-        })).max(200)
+        messages: z.array(
+          z.object({
+            role: z.enum(["user", "assistant"]),
+            text: z.string().max(1e5)
+          })
+        ).max(200)
       })
     ]);
   }
 });
 
-// dist/sdk/runtime.js
+// sdk/runtime.ts
 var consoleLogger, noopMetrics, DEFAULT_S2S_CONFIG;
 var init_runtime = __esm({
-  "dist/sdk/runtime.js"() {
+  "sdk/runtime.ts"() {
     "use strict";
     init_protocol();
     consoleLogger = {
       info(msg, ctx) {
-        if (ctx)
-          console.log(msg, ctx);
-        else
-          console.log(msg);
+        if (ctx) console.log(msg, ctx);
+        else console.log(msg);
       },
       warn(msg, ctx) {
-        if (ctx)
-          console.warn(msg, ctx);
-        else
-          console.warn(msg);
+        if (ctx) console.warn(msg, ctx);
+        else console.warn(msg);
       },
       error(msg, ctx) {
-        if (ctx)
-          console.error(msg, ctx);
-        else
-          console.error(msg);
+        if (ctx) console.error(msg, ctx);
+        else console.error(msg);
       },
       debug(msg, ctx) {
-        if (ctx)
-          console.debug(msg, ctx);
-        else
-          console.debug(msg);
+        if (ctx) console.debug(msg, ctx);
+        else console.debug(msg);
       }
     };
     noopMetrics = {
@@ -302,7 +1041,7 @@ var init_runtime = __esm({
   }
 });
 
-// dist/sdk/_internal_types.js
+// sdk/_internal_types.ts
 import { z as z2 } from "zod";
 function agentToolsToSchemas(tools) {
   return Object.entries(tools).map(([name, def]) => ({
@@ -313,13 +1052,13 @@ function agentToolsToSchemas(tools) {
 }
 var EMPTY_PARAMS;
 var init_internal_types = __esm({
-  "dist/sdk/_internal_types.js"() {
+  "sdk/_internal_types.ts"() {
     "use strict";
     EMPTY_PARAMS = z2.object({});
   }
 });
 
-// dist/sdk/builtin_tools.js
+// sdk/builtin_tools.ts
 import { convert } from "html-to-text";
 import { z as z3 } from "zod";
 function htmlToText(html) {
@@ -344,12 +1083,10 @@ function createWebSearch() {
         headers: { "X-Subscription-Token": apiKey },
         signal: ctx.abortSignal ?? AbortSignal.timeout(15e3)
       });
-      if (!resp.ok)
-        return [];
+      if (!resp.ok) return [];
       const raw = await resp.json();
       const data = BraveSearchResponseSchema.safeParse(raw);
-      if (!data.success)
-        return [];
+      if (!data.success) return [];
       return (data.data.web?.results ?? []).slice(0, maxResults).map((r) => ({
         title: r.title,
         url: r.url,
@@ -433,7 +1170,9 @@ function createRunCode() {
         const fn = new AsyncFunction("console", code);
         await Promise.race([
           fn(fakeConsole),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("Code execution timed out")), RUN_CODE_TIMEOUT))
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Code execution timed out")), RUN_CODE_TIMEOUT)
+          )
         ]);
         const result = output.join("\n").trim();
         return result || "Code ran successfully (no output)";
@@ -481,8 +1220,7 @@ function getBuiltinToolDefs(names, opts) {
 function getBuiltinToolSchemas(names) {
   return names.flatMap((name) => {
     const creator = TOOL_CREATORS[name];
-    if (!creator)
-      return [];
+    if (!creator) return [];
     const def = creator();
     return [
       {
@@ -495,7 +1233,7 @@ function getBuiltinToolSchemas(names) {
 }
 var webSearchParams, BRAVE_SEARCH_URL, BraveSearchResponseSchema, MAX_PAGE_CHARS, MAX_HTML_BYTES, visitWebpageParams, fetchJsonParams, runCodeParams, vectorSearchParams, TOOL_CREATORS;
 var init_builtin_tools = __esm({
-  "dist/sdk/builtin_tools.js"() {
+  "sdk/builtin_tools.ts"() {
     "use strict";
     init_internal_types();
     webSearchParams = z3.object({
@@ -505,11 +1243,13 @@ var init_builtin_tools = __esm({
     BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search";
     BraveSearchResponseSchema = z3.object({
       web: z3.object({
-        results: z3.array(z3.object({
-          title: z3.string(),
-          url: z3.string(),
-          description: z3.string()
-        }))
+        results: z3.array(
+          z3.object({
+            title: z3.string(),
+            url: z3.string(),
+            description: z3.string()
+          })
+        )
       }).optional()
     });
     MAX_PAGE_CHARS = 1e4;
@@ -525,7 +1265,9 @@ var init_builtin_tools = __esm({
       code: z3.string().describe("JavaScript code to execute. Use console.log() for output.")
     });
     vectorSearchParams = z3.object({
-      query: z3.string().describe('Short keyword query to search the knowledge base. Use specific topic terms, not full sentences. Do NOT include the company or product name since all documents are from the same source. For example, if the user asks "how much does Acme cost", search for "pricing plans rates".'),
+      query: z3.string().describe(
+        'Short keyword query to search the knowledge base. Use specific topic terms, not full sentences. Do NOT include the company or product name since all documents are from the same source. For example, if the user asks "how much does Acme cost", search for "pricing plans rates".'
+      ),
       topK: z3.number().describe("Maximum results to return (default: 5)").optional()
     });
     TOOL_CREATORS = {
@@ -539,11 +1281,10 @@ var init_builtin_tools = __esm({
   }
 });
 
-// dist/sdk/kv.js
+// sdk/kv.ts
 function sortAndPaginate(entries, options) {
   entries.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-  if (options?.reverse)
-    entries.reverse();
+  if (options?.reverse) entries.reverse();
   if (options?.limit && options.limit > 0) {
     entries.length = Math.min(entries.length, options.limit);
   }
@@ -558,8 +1299,7 @@ function createMemoryKv() {
     get(key) {
       const entry = store.get(key);
       if (!entry || isExpired(entry)) {
-        if (entry)
-          store.delete(key);
+        if (entry) store.delete(key);
         return Promise.resolve(null);
       }
       return Promise.resolve(JSON.parse(entry.raw));
@@ -586,8 +1326,7 @@ function createMemoryKv() {
       const entries = [];
       let i = 0;
       for (const [key, entry] of store) {
-        if (++i % 500 === 0)
-          await new Promise((r) => setTimeout(r, 0));
+        if (++i % 500 === 0) await new Promise((r) => setTimeout(r, 0));
         if (entry.expiresAt && entry.expiresAt <= now) {
           store.delete(key);
           continue;
@@ -602,13 +1341,13 @@ function createMemoryKv() {
 }
 var MAX_VALUE_SIZE;
 var init_kv = __esm({
-  "dist/sdk/kv.js"() {
+  "sdk/kv.ts"() {
     "use strict";
     MAX_VALUE_SIZE = 65536;
   }
 });
 
-// dist/sdk/s2s.js
+// sdk/s2s.ts
 import { z as z4 } from "zod";
 function uint8ToBase64(bytes) {
   return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
@@ -620,9 +1359,11 @@ function base64ToUint8(base64) {
 function dispatchS2sMessage(target, msg) {
   switch (msg.type) {
     case "session.ready":
-      target.dispatchEvent(new CustomEvent("ready", {
-        detail: { session_id: msg.session_id }
-      }));
+      target.dispatchEvent(
+        new CustomEvent("ready", {
+          detail: { session_id: msg.session_id }
+        })
+      );
       break;
     case "session.updated":
       target.dispatchEvent(new CustomEvent("session_updated", { detail: msg }));
@@ -634,54 +1375,80 @@ function dispatchS2sMessage(target, msg) {
       target.dispatchEvent(new CustomEvent("speech_stopped"));
       break;
     case "transcript.user.delta":
-      target.dispatchEvent(new CustomEvent("user_transcript_delta", {
-        detail: { text: msg.text }
-      }));
+      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
-        }
-      }));
+      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 }
-      }));
+      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 }
-      }));
+      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
-        }
-      }));
+      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 }
-      }));
+      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 }
-      }));
+      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 }
-      }));
+      target.dispatchEvent(
+        new CustomEvent("error", {
+          detail: { code: "connection", message: msg.message }
+        })
+      );
       break;
   }
 }
@@ -695,20 +1462,24 @@ function connectS2s(opts) {
     const target = new EventTarget();
     let opened = false;
     function send(msg) {
-      if (ws.readyState !== WS_OPEN)
-        return;
+      if (ws.readyState !== WS_OPEN) return;
       const json = JSON.stringify(msg);
       if (msg.type !== "input.audio") {
-        log.debug(`S2S >> ${msg.type}`);
+        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.readyState !== WS_OPEN) return;
         if (ws.sendBinary) {
-          const ab = audio.buffer.slice(audio.byteOffset, audio.byteOffset + audio.byteLength);
+          const ab = audio.buffer.slice(
+            audio.byteOffset,
+            audio.byteOffset + audio.byteLength
+          );
           ws.sendBinary(ab);
         } else {
           ws.send(`{"type":"input.audio","audio":"${uint8ToBase64(audio)}"}`);
@@ -752,7 +1523,9 @@ function connectS2s(opts) {
       }
       const parsed = S2sServerMessageSchema.safeParse(raw);
       if (!parsed.success) {
-        log.debug("S2S << unrecognised message type");
+        log.debug(
+          `S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 100)}`
+        );
         return;
       }
       const msg = parsed.data;
@@ -772,16 +1545,18 @@ function connectS2s(opts) {
       if (!opened) {
         reject(errObj);
       } else {
-        target.dispatchEvent(new CustomEvent("error", {
-          detail: { code: "ws_error", message: errObj.message }
-        }));
+        target.dispatchEvent(
+          new CustomEvent("error", {
+            detail: { code: "ws_error", message: errObj.message }
+          })
+        );
       }
     });
   });
 }
 var WS_OPEN, S2sServerMessageSchema;
 var init_s2s = __esm({
-  "dist/sdk/s2s.js"() {
+  "sdk/s2s.ts"() {
     "use strict";
     init_runtime();
     WS_OPEN = 1;
@@ -798,7 +1573,10 @@ var init_s2s = __esm({
       }),
       z4.object({ type: z4.literal("reply.started"), reply_id: z4.string() }),
       // reply.audio is handled on the fast path before Zod — see message handler.
+      z4.object({ type: z4.literal("transcript.agent.delta"), delta: z4.string() }).passthrough(),
       z4.object({ type: z4.literal("transcript.agent"), text: z4.string() }),
+      z4.object({ type: z4.literal("reply.content_part.started") }).passthrough(),
+      z4.object({ type: z4.literal("reply.content_part.done") }).passthrough(),
       z4.object({
         type: z4.literal("tool.call"),
         call_id: z4.string(),
@@ -823,10 +1601,10 @@ var init_s2s = __esm({
   }
 });
 
-// dist/sdk/types.js
+// sdk/types.ts
 var DEFAULT_INSTRUCTIONS;
 var init_types = __esm({
-  "dist/sdk/types.js"() {
+  "sdk/types.ts"() {
     "use strict";
     DEFAULT_INSTRUCTIONS = `You are AAI, a helpful AI assistant.
 
@@ -842,7 +1620,7 @@ Voice-First Rules:
   }
 });
 
-// dist/sdk/system_prompt.js
+// sdk/system_prompt.ts
 function buildSystemPrompt(config, opts) {
   const { hasTools } = opts;
   const agentInstructions = config.instructions && config.instructions !== DEFAULT_INSTRUCTIONS ? `
@@ -862,16 +1640,28 @@ Today's date is ${today}.` + agentInstructions + toolPreamble + (opts?.voice ? V
 }
 var VOICE_RULES;
 var init_system_prompt = __esm({
-  "dist/sdk/system_prompt.js"() {
+  "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';
   }
 });
 
-// dist/sdk/session.js
+// sdk/session.ts
 function createS2sSession(opts) {
-  const { id, agent, client, toolSchemas, apiKey, s2sConfig, executeTool, createWebSocket, hookInvoker, logger: log = consoleLogger, metrics = noopMetrics } = opts;
+  const {
+    id,
+    agent,
+    client,
+    toolSchemas,
+    apiKey,
+    s2sConfig,
+    executeTool,
+    createWebSocket,
+    hookInvoker,
+    logger: log = consoleLogger,
+    metrics = noopMetrics
+  } = opts;
   const agentLabel = { agent };
   const agentConfig = opts.skipGreeting ? { ...opts.agentConfig, greeting: "" } : opts.agentConfig;
   const hasTools = toolSchemas.length > 0 || (agentConfig.builtinTools?.length ?? 0) > 0;
@@ -896,8 +1686,7 @@ function createS2sSession(opts) {
   let pendingReconnect = false;
   let pendingTools = [];
   async function resolveTurnConfig() {
-    if (!hookInvoker)
-      return null;
+    if (!hookInvoker) return null;
     try {
       return await hookInvoker.resolveTurnConfig(id, HOOK_TIMEOUT_MS);
     } catch {
@@ -905,8 +1694,7 @@ function createS2sSession(opts) {
     }
   }
   function invokeHook(hook, arg) {
-    if (!hookInvoker)
-      return;
+    if (!hookInvoker) return;
     const run = async () => {
       switch (hook) {
         case "onConnect":
@@ -992,7 +1780,7 @@ function createS2sSession(opts) {
     }
     connecting = true;
     try {
-      const handle = await _internals3.connectS2s({
+      const handle = await _internals2.connectS2s({
         apiKey,
         config: s2sConfig,
         createWebSocket,
@@ -1101,1507 +1889,730 @@ function createS2sSession(opts) {
       const msg = err instanceof Error ? err.message : String(err);
       log.error("S2S connect failed", { error: msg });
       client.event({ type: "error", code: "internal", message: msg });
-    } finally {
-      connecting = false;
-      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 });
-        });
-      }
-    }
-  }
-  return {
-    async start() {
-      metrics.sessionsTotal.inc(agentLabel);
-      metrics.sessionsActive.inc(agentLabel);
-      invokeHook("onConnect");
-      await connectAndSetup();
-    },
-    async stop() {
-      if (sessionAbort.signal.aborted)
-        return;
-      sessionAbort.abort();
-      metrics.sessionsActive.dec(agentLabel);
-      if (turnPromise)
-        await turnPromise;
-      s2s?.close();
-      invokeHook("onDisconnect");
-    },
-    onAudio(data) {
-      s2s?.sendAudio(data);
-    },
-    onAudioReady() {
-      if (audioReady)
-        return;
-      audioReady = true;
-    },
-    onCancel() {
-      client.event({ type: "cancelled" });
-    },
-    onReset() {
-      conversationMessages = [];
-      toolCallCount = 0;
-      turnPromise = null;
-      pendingTools = [];
-      s2sSessionId = null;
-      s2s?.close();
-      client.event({ type: "reset" });
-    },
-    onHistory(incoming) {
-      for (const msg of incoming) {
-        conversationMessages.push({ role: msg.role, content: msg.text });
-      }
-    },
-    waitForTurn() {
-      return turnPromise ?? Promise.resolve();
-    }
-  };
-}
-var _internals3;
-var init_session = __esm({
-  "dist/sdk/session.js"() {
-    "use strict";
-    init_protocol();
-    init_runtime();
-    init_s2s();
-    init_system_prompt();
-    _internals3 = {
-      connectS2s
-    };
-  }
-});
-
-// dist/sdk/vector.js
-function createMemoryVectorStore() {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    upsert(id, data, metadata) {
-      store.set(id, { data, metadata });
-      return Promise.resolve();
-    },
-    async query(text, options) {
-      const topK = options?.topK ?? 10;
-      const query = text.toLowerCase();
-      const words = query.split(/\s+/).filter(Boolean);
-      const results = [];
-      let i = 0;
-      for (const [id, entry] of store) {
-        if (++i % 500 === 0)
-          await new Promise((r) => setTimeout(r, 0));
-        const data = entry.data.toLowerCase();
-        const matches = words.filter((w) => data.includes(w)).length;
-        if (matches > 0) {
-          results.push({
-            id,
-            score: matches / Math.max(words.length, 1),
-            data: entry.data,
-            metadata: entry.metadata
-          });
-        }
-      }
-      results.sort((a, b) => b.score - a.score);
-      return results.slice(0, topK);
-    },
-    remove(ids) {
-      const idArray = Array.isArray(ids) ? ids : [ids];
-      for (const id of idArray) {
-        store.delete(id);
-      }
-      return Promise.resolve();
-    }
-  };
-}
-var init_vector = __esm({
-  "dist/sdk/vector.js"() {
-    "use strict";
-  }
-});
-
-// dist/sdk/worker_entry.js
-function buildToolContext(opts) {
-  const { env, sessionId, state, kv, vector, messages } = opts;
-  return {
-    sessionId: sessionId ?? "",
-    env: { ...env },
-    abortSignal: AbortSignal.timeout(TOOL_HANDLER_TIMEOUT),
-    state: state ?? {},
-    get kv() {
-      if (!kv)
-        throw new Error("KV not available");
-      return kv;
-    },
-    get vector() {
-      if (!vector)
-        throw new Error("Vector store not available");
-      return vector;
-    },
-    messages: messages ?? []
-  };
-}
-async function executeToolCall(name, args, options) {
-  const { tool } = options;
-  const schema = tool.parameters ?? EMPTY_PARAMS;
-  const parsed = schema.safeParse(args);
-  if (!parsed.success) {
-    const issues = (parsed.error?.issues ?? []).map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join(", ");
-    return `Error: Invalid arguments for tool "${name}": ${issues}`;
-  }
-  try {
-    const ctx = buildToolContext(options);
-    await yieldTick();
-    const result = await Promise.resolve(tool.execute(parsed.data, ctx));
-    await yieldTick();
-    if (result == null)
-      return "null";
-    return typeof result === "string" ? result : JSON.stringify(result);
-  } catch (err) {
-    if (err instanceof DOMException && err.name === "TimeoutError") {
-      console.warn(`[tool-executor] Tool execution timed out: ${name}`);
-      return `Error: Tool "${name}" timed out after ${TOOL_HANDLER_TIMEOUT}ms`;
-    }
-    console.warn(`[tool-executor] Tool execution failed: ${name}`, err);
-    return `Error: ${err instanceof Error ? err.message : String(err)}`;
-  }
-}
-var yieldTick, TOOL_HANDLER_TIMEOUT;
-var init_worker_entry = __esm({
-  "dist/sdk/worker_entry.js"() {
-    "use strict";
-    init_internal_types();
-    yieldTick = () => new Promise((r) => setTimeout(r, 0));
-    TOOL_HANDLER_TIMEOUT = 3e4;
-  }
-});
-
-// dist/sdk/direct_executor.js
-function buildAgentConfig(agent) {
-  const config = {
-    name: agent.name,
-    instructions: agent.instructions,
-    greeting: agent.greeting,
-    voice: agent.voice
-  };
-  if (agent.sttPrompt !== void 0)
-    config.sttPrompt = agent.sttPrompt;
-  if (typeof agent.maxSteps !== "function")
-    config.maxSteps = agent.maxSteps;
-  if (agent.toolChoice !== void 0)
-    config.toolChoice = agent.toolChoice;
-  if (agent.builtinTools)
-    config.builtinTools = [...agent.builtinTools];
-  if (agent.activeTools)
-    config.activeTools = [...agent.activeTools];
-  return config;
-}
-function createDirectExecutor(opts) {
-  const { agent, env, kv = createMemoryKv(), vector = createMemoryVectorStore(), vectorSearch, createWebSocket, logger = consoleLogger, metrics = noopMetrics, s2sConfig = DEFAULT_S2S_CONFIG } = opts;
-  const agentConfig = buildAgentConfig(agent);
-  const builtinDefs = getBuiltinToolDefs(agent.builtinTools ?? [], vectorSearch ? { vectorSearch } : void 0);
-  const allTools = {
-    ...builtinDefs,
-    ...agent.tools
-  };
-  const customSchemas = agentToolsToSchemas(agent.tools ?? {});
-  const builtinSchemas = getBuiltinToolSchemas(agent.builtinTools ?? []);
-  const toolSchemas = [...customSchemas, ...builtinSchemas];
-  const sessionState = /* @__PURE__ */ new Map();
-  const frozenEnv = Object.freeze({ ...env });
-  function getState(sessionId) {
-    if (!sessionState.has(sessionId) && agent.state) {
-      sessionState.set(sessionId, agent.state());
-    }
-    return sessionState.get(sessionId) ?? {};
-  }
-  function makeHookContext(sessionId) {
-    return {
-      sessionId,
-      env: frozenEnv,
-      state: getState(sessionId),
-      get kv() {
-        return kv;
-      },
-      get vector() {
-        return vector;
-      }
-    };
-  }
-  const executeTool = async (name, args, sessionId, messages) => {
-    const tool = allTools[name];
-    if (!tool)
-      return JSON.stringify({ error: `Unknown tool: ${name}` });
-    return executeToolCall(name, args, {
-      tool,
-      env: frozenEnv,
-      sessionId,
-      state: getState(sessionId ?? ""),
-      kv,
-      vector,
-      messages
-    });
-  };
-  const hookInvoker = {
-    async onConnect(sessionId) {
-      await agent.onConnect?.(makeHookContext(sessionId));
-    },
-    async onDisconnect(sessionId) {
-      await agent.onDisconnect?.(makeHookContext(sessionId));
-      sessionState.delete(sessionId);
-    },
-    async onTurn(sessionId, text) {
-      await agent.onTurn?.(text, makeHookContext(sessionId));
-    },
-    async onError(sessionId, error3) {
-      await agent.onError?.(new Error(error3.message), makeHookContext(sessionId));
-    },
-    async onStep(sessionId, step2) {
-      await agent.onStep?.(step2, makeHookContext(sessionId));
-    },
-    async resolveTurnConfig(sessionId) {
-      const ctx = makeHookContext(sessionId);
-      let maxSteps;
-      let activeTools;
-      if (typeof agent.maxSteps === "function") {
-        maxSteps = await agent.maxSteps(ctx) ?? void 0;
-      }
-      if (agent.onBeforeStep) {
-        const result = await agent.onBeforeStep(0, ctx);
-        activeTools = result?.activeTools;
+    } finally {
+      connecting = false;
+      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 });
+        });
       }
-      if (maxSteps === void 0 && activeTools === void 0)
-        return null;
-      const config = {};
-      if (maxSteps !== void 0)
-        config.maxSteps = maxSteps;
-      if (activeTools !== void 0)
-        config.activeTools = activeTools;
-      return config;
-    }
-  };
-  function createSession(sessionOpts) {
-    if (!createWebSocket) {
-      throw new Error("createWebSocket not provided \u2014 pass it in DirectExecutorOptions");
-    }
-    const apiKey = frozenEnv.ASSEMBLYAI_API_KEY ?? "";
-    return createS2sSession({
-      id: sessionOpts.id,
-      agent: sessionOpts.agent,
-      client: sessionOpts.client,
-      agentConfig,
-      toolSchemas,
-      apiKey,
-      s2sConfig,
-      executeTool,
-      createWebSocket,
-      hookInvoker,
-      skipGreeting: sessionOpts.skipGreeting ?? false,
-      logger,
-      metrics
-    });
-  }
-  return { executeTool, hookInvoker, toolSchemas, createSession };
-}
-var init_direct_executor = __esm({
-  "dist/sdk/direct_executor.js"() {
-    "use strict";
-    init_internal_types();
-    init_builtin_tools();
-    init_kv();
-    init_runtime();
-    init_session();
-    init_vector();
-    init_worker_entry();
-  }
-});
-
-// dist/sdk/ws_handler.js
-function isValidAudioChunk(data) {
-  return data.byteLength > 0 && data.byteLength <= MAX_AUDIO_CHUNK_BYTES && data.byteLength % 2 === 0;
-}
-function createClientSink(ws) {
-  function safeSend(data) {
-    try {
-      if (ws.readyState === 1)
-        ws.send(data);
-    } catch {
     }
   }
   return {
-    get open() {
-      return ws.readyState === 1;
+    async start() {
+      metrics.sessionsTotal.inc(agentLabel);
+      metrics.sessionsActive.inc(agentLabel);
+      invokeHook("onConnect");
+      await connectAndSetup();
     },
-    event(e) {
-      safeSend(JSON.stringify(e));
+    async stop() {
+      if (sessionAbort.signal.aborted) return;
+      sessionAbort.abort();
+      metrics.sessionsActive.dec(agentLabel);
+      if (turnPromise) await turnPromise;
+      s2s?.close();
+      invokeHook("onDisconnect");
     },
-    playAudioChunk(chunk) {
-      safeSend(chunk);
+    onAudio(data) {
+      s2s?.sendAudio(data);
     },
-    playAudioDone() {
-      safeSend(JSON.stringify({ type: "audio_done" }));
+    onAudioReady() {
+      if (audioReady) return;
+      audioReady = true;
+    },
+    onCancel() {
+      client.event({ type: "cancelled" });
+    },
+    onReset() {
+      conversationMessages = [];
+      toolCallCount = 0;
+      turnPromise = null;
+      pendingTools = [];
+      s2sSessionId = null;
+      s2s?.close();
+      client.event({ type: "reset" });
+    },
+    onHistory(incoming) {
+      for (const msg of incoming) {
+        conversationMessages.push({ role: msg.role, content: msg.text });
+      }
+    },
+    waitForTurn() {
+      return turnPromise ?? Promise.resolve();
     }
   };
 }
-function isBinaryData(data) {
-  return globalThis.Buffer?.isBuffer(data) || data instanceof ArrayBuffer || data instanceof Uint8Array;
-}
-function toUint8Array(data) {
-  if (data instanceof Uint8Array)
-    return data;
-  if (data instanceof ArrayBuffer)
-    return new Uint8Array(data);
-  const buf = data;
-  return new Uint8Array(buf.buffer ?? data, buf.byteOffset ?? 0, buf.byteLength);
-}
-function handleBinaryAudio(data, session, log, ctx, sid) {
-  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);
-  return true;
-}
-function handleTextMessage(data, session, log, ctx, sid) {
-  if (typeof data !== "string")
-    return;
-  let json;
-  try {
-    json = JSON.parse(data);
-  } catch {
-    log.warn("Invalid JSON from client", { ...ctx, sid });
-    return;
-  }
-  const parsed = ClientMessageSchema.safeParse(json);
-  if (!parsed.success) {
-    log.warn("Invalid client message", { ...ctx, sid, error: parsed.error.message });
-    return;
-  }
-  const msg = parsed.data;
-  switch (msg.type) {
-    case "audio_ready":
-      session.onAudioReady();
-      break;
-    case "cancel":
-      session.onCancel();
-      break;
-    case "reset":
-      session.onReset();
-      break;
-    case "history":
-      session.onHistory(msg.messages);
-      break;
-  }
-}
-function wireSessionSocket(ws, opts) {
-  const { sessions, logger: log = consoleLogger } = opts;
-  const sessionId = crypto.randomUUID();
-  const sid = sessionId.slice(0, 8);
-  const ctx = opts.logContext ?? {};
-  let session = null;
-  function onOpen() {
-    opts.onOpen?.();
-    log.info("Session connected", { ...ctx, sid });
-    const client = createClientSink(ws);
-    session = opts.createSession(sessionId, client);
-    sessions.set(sessionId, session);
-    ws.send(JSON.stringify({ type: "config", ...opts.readyConfig }));
-    void session.start();
-    log.info("Session ready", { ...ctx, sid });
-  }
-  if (ws.readyState === 1) {
-    onOpen();
-  } else {
-    ws.addEventListener("open", onOpen);
-  }
-  ws.addEventListener("message", (event) => {
-    if (!session)
-      return;
-    const { data } = event;
-    if (handleBinaryAudio(data, session, log, ctx, sid))
-      return;
-    handleTextMessage(data, session, log, ctx, sid);
-  });
-  ws.addEventListener("close", () => {
-    log.info("Session disconnected", { ...ctx, sid });
-    if (session) {
-      void session.stop().finally(() => {
-        sessions.delete(sessionId);
-      });
-    }
-    opts.onClose?.();
-  });
-  ws.addEventListener("error", (event) => {
-    const msg = event instanceof ErrorEvent ? event.message : "WebSocket error";
-    log.error("WebSocket error", { ...ctx, sid, error: msg });
-  });
-}
-var MAX_AUDIO_CHUNK_BYTES;
-var init_ws_handler = __esm({
-  "dist/sdk/ws_handler.js"() {
+var _internals2;
+var init_session = __esm({
+  "sdk/session.ts"() {
     "use strict";
     init_protocol();
     init_runtime();
-    MAX_AUDIO_CHUNK_BYTES = 1048576;
+    init_s2s();
+    init_system_prompt();
+    _internals2 = {
+      connectS2s
+    };
   }
 });
 
-// dist/sdk/winterc_server.js
-function createWintercServer(options) {
-  const { agent, env, kv = createMemoryKv(), vector = createMemoryVectorStore(), vectorSearch, clientHtml, logger = consoleLogger, metrics = noopMetrics, s2sConfig = DEFAULT_S2S_CONFIG } = options;
-  const executor = createDirectExecutor({
-    agent,
-    env,
-    kv,
-    vector,
-    ...vectorSearch ? { vectorSearch } : {},
-    createWebSocket: options.createWebSocket,
-    logger,
-    metrics,
-    s2sConfig
-  });
-  const sessions = /* @__PURE__ */ new Map();
-  const readyConfig = {
-    protocolVersion: PROTOCOL_VERSION,
-    audioFormat: AUDIO_FORMAT,
-    sampleRate: s2sConfig.inputSampleRate,
-    ttsSampleRate: s2sConfig.outputSampleRate
-  };
+// sdk/vector.ts
+function createMemoryVectorStore() {
+  const store = /* @__PURE__ */ new Map();
   return {
-    async fetch(request) {
-      const url = new URL(request.url);
-      if (url.pathname === "/health") {
-        return new Response(JSON.stringify({ status: "ok", name: agent.name }), {
-          headers: { "Content-Type": "application/json" }
-        });
-      }
-      if (url.pathname === "/" && clientHtml) {
-        return new Response(clientHtml, {
-          headers: { "Content-Type": "text/html" }
-        });
-      }
-      if (url.pathname === "/") {
-        return new Response(`<!DOCTYPE html><html><body><h1>${agent.name}</h1><p>Agent server running.</p></body></html>`, { headers: { "Content-Type": "text/html" } });
-      }
-      return new Response("Not Found", { status: 404 });
+    upsert(id, data, metadata) {
+      store.set(id, { data, metadata });
+      return Promise.resolve();
     },
-    handleWebSocket(ws, wsOpts) {
-      wireSessionSocket(ws, {
-        sessions,
-        createSession: (sid, client) => executor.createSession({
-          id: sid,
-          agent: agent.name,
-          client,
-          skipGreeting: wsOpts?.skipGreeting ?? false
-        }),
-        readyConfig,
-        logger
-      });
+    async query(text, options) {
+      const topK = options?.topK ?? 10;
+      const query = text.toLowerCase();
+      const words = query.split(/\s+/).filter(Boolean);
+      const results = [];
+      let i = 0;
+      for (const [id, entry] of store) {
+        if (++i % 500 === 0) await new Promise((r) => setTimeout(r, 0));
+        const data = entry.data.toLowerCase();
+        const matches = words.filter((w) => data.includes(w)).length;
+        if (matches > 0) {
+          results.push({
+            id,
+            score: matches / Math.max(words.length, 1),
+            data: entry.data,
+            metadata: entry.metadata
+          });
+        }
+      }
+      results.sort((a, b) => b.score - a.score);
+      return results.slice(0, topK);
     },
-    async close() {
-      for (const session of sessions.values()) {
-        await session.stop();
+    remove(ids) {
+      const idArray = Array.isArray(ids) ? ids : [ids];
+      for (const id of idArray) {
+        store.delete(id);
       }
-      sessions.clear();
+      return Promise.resolve();
     }
   };
 }
-var init_winterc_server = __esm({
-  "dist/sdk/winterc_server.js"() {
+var init_vector = __esm({
+  "sdk/vector.ts"() {
     "use strict";
-    init_direct_executor();
-    init_kv();
-    init_protocol();
-    init_runtime();
-    init_vector();
-    init_ws_handler();
   }
 });
 
-// dist/sdk/server.js
-var server_exports = {};
-__export(server_exports, {
-  createServer: () => createServer
-});
-async function loadWsFactory() {
+// sdk/worker_entry.ts
+function buildToolContext(opts) {
+  const { env, sessionId, state, kv, vector, messages } = opts;
+  return {
+    sessionId: sessionId ?? "",
+    env: { ...env },
+    abortSignal: AbortSignal.timeout(TOOL_HANDLER_TIMEOUT),
+    state: state ?? {},
+    get kv() {
+      if (!kv) throw new Error("KV not available");
+      return kv;
+    },
+    get vector() {
+      if (!vector) throw new Error("Vector store not available");
+      return vector;
+    },
+    messages: messages ?? []
+  };
+}
+async function executeToolCall(name, args, options) {
+  const { tool } = options;
+  const schema = tool.parameters ?? EMPTY_PARAMS;
+  const parsed = schema.safeParse(args);
+  if (!parsed.success) {
+    const issues = (parsed.error?.issues ?? []).map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join(", ");
+    return `Error: Invalid arguments for tool "${name}": ${issues}`;
+  }
   try {
-    const mod = await import("ws");
-    const WS = mod.default ?? mod;
-    return (url, opts) => new WS(url, { headers: opts.headers });
-  } catch {
-    throw new Error("WebSocket factory not provided and `ws` package not found. Install `ws` (`npm install ws`) or pass `createWebSocket` option.");
+    const ctx = buildToolContext(options);
+    await yieldTick();
+    const result = await Promise.resolve(tool.execute(parsed.data, ctx));
+    await yieldTick();
+    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)}`;
   }
 }
-function resolveEnv(env) {
-  const resolved = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (value !== void 0)
-      resolved[key] = value;
+var yieldTick, TOOL_HANDLER_TIMEOUT;
+var init_worker_entry = __esm({
+  "sdk/worker_entry.ts"() {
+    "use strict";
+    init_internal_types();
+    yieldTick = () => new Promise((r) => setTimeout(r, 0));
+    TOOL_HANDLER_TIMEOUT = 3e4;
   }
-  return resolved;
+});
+
+// sdk/direct_executor.ts
+function buildAgentConfig(agent) {
+  const config = {
+    name: agent.name,
+    instructions: agent.instructions,
+    greeting: agent.greeting,
+    voice: agent.voice
+  };
+  if (agent.sttPrompt !== void 0) config.sttPrompt = agent.sttPrompt;
+  if (typeof agent.maxSteps !== "function") config.maxSteps = agent.maxSteps;
+  if (agent.toolChoice !== void 0) config.toolChoice = agent.toolChoice;
+  if (agent.builtinTools) config.builtinTools = [...agent.builtinTools];
+  if (agent.activeTools) config.activeTools = [...agent.activeTools];
+  return config;
 }
-function createServer(options) {
-  const { agent, kv, clientHtml, logger = consoleLogger, s2sConfig = DEFAULT_S2S_CONFIG } = options;
-  const env = resolveEnv(options.env ?? (typeof process !== "undefined" ? process.env : {}));
-  let wsFactory = options.createWebSocket ?? null;
-  async function getWsFactory() {
-    if (!wsFactory) {
-      wsFactory = await loadWsFactory();
+function createDirectExecutor(opts) {
+  const {
+    agent,
+    env,
+    kv = createMemoryKv(),
+    vector = createMemoryVectorStore(),
+    vectorSearch,
+    createWebSocket,
+    logger = consoleLogger,
+    metrics = noopMetrics,
+    s2sConfig = DEFAULT_S2S_CONFIG
+  } = opts;
+  const agentConfig = buildAgentConfig(agent);
+  const builtinDefs = getBuiltinToolDefs(
+    agent.builtinTools ?? [],
+    vectorSearch ? { vectorSearch } : void 0
+  );
+  const allTools = {
+    ...builtinDefs,
+    ...agent.tools
+  };
+  const customSchemas = agentToolsToSchemas(agent.tools ?? {});
+  const builtinSchemas = getBuiltinToolSchemas(agent.builtinTools ?? []);
+  const toolSchemas = [...customSchemas, ...builtinSchemas];
+  const sessionState = /* @__PURE__ */ new Map();
+  const frozenEnv = Object.freeze({ ...env });
+  function getState(sessionId) {
+    if (!sessionState.has(sessionId) && agent.state) {
+      sessionState.set(sessionId, agent.state());
     }
-    return wsFactory;
+    return sessionState.get(sessionId) ?? {};
   }
-  let winterc = null;
-  function getWinterc() {
-    if (!winterc) {
-      winterc = createWintercServer({
-        agent,
-        env,
-        ...kv ? { kv } : {},
-        createWebSocket: wsFactory ?? (() => {
-          throw new Error("WebSocket factory not loaded");
-        }),
-        ...clientHtml !== void 0 ? { clientHtml } : {},
-        logger,
-        s2sConfig
-      });
-    }
-    return winterc;
+  function makeHookContext(sessionId) {
+    return {
+      sessionId,
+      env: frozenEnv,
+      state: getState(sessionId),
+      get kv() {
+        return kv;
+      },
+      get vector() {
+        return vector;
+      }
+    };
   }
-  let serverHandle = null;
-  return {
-    fetch(request) {
-      return getWinterc().fetch(request);
+  const executeTool = async (name, args, sessionId, messages) => {
+    const tool = allTools[name];
+    if (!tool) return JSON.stringify({ error: `Unknown tool: ${name}` });
+    return executeToolCall(name, args, {
+      tool,
+      env: frozenEnv,
+      sessionId,
+      state: getState(sessionId ?? ""),
+      kv,
+      vector,
+      messages
+    });
+  };
+  const hookInvoker = {
+    async onConnect(sessionId) {
+      await agent.onConnect?.(makeHookContext(sessionId));
     },
-    async listen(port = 3e3) {
-      await getWsFactory();
-      const http = await import("node:http");
-      const nodeServer = http.createServer(async (req, res) => {
-        await nodeHttpHandler(req, res, port, getWinterc);
-      });
-      attachWsUpgrade(nodeServer, port, getWinterc, logger);
-      await new Promise((resolve) => {
-        nodeServer.listen(port, () => {
-          logger.info(`Agent "${agent.name}" listening on http://localhost:${port}`);
-          resolve();
-        });
-      });
-      serverHandle = {
-        async shutdown() {
-          await new Promise((resolve, reject) => {
-            nodeServer.close((err) => err ? reject(err) : resolve());
-          });
-        }
-      };
+    async onDisconnect(sessionId) {
+      await agent.onDisconnect?.(makeHookContext(sessionId));
+      sessionState.delete(sessionId);
     },
-    async close() {
-      await winterc?.close();
-      await serverHandle?.shutdown();
+    async onTurn(sessionId, text) {
+      await agent.onTurn?.(text, makeHookContext(sessionId));
+    },
+    async onError(sessionId, error) {
+      await agent.onError?.(new Error(error.message), makeHookContext(sessionId));
+    },
+    async onStep(sessionId, step) {
+      await agent.onStep?.(step, makeHookContext(sessionId));
+    },
+    async resolveTurnConfig(sessionId) {
+      const ctx = makeHookContext(sessionId);
+      let maxSteps;
+      let activeTools;
+      if (typeof agent.maxSteps === "function") {
+        maxSteps = await agent.maxSteps(ctx) ?? void 0;
+      }
+      if (agent.onBeforeStep) {
+        const result = await agent.onBeforeStep(0, ctx);
+        activeTools = result?.activeTools;
+      }
+      if (maxSteps === void 0 && activeTools === void 0) return null;
+      const config = {};
+      if (maxSteps !== void 0) config.maxSteps = maxSteps;
+      if (activeTools !== void 0) config.activeTools = activeTools;
+      return config;
     }
   };
-}
-async function nodeHttpHandler(req, res, port, getWinterc) {
-  try {
-    const protocol = req.socket.encrypted ? "https" : "http";
-    const host = req.headers.host ?? `localhost:${port}`;
-    const url = new URL(req.url ?? "/", `${protocol}://${host}`);
-    const headers = new Headers();
-    for (const [key, val] of Object.entries(req.headers)) {
-      if (val)
-        headers.set(key, Array.isArray(val) ? val[0] ?? "" : val);
+  function createSession(sessionOpts) {
+    if (!createWebSocket) {
+      throw new Error("createWebSocket not provided \u2014 pass it in DirectExecutorOptions");
     }
-    const request = new Request(url, { method: req.method ?? "GET", headers });
-    const response = await getWinterc().fetch(request);
-    res.writeHead(response.status, Object.fromEntries(response.headers));
-    res.end(await response.text());
-  } catch (err) {
-    res.writeHead(500);
-    res.end(err instanceof Error ? err.message : "Internal Server Error");
-  }
-}
-function attachWsUpgrade(nodeServer, port, getWinterc, logger) {
-  import("ws").then((wsMod) => {
-    const WSServer = wsMod.WebSocketServer;
-    if (!WSServer)
-      return;
-    const wss = new WSServer({ noServer: true });
-    nodeServer.on("upgrade", (req, socket, head) => {
-      wss.handleUpgrade(req, socket, head, (ws) => {
-        const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
-        getWinterc().handleWebSocket(ws, {
-          skipGreeting: reqUrl.searchParams.has("resume")
-        });
-      });
+    const apiKey = frozenEnv.ASSEMBLYAI_API_KEY ?? "";
+    return createS2sSession({
+      id: sessionOpts.id,
+      agent: sessionOpts.agent,
+      client: sessionOpts.client,
+      agentConfig,
+      toolSchemas,
+      apiKey,
+      s2sConfig,
+      executeTool,
+      createWebSocket,
+      hookInvoker,
+      skipGreeting: sessionOpts.skipGreeting ?? false,
+      logger,
+      metrics
     });
-  }).catch(() => {
-    logger.warn("ws package not available for Node.js WebSocket upgrade");
-  });
+  }
+  return { executeTool, hookInvoker, toolSchemas, createSession };
 }
-var init_server = __esm({
-  "dist/sdk/server.js"() {
+var init_direct_executor = __esm({
+  "sdk/direct_executor.ts"() {
+    "use strict";
+    init_internal_types();
+    init_builtin_tools();
+    init_kv();
     init_runtime();
-    init_winterc_server();
+    init_session();
+    init_vector();
+    init_worker_entry();
   }
 });
 
-// cli/cli.ts
-import { readFileSync } from "node:fs";
-import path11 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-import minimist7 from "minimist";
-
-// cli/_help.ts
-init_colors();
-import chalk2 from "chalk";
-function rootHelp(version) {
-  const lines = [];
-  lines.push("");
-  lines.push(
-    `  ${primary(chalk2.bold(" \u2584\u2580\u2588 \u2584\u2580\u2588 \u2588"))}   ${chalk2.dim("Voice agent development kit")}`
-  );
-  lines.push(`  ${primary(chalk2.bold(" \u2588\u2580\u2588 \u2588\u2580\u2588 \u2588"))}   ${primary(`v${version}`)}`);
-  lines.push("");
-  lines.push(
-    `  ${chalk2.bold(interactive("Usage"))}   ${primary("aai")} ${chalk2.dim("<command> [options]")}`
-  );
-  lines.push("");
-  lines.push(`  ${chalk2.bold(interactive("Commands"))}`);
-  lines.push("");
-  const cmds = [
-    ["init", "[dir]", "Scaffold a new agent project"],
-    ["dev", "", "Start a local development server"],
-    ["deploy", "", "Bundle and deploy to production"],
-    ["start", "", "Start production server from build"],
-    ["secret", "<cmd>", "Manage secrets"],
-    ["rag", "<url>", "Ingest a site into the vector store"]
-  ];
-  for (const [name, args, desc] of cmds) {
-    const nameStr = interactive(name.padEnd(8));
-    const argsStr = args ? primary(args.padEnd(6)) : "      ";
-    lines.push(`    ${nameStr} ${argsStr} ${chalk2.dim(desc)}`);
-  }
-  lines.push("");
-  lines.push(`  ${chalk2.bold(interactive("Options"))}`);
-  lines.push("");
-  lines.push(
-    `    ${interactive("-h")}${chalk2.dim(",")} ${interactive("--help")}      ${chalk2.dim(
-      "Show this help"
-    )}`
-  );
-  lines.push(
-    `    ${interactive("-V")}${chalk2.dim(",")} ${interactive("--version")}   ${chalk2.dim(
-      "Show the version number"
-    )}`
-  );
-  lines.push("");
-  lines.push(`  ${chalk2.bold(interactive("Getting started"))}`);
-  lines.push("");
-  lines.push(
-    `    ${chalk2.dim("$")} ${primary("aai init")} ${interactive("my-agent")}    ${chalk2.dim(
-      "Create a new agent"
-    )}`
-  );
-  lines.push(`    ${chalk2.dim("$")} ${primary("cd my-agent")}`);
-  lines.push(
-    `    ${chalk2.dim("$")} ${primary("aai deploy")}          ${chalk2.dim("Deploy to production")}`
-  );
-  lines.push("");
-  return lines.join("\n");
+// sdk/ws_handler.ts
+function isValidAudioChunk(data) {
+  return data.byteLength > 0 && data.byteLength <= MAX_AUDIO_CHUNK_BYTES && data.byteLength % 2 === 0;
 }
-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}`);
+function createClientSink(ws) {
+  function safeSend(data) {
+    try {
+      if (ws.readyState === 1) ws.send(data);
+    } catch {
     }
-    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)}`);
+  return {
+    get open() {
+      return ws.readyState === 1;
+    },
+    event(e) {
+      safeSend(JSON.stringify(e));
+    },
+    playAudioChunk(chunk) {
+      safeSend(chunk);
+    },
+    playAudioDone() {
+      safeSend(JSON.stringify({ type: "audio_done" }));
     }
-    lines.push(`    ${interactive("-h")}${chalk2.dim(",")} ${interactive("--help")}`);
-    lines.push(`      ${chalk2.dim("Show this help")}`);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-
-// cli/cli.ts
-init_output();
-
-// cli/deploy.tsx
-import path6 from "node:path";
-import minimist2 from "minimist";
-
-// cli/_discover.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { humanId } from "human-id";
-
-// cli/_exec.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
-
-// cli/_discover.ts
-init_output();
-
-// cli/_prompts.tsx
-import { ConfirmInput, PasswordInput, Select } from "@inkjs/ui";
-import { Box, render, Text } from "ink";
-import { jsx, jsxs } from "react/jsx-runtime";
-async function askPassword(message) {
-  return new Promise((resolve) => {
-    const app = render(
-      /* @__PURE__ */ jsxs(Box, { children: [
-        /* @__PURE__ */ jsxs(Text, { children: [
-          message,
-          ": "
-        ] }),
-        /* @__PURE__ */ jsx(
-          PasswordInput,
-          {
-            onSubmit: (value) => {
-              resolve(value);
-              app.unmount();
-            }
-          }
-        )
-      ] })
-    );
-  });
-}
-async function askSelect(message, choices) {
-  return new Promise((resolve) => {
-    const app = render(
-      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-        /* @__PURE__ */ jsx(Text, { children: message }),
-        /* @__PURE__ */ jsx(
-          Select,
-          {
-            options: choices,
-            visibleOptionCount: choices.length,
-            onChange: (value) => {
-              resolve(value);
-              app.unmount();
-            }
-          }
-        )
-      ] })
-    );
-  });
-}
-
-// cli/_discover.ts
-function isDevMode() {
-  const script = process.argv[1] ?? "";
-  return script.endsWith(".ts") || script.endsWith(".tsx");
-}
-function generateSlug() {
-  return humanId({ separator: "-", capitalize: false });
+  };
 }
-var CONFIG_DIR = path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "aai");
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-async function readAuthConfig() {
-  try {
-    return JSON.parse(await fs.readFile(CONFIG_FILE, "utf-8"));
-  } catch {
-    return {};
-  }
+function isBinaryData(data) {
+  return globalThis.Buffer?.isBuffer(data) || data instanceof ArrayBuffer || data instanceof Uint8Array;
 }
-async function writeAuthConfig(config) {
-  await fs.mkdir(CONFIG_DIR, { recursive: true });
-  await fs.writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
-`);
-  if (process.platform !== "win32") {
-    await fs.chmod(CONFIG_FILE, 384);
-  }
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) return data;
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  const buf = data;
+  return new Uint8Array(buf.buffer ?? data, buf.byteOffset ?? 0, buf.byteLength);
 }
-async function getApiKey() {
-  const config = await readAuthConfig();
-  if (config.assemblyai_api_key) {
-    process.env.ASSEMBLYAI_API_KEY = config.assemblyai_api_key;
-    return config.assemblyai_api_key;
-  }
-  step("Setup", "AssemblyAI API key required for speech-to-text");
-  console.log("Get one at https://www.assemblyai.com/dashboard/signup\n");
-  let key;
-  while (!key) {
-    key = await askPassword("ASSEMBLYAI_API_KEY");
+function handleBinaryAudio(data, session, log, ctx, sid) {
+  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;
   }
-  config.assemblyai_api_key = key;
-  process.env.ASSEMBLYAI_API_KEY = key;
-  await writeAuthConfig(config);
-  step("Saved", CONFIG_FILE);
-  return key;
+  session.onAudio(chunk);
+  return true;
 }
-async function readProjectConfig(agentDir) {
+function handleTextMessage(data, session, log, ctx, sid) {
+  if (typeof data !== "string") return;
+  let json;
   try {
-    return JSON.parse(await fs.readFile(path.join(agentDir, ".aai", "project.json"), "utf-8"));
+    json = JSON.parse(data);
   } catch {
-    return null;
+    log.warn("Invalid JSON from client", { ...ctx, sid });
+    return;
   }
-}
-async function writeProjectConfig(agentDir, data) {
-  const aaiDir = path.join(agentDir, ".aai");
-  await fs.mkdir(aaiDir, { recursive: true });
-  await fs.writeFile(path.join(aaiDir, "project.json"), `${JSON.stringify(data, null, 2)}
-`);
-}
-var DEFAULT_SERVER = "https://aai-agent.fly.dev";
-async function fileExists(p) {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
+  const parsed = ClientMessageSchema.safeParse(json);
+  if (!parsed.success) {
+    log.warn("Invalid client message", { ...ctx, sid, error: parsed.error.message });
+    return;
+  }
+  const msg = parsed.data;
+  switch (msg.type) {
+    case "audio_ready":
+      session.onAudioReady();
+      break;
+    case "cancel":
+      session.onCancel();
+      break;
+    case "reset":
+      session.onReset();
+      break;
+    case "history":
+      session.onHistory(msg.messages);
+      break;
   }
 }
-async function loadAgent(dir) {
-  const hasAgentTs = await fileExists(path.join(dir, "agent.ts"));
-  if (!hasAgentTs) return null;
-  const config = await readProjectConfig(dir);
-  const slug = config?.slug ?? generateSlug();
-  const clientEntry = await fileExists(path.join(dir, "client.tsx")) ? path.join(dir, "client.tsx") : "";
-  return {
-    slug,
-    dir,
-    entryPoint: path.join(dir, "agent.ts"),
-    clientEntry
-  };
-}
-async function ensureClaudeMd(targetDir) {
-  const claudePath = path.join(targetDir, "CLAUDE.md");
-  const cliDir2 = path.dirname(fileURLToPath(import.meta.url));
-  const srcPath = path.join(cliDir2, "..", "templates", "_shared", "CLAUDE.md");
-  const srcContent = await fs.readFile(srcPath, "utf-8");
-  let existing = "";
-  try {
-    existing = await fs.readFile(claudePath, "utf-8");
-  } catch {
+function wireSessionSocket(ws, opts) {
+  const { sessions, logger: log = consoleLogger } = opts;
+  const sessionId = crypto.randomUUID();
+  const sid = sessionId.slice(0, 8);
+  const ctx = opts.logContext ?? {};
+  let session = null;
+  function onOpen() {
+    opts.onOpen?.();
+    log.info("Session connected", { ...ctx, sid });
+    const client = createClientSink(ws);
+    session = opts.createSession(sessionId, client);
+    sessions.set(sessionId, session);
+    ws.send(JSON.stringify({ type: "config", ...opts.readyConfig }));
+    void session.start();
+    log.info("Session ready", { ...ctx, sid });
   }
-  if (existing !== srcContent) {
-    await fs.writeFile(claudePath, srcContent);
-    step(existing ? "Updated" : "Wrote", "CLAUDE.md \u2014 aai agent API reference");
+  if (ws.readyState === 1) {
+    onOpen();
+  } else {
+    ws.addEventListener("open", onOpen);
   }
-}
-async function ensureDependencies(targetDir) {
-  if (!await fileExists(path.join(targetDir, "node_modules"))) {
-    step("Install", "dependencies");
-    try {
-      await execFileAsync("npm", ["install"], { cwd: targetDir });
-    } catch {
-      step("Skip", "npm install failed");
+  ws.addEventListener("message", (event) => {
+    if (!session) return;
+    const { data } = event;
+    if (handleBinaryAudio(data, session, log, ctx, sid)) return;
+    handleTextMessage(data, session, log, ctx, sid);
+  });
+  ws.addEventListener("close", () => {
+    log.info("Session disconnected", { ...ctx, sid });
+    if (session) {
+      void session.stop().finally(() => {
+        sessions.delete(sessionId);
+      });
     }
-  }
-}
-
-// cli/_deploy.ts
-init_output();
-var _internals = {
-  fetch: globalThis.fetch.bind(globalThis)
-};
-async function attemptDeploy(url, slug, apiKey, env, worker, html) {
-  return await _internals.fetch(`${url}/${slug}/deploy`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    },
-    body: JSON.stringify({
-      env,
-      worker,
-      html
-    })
+    opts.onClose?.();
+  });
+  ws.addEventListener("error", (event) => {
+    const msg = event instanceof ErrorEvent ? event.message : "WebSocket error";
+    log.error("WebSocket error", { ...ctx, sid, error: msg });
   });
 }
-var MAX_RETRIES = 20;
-async function runDeploy(opts) {
-  const worker = opts.bundle.worker;
-  const html = opts.bundle.html;
-  let slug = opts.slug;
-  if (opts.dryRun) {
-    stepInfo("Dry run", "would deploy:");
-    info(`${slug} -> ${opts.url}/${slug}`);
-    return { slug };
-  }
-  for (let i = 0; i < MAX_RETRIES; i++) {
-    const resp = await attemptDeploy(opts.url, slug, opts.apiKey, opts.env, worker, html);
-    if (resp.ok) {
-      step("Deploy", `${slug} -> ${opts.url}/${slug}`);
-      try {
-        const healthResp = await _internals.fetch(`${opts.url}/${slug}/health`);
-        const ok = healthResp.ok && (await healthResp.json()).status === "ok";
-        if (ok) {
-          step("Ready", slug);
-        } else {
-          warn(`${slug} deployed but health check failed -- check for runtime errors`);
-        }
-      } catch {
-      }
-      return { slug };
-    }
-    if (resp.status === 403) {
-      const text2 = await resp.text();
-      if (text2.includes("Slug")) {
-        const next = generateSlug();
-        step("Retry", `slug "${slug}" taken, trying "${next}"`);
-        slug = next;
-        continue;
-      }
-    }
-    const text = await resp.text();
-    throw new Error(`deploy failed (${resp.status}): ${text}`);
+var MAX_AUDIO_CHUNK_BYTES;
+var init_ws_handler = __esm({
+  "sdk/ws_handler.ts"() {
+    "use strict";
+    init_protocol();
+    init_runtime();
+    MAX_AUDIO_CHUNK_BYTES = 1048576;
   }
-  throw new Error(`deploy failed: could not find available slug after ${MAX_RETRIES} attempts`);
-}
+});
 
-// cli/_ink.tsx
-import { Spinner } from "@inkjs/ui";
-import { Box as Box2, render as render2, Static, Text as Text2, useApp } from "ink";
-import React, { useRef, useState } from "react";
-import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-var PAD2 = 9;
-var PRIMARY = "#fab283";
-var INTERACTIVE = "#56b6c2";
-var ERROR_COLOR = "#e06c75";
-var WARNING_COLOR = "#f5a742";
-function Step({ action, msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: PRIMARY, children: action.padStart(PAD2) }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function StepInfo({ action, msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: INTERACTIVE, children: action.padStart(PAD2) }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function Info({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
-    " ".repeat(PAD2 + 1),
-    msg
-  ] });
-}
-function Detail({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    " ".repeat(PAD2 + 1),
-    msg
-  ] });
-}
-function Warn({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: WARNING_COLOR, children: "warning".padStart(PAD2) }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function ErrorLine({ msg }) {
-  return /* @__PURE__ */ jsxs2(Text2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { bold: true, color: ERROR_COLOR, children: "error" }),
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      ": ",
-      msg
-    ] })
-  ] });
-}
-function StepLog({ items }) {
-  return /* @__PURE__ */ jsx2(Static, { items, children: (item) => /* @__PURE__ */ jsx2(Box2, { children: item.node }, item.id) });
-}
-function TaskSpinner({ label }) {
-  return /* @__PURE__ */ jsxs2(Box2, { children: [
-    /* @__PURE__ */ jsx2(Text2, { children: " ".repeat(PAD2 + 1) }),
-    /* @__PURE__ */ jsx2(Spinner, { label })
-  ] });
-}
-function useStepLog() {
-  const [items, setItems] = useState([]);
-  const nextId = useRef(0);
-  const log = (node) => {
-    const id = nextId.current++;
-    setItems((prev) => [...prev, { id, node }]);
+// sdk/winterc_server.ts
+function createWintercServer(options) {
+  const {
+    agent,
+    env,
+    kv = createMemoryKv(),
+    vector = createMemoryVectorStore(),
+    vectorSearch,
+    clientHtml,
+    logger = consoleLogger,
+    metrics = noopMetrics,
+    s2sConfig = DEFAULT_S2S_CONFIG
+  } = options;
+  const executor = createDirectExecutor({
+    agent,
+    env,
+    kv,
+    vector,
+    ...vectorSearch ? { vectorSearch } : {},
+    createWebSocket: options.createWebSocket,
+    logger,
+    metrics,
+    s2sConfig
+  });
+  const sessions = /* @__PURE__ */ new Map();
+  const readyConfig = {
+    audioFormat: AUDIO_FORMAT,
+    sampleRate: s2sConfig.inputSampleRate,
+    ttsSampleRate: s2sConfig.outputSampleRate
   };
-  return { items, log };
-}
-function CommandRunner({
-  run,
-  spinnerLabel,
-  onError
-}) {
-  const { exit } = useApp();
-  const { items, log } = useStepLog();
-  const [spinning, setSpinning] = useState(true);
-  const [err, setErr] = useState(null);
-  const started = useRef(false);
-  React.useEffect(() => {
-    if (started.current) return;
-    started.current = true;
-    (async () => {
-      try {
-        await run(log);
-      } catch (e) {
-        const error3 = e instanceof Error ? e : new Error(String(e));
-        setErr(error3.message);
-        onError?.(error3);
+  return {
+    async fetch(request) {
+      const url = new URL(request.url);
+      if (url.pathname === "/health") {
+        return new Response(JSON.stringify({ status: "ok", name: agent.name }), {
+          headers: { "Content-Type": "application/json" }
+        });
       }
-      setSpinning(false);
-      exit();
-    })();
-  });
-  return /* @__PURE__ */ jsxs2(Fragment, { children: [
-    /* @__PURE__ */ jsx2(StepLog, { items }),
-    err && /* @__PURE__ */ jsx2(ErrorLine, { msg: err }),
-    spinning && /* @__PURE__ */ jsx2(TaskSpinner, { label: spinnerLabel ?? "" })
-  ] });
-}
-async function runWithInk(label, fn) {
-  let thrownError;
-  const app = render2(
-    /* @__PURE__ */ jsx2(
-      CommandRunner,
-      {
-        spinnerLabel: label,
-        onError: (e) => {
-          thrownError = e;
-        },
-        run: fn
+      if (url.pathname === "/" && clientHtml) {
+        return new Response(clientHtml, {
+          headers: { "Content-Type": "text/html" }
+        });
       }
-    )
-  );
-  await app.waitUntilExit();
-  if (thrownError) throw thrownError;
-}
-
-// cli/build.ts
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
-
-// cli/_bundler.ts
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-import preact from "@preact/preset-vite";
-import tailwindcss from "@tailwindcss/vite";
-import { build } from "vite";
-import { viteSingleFile } from "vite-plugin-singlefile";
-var BundleError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BundleError";
-  }
-};
-function workerEntryPlugin(agentDir) {
-  const id = "virtual:worker-entry";
-  const resolved = `\0${id}`;
-  return {
-    name: "aai-worker-entry",
-    enforce: "pre",
-    resolveId(source) {
-      if (source === id) return resolved;
+      if (url.pathname === "/") {
+        return new Response(
+          `<!DOCTYPE html><html><body><h1>${agent.name}</h1><p>Agent server running.</p></body></html>`,
+          { headers: { "Content-Type": "text/html" } }
+        );
+      }
+      return new Response("Not Found", { status: 404 });
+    },
+    handleWebSocket(ws, wsOpts) {
+      wireSessionSocket(ws, {
+        sessions,
+        createSession: (sid, client) => executor.createSession({
+          id: sid,
+          agent: agent.name,
+          client,
+          skipGreeting: wsOpts?.skipGreeting ?? false
+        }),
+        readyConfig,
+        logger
+      });
     },
-    load(source) {
-      if (source === resolved) {
-        const agentPath = path2.resolve(agentDir, "agent.ts");
-        return [
-          `import agent from "${agentPath}";`,
-          `import { initWorker } from "@alexkroman1/aai/worker-shim";`,
-          `initWorker(agent);`
-        ].join("\n");
+    async close() {
+      for (const session of sessions.values()) {
+        await session.stop();
       }
+      sessions.clear();
     }
   };
 }
-var DEFAULT_STYLES_CSS = `@import url("https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500&display=swap");
-@import "tailwindcss";
-@source "./";
-@source "./components/";
-@source "./node_modules/@alexkroman1/aai/ui/";
-
-@theme {
-  --color-aai-bg: #101010;
-  --color-aai-surface: #151515;
-  --color-aai-surface-faint: rgba(255, 255, 255, 0.031);
-  --color-aai-surface-hover: rgba(255, 255, 255, 0.059);
-  --color-aai-border: #282828;
-  --color-aai-primary: #fab283;
-  --color-aai-text: rgba(255, 255, 255, 0.936);
-  --color-aai-text-secondary: rgba(255, 255, 255, 0.618);
-  --color-aai-text-muted: rgba(255, 255, 255, 0.284);
-  --color-aai-text-dim: rgba(255, 255, 255, 0.422);
-  --color-aai-error: #e06c75;
-  --color-aai-ring: #56b6c2;
-  --color-aai-state-disconnected: rgba(255, 255, 255, 0.422);
-  --color-aai-state-connecting: rgba(255, 255, 255, 0.422);
-  --color-aai-state-ready: #7fd88f;
-  --color-aai-state-listening: #56b6c2;
-  --color-aai-state-thinking: #f5a742;
-  --color-aai-state-speaking: #e06c75;
-  --color-aai-state-error: #e06c75;
-  --radius-aai: 6px;
-  --font-aai: "Inter", system-ui, -apple-system, sans-serif;
-  --font-aai-mono: "IBM Plex Mono", monospace;
-}
-
-@layer base {
-  html, body {
-    margin: 0;
-    padding: 0;
-    background: var(--color-aai-bg);
+var init_winterc_server = __esm({
+  "sdk/winterc_server.ts"() {
+    "use strict";
+    init_direct_executor();
+    init_kv();
+    init_protocol();
+    init_runtime();
+    init_vector();
+    init_ws_handler();
   }
-}
+});
 
-@keyframes aai-bounce {
-  0%, 80%, 100% {
-    opacity: 0.3;
-    transform: scale(0.8);
-  }
-  40% {
-    opacity: 1;
-    transform: scale(1);
+// sdk/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer
+});
+async function loadWsFactory() {
+  try {
+    const mod = await import("ws");
+    const WS = mod.default ?? mod;
+    return (url, opts) => new WS(url, { headers: opts.headers });
+  } catch {
+    throw new Error(
+      "WebSocket factory not provided and `ws` package not found. Install `ws` (`npm install ws`) or pass `createWebSocket` option."
+    );
   }
 }
-
-@keyframes aai-shimmer {
-  0% {
-    background-position: -200% 0;
-  }
-  100% {
-    background-position: 200% 0;
+function resolveEnv(env) {
+  const resolved = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) resolved[key] = value;
   }
+  return resolved;
 }
-
-.tool-shimmer {
-  background: linear-gradient(
-    90deg,
-    var(--color-aai-text) 25%,
-    var(--color-aai-text-dim) 50%,
-    var(--color-aai-text) 75%
+function createServer(options) {
+  const {
+    agent,
+    kv,
+    clientHtml,
+    clientDir,
+    logger = consoleLogger,
+    s2sConfig = DEFAULT_S2S_CONFIG
+  } = options;
+  const env = resolveEnv(
+    options.env ?? (typeof process !== "undefined" ? process.env : {})
   );
-  background-size: 200% 100%;
-  -webkit-background-clip: text;
-  background-clip: text;
-  -webkit-text-fill-color: transparent;
-  animation: aai-shimmer 2s ease-in-out infinite;
-}
-`;
-var INDEX_HTML = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta
-      name="viewport"
-      content="width=device-width, initial-scale=1.0, viewport-fit=cover"
-    />
-    <title>aai</title>
-    <link rel="icon" href="data:," />
-    <link rel="stylesheet" href="../styles.css" />
-  </head>
-  <body>
-    <main id="app"></main>
-    <script type="module" src="../client.tsx"></script>
-  </body>
-</html>
-`;
-async function bundleAgent(agent, opts) {
-  const aaiDir = path2.join(agent.dir, ".aai");
-  const buildDir = path2.join(aaiDir, "build");
-  await fs2.mkdir(aaiDir, { recursive: true });
-  await fs2.writeFile(path2.join(aaiDir, "index.html"), INDEX_HTML);
-  const stylesPath = path2.join(agent.dir, "styles.css");
-  try {
-    await fs2.access(stylesPath);
-  } catch {
-    await fs2.writeFile(stylesPath, DEFAULT_STYLES_CSS);
-  }
-  try {
-    await build({
-      configFile: false,
-      root: agent.dir,
-      logLevel: "warn",
-      plugins: [workerEntryPlugin(agent.dir)],
-      build: {
-        outDir: buildDir,
-        emptyOutDir: true,
-        minify: true,
-        target: "es2022",
-        rollupOptions: {
-          input: "virtual:worker-entry",
-          output: {
-            format: "es",
-            entryFileNames: "worker.js",
-            inlineDynamicImports: true
-          }
-        }
-      }
-    });
-  } catch (err) {
-    throw new BundleError(err instanceof Error ? err.message : String(err));
+  let wsFactory = options.createWebSocket ?? null;
+  async function getWsFactory() {
+    if (!wsFactory) {
+      wsFactory = await loadWsFactory();
+    }
+    return wsFactory;
   }
-  const skipClient = opts?.skipClient || !agent.clientEntry;
-  if (!skipClient) {
-    try {
-      await build({
-        configFile: false,
-        root: aaiDir,
-        logLevel: "warn",
-        plugins: [preact(), tailwindcss(), viteSingleFile()],
-        build: {
-          outDir: buildDir,
-          emptyOutDir: false,
-          minify: true,
-          target: "es2022"
-        }
+  let winterc = null;
+  function getWinterc() {
+    if (!winterc) {
+      winterc = createWintercServer({
+        agent,
+        env,
+        ...kv ? { kv } : {},
+        createWebSocket: wsFactory ?? (() => {
+          throw new Error("WebSocket factory not loaded");
+        }),
+        ...clientHtml !== void 0 ? { clientHtml } : {},
+        logger,
+        s2sConfig
       });
-    } catch (err) {
-      throw new BundleError(err instanceof Error ? err.message : String(err));
     }
+    return winterc;
   }
-  const worker = await fs2.readFile(path2.join(buildDir, "worker.js"), "utf-8");
-  const htmlPath = skipClient ? path2.join(aaiDir, "index.html") : path2.join(buildDir, "index.html");
-  const html = await fs2.readFile(htmlPath, "utf-8");
+  let serverHandle = null;
   return {
-    worker,
-    html,
-    workerBytes: Buffer.byteLength(worker)
+    fetch(request) {
+      return getWinterc().fetch(request);
+    },
+    async listen(port = 3e3) {
+      await getWsFactory();
+      const http = await import("node:http");
+      const nodeServer = http.createServer(async (req, res) => {
+        if (clientDir && req.url) {
+          const served = await serveStaticFile(req.url, clientDir, res);
+          if (served) return;
+        }
+        await nodeHttpHandler(req, res, port, getWinterc);
+      });
+      attachWsUpgrade(nodeServer, port, getWinterc, logger);
+      await new Promise((resolve) => {
+        nodeServer.listen(port, () => resolve());
+      });
+      serverHandle = {
+        async shutdown() {
+          await new Promise((resolve, reject) => {
+            nodeServer.close((err) => err ? reject(err) : resolve());
+          });
+        }
+      };
+    },
+    async close() {
+      await winterc?.close();
+      await serverHandle?.shutdown();
+    }
   };
 }
-
-// cli/build.ts
-init_output();
-async function writeBuildOutput(agentDir, bundle) {
-  const buildDir = path3.join(agentDir, ".aai", "build");
-  await fs3.mkdir(buildDir, { recursive: true });
-  await Promise.all([
-    fs3.writeFile(path3.join(buildDir, "worker.js"), bundle.worker),
-    fs3.writeFile(path3.join(buildDir, "index.html"), bundle.html)
-  ]);
-}
-async function runBuild(opts) {
-  const agent = await loadAgent(opts.agentDir);
-  if (!agent) {
-    throw new Error("No agent found \u2014 run `aai new` first");
-  }
-  step("Bundle", agent.slug);
-  let bundle;
+async function serveStaticFile(reqUrl, clientDir, res) {
+  const { readFile } = await import("node:fs/promises");
+  const { join, extname, normalize } = await import("node:path");
+  const urlPath = new URL(reqUrl, "http://localhost").pathname;
+  const relPath = urlPath === "/" ? "index.html" : urlPath.slice(1);
+  const filePath = normalize(join(clientDir, relPath));
+  if (!filePath.startsWith(clientDir)) return false;
   try {
-    bundle = await bundleAgent(agent);
-  } catch (err) {
-    if (err instanceof BundleError) {
-      error2(err.message);
-      throw new Error("Bundle failed \u2014 fix the errors above");
-    }
-    throw err;
+    const content = await readFile(filePath);
+    const ext = extname(filePath);
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+    res.writeHead(200, { "Content-Type": contentType });
+    res.end(content);
+    return true;
+  } catch {
+    return false;
   }
-  await writeBuildOutput(opts.agentDir, bundle);
-  return { agent, bundle };
-}
-
-// cli/new.tsx
-init_colors();
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import chalk4 from "chalk";
-import minimist from "minimist";
-init_new();
-var newCommandDef = {
-  name: "init",
-  description: "Scaffold a new agent project",
-  args: [{ name: "dir", optional: true }],
-  options: [
-    {
-      flags: "-t, --template <template>",
-      description: "Template to use"
-    },
-    { flags: "-f, --force", description: "Overwrite existing agent.ts" },
-    { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
-  ]
-};
-var TEMPLATE_DESCRIPTIONS = {
-  simple: "Minimal starter with search, code, and fetch tools",
-  "web-researcher": "Research assistant with web search and page visits",
-  "smart-research": "Phase-based research with dynamic tool filtering",
-  "memory-agent": "Persistent KV storage across conversations",
-  "code-interpreter": "Writes and runs JavaScript for calculations",
-  "math-buddy": "Calculations, unit conversions, dice rolls",
-  "health-assistant": "Medication lookup, drug interactions, BMI",
-  "personal-finance": "Currency, crypto, loans, savings projections",
-  "travel-concierge": "Trip planning, weather, flights, hotels",
-  "night-owl": "Movie/music/book recs by mood \u2014 custom UI",
-  "dispatch-center": "911 dispatch with triage \u2014 custom UI",
-  "infocom-adventure": "Zork-style text adventure \u2014 custom UI",
-  "embedded-assets": "FAQ bot using embedded JSON knowledge",
-  support: "RAG-powered support agent for a documentation site",
-  terminal: "STT-only mode for voice-driven commands"
-};
-async function selectTemplate(available) {
-  const sorted = ["simple", ...available.filter((t) => t !== "simple")];
-  const maxLen = Math.max(...sorted.map((t) => t.length));
-  const choices = sorted.map((name) => ({
-    label: `${name.padEnd(maxLen + 2)}${TEMPLATE_DESCRIPTIONS[name] ?? ""}`,
-    value: name
-  }));
-  return await askSelect("Which template?", choices);
 }
-async function runNewCommand(args, version, opts) {
-  const parsed = minimist(args, {
-    string: ["template"],
-    boolean: ["force", "help", "yes"],
-    alias: { t: "template", f: "force", h: "help", y: "yes" }
-  });
-  if (parsed.help) {
-    console.log(subcommandHelp(newCommandDef, version));
-    return "";
-  }
-  const dir = parsed._[0];
-  const cwd = dir ?? (process.env.INIT_CWD || process.cwd());
-  if (!parsed.force && await fileExists(path5.join(cwd, "agent.ts"))) {
-    console.log(
-      `agent.ts already exists in this directory. Use ${interactive("--force")} to overwrite.`
-    );
-    process.exit(1);
-  }
-  const cliDir2 = path5.dirname(fileURLToPath2(import.meta.url));
-  const templatesDir = path5.join(cliDir2, "..", "templates");
-  const { runNew: runNew2 } = await Promise.resolve().then(() => (init_new(), new_exports));
-  const available = await listTemplates(templatesDir);
-  const template = parsed.template || (parsed.yes ? "simple" : await selectTemplate(available));
-  await runWithInk("Scaffolding...", async () => {
-    await runNew2({
-      targetDir: cwd,
-      template,
-      templatesDir
-    });
-    if (isDevMode()) {
-      const monorepoRoot = path5.join(cliDir2, "..");
-      const pkgJsonPath2 = path5.join(cwd, "package.json");
-      const pkgJson2 = JSON.parse(await fs5.readFile(pkgJsonPath2, "utf-8"));
-      for (const pkg of ["sdk", "ui"]) {
-        const localPkgPath = path5.join(monorepoRoot, pkg, "package.json");
-        const localPkg = JSON.parse(await fs5.readFile(localPkgPath, "utf-8"));
-        const pkgName = localPkg.name;
-        pkgJson2.dependencies[pkgName] = `file:${path5.join(monorepoRoot, pkg)}`;
-      }
-      await fs5.writeFile(pkgJsonPath2, `${JSON.stringify(pkgJson2, null, 2)}
-`);
-    }
-    await ensureClaudeMd(cwd);
-    await ensureDependencies(cwd);
-  });
-  if (!opts?.quiet) {
-    const cdNeeded = dir != null;
-    console.log();
-    console.log(chalk4.bold("Next steps:"));
-    if (cdNeeded) {
-      console.log(`  ${chalk4.dim("$")} ${primary(`cd ${path5.relative(process.cwd(), cwd)}`)}`);
+async function nodeHttpHandler(req, res, port, getWinterc) {
+  try {
+    const protocol = req.socket.encrypted ? "https" : "http";
+    const host = req.headers.host ?? `localhost:${port}`;
+    const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+    const headers = new Headers();
+    for (const [key, val] of Object.entries(req.headers)) {
+      if (val) headers.set(key, Array.isArray(val) ? val[0] ?? "" : val);
     }
-    console.log(
-      `  ${chalk4.dim("$")} ${primary("aai dev")}          ${chalk4.dim("Start local dev server")}`
-    );
-    console.log(
-      `  ${chalk4.dim("$")} ${primary("aai deploy")}       ${chalk4.dim("Deploy to production")}`
-    );
+    const request = new Request(url, { method: req.method ?? "GET", headers });
+    const response = await getWinterc().fetch(request);
+    res.writeHead(response.status, Object.fromEntries(response.headers));
+    res.end(await response.text());
+  } catch (err) {
+    res.writeHead(500);
+    res.end(err instanceof Error ? err.message : "Internal Server Error");
   }
-  return cwd;
 }
-
-// cli/deploy.tsx
-var deployCommandDef = {
-  name: "deploy",
-  description: "Bundle and deploy to production",
-  options: [
-    { flags: "-s, --server <url>", description: "Server URL" },
-    {
-      flags: "--local [url]",
-      description: "Use local server",
-      hidden: true
-    },
-    {
-      flags: "--dry-run",
-      description: "Validate and bundle without deploying"
-    },
-    { flags: "-y, --yes", description: "Accept defaults (no prompts)" }
-  ]
-};
-async function runDeployCommand(args, version) {
-  const parsed = minimist2(args, {
-    string: ["server", "local"],
-    boolean: ["dry-run", "help", "yes"],
-    alias: { s: "server", h: "help", y: "yes" }
-  });
-  if (parsed.help) {
-    console.log(subcommandHelp(deployCommandDef, version));
-    return;
-  }
-  const cwd = process.env.INIT_CWD || process.cwd();
-  if (!await fileExists(path6.join(cwd, "agent.ts"))) {
-    await runNewCommand(parsed.yes ? ["-y"] : [], version, { quiet: true });
-  }
-  const local = parsed.local;
-  const serverUrl = local !== void 0 ? typeof local === "string" && local !== "" ? local : "http://localhost:3100" : parsed.server || (isDevMode() ? "http://localhost:3100" : DEFAULT_SERVER);
-  const dryRun = parsed["dry-run"] ?? false;
-  const apiKey = dryRun ? "" : await getApiKey();
-  const projectConfig = await readProjectConfig(cwd);
-  const slug = projectConfig?.slug ?? generateSlug();
-  await runWithInk("Deploying...", async () => {
-    const result = await runBuild({ agentDir: cwd });
-    const deployed = await runDeploy({
-      url: serverUrl,
-      bundle: result.bundle,
-      env: dryRun ? {} : { ASSEMBLYAI_API_KEY: apiKey },
-      slug,
-      dryRun,
-      apiKey
-    });
-    await writeProjectConfig(cwd, {
-      slug: deployed.slug,
-      serverUrl
+function attachWsUpgrade(nodeServer, port, getWinterc, logger) {
+  import("ws").then((wsMod) => {
+    const WSServer = wsMod.WebSocketServer;
+    if (!WSServer) return;
+    const wss = new WSServer({ noServer: true });
+    nodeServer.on("upgrade", (req, socket, head) => {
+      wss.handleUpgrade(
+        req,
+        socket,
+        head,
+        (ws) => {
+          const reqUrl = new URL(
+            req.url ?? "/",
+            `http://localhost:${port}`
+          );
+          getWinterc().handleWebSocket(ws, {
+            skipGreeting: reqUrl.searchParams.has("resume")
+          });
+        }
+      );
     });
+  }).catch(() => {
+    logger.warn("ws package not available for Node.js WebSocket upgrade");
   });
 }
+var MIME_TYPES;
+var init_server = __esm({
+  "sdk/server.ts"() {
+    "use strict";
+    init_runtime();
+    init_winterc_server();
+    MIME_TYPES = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".css": "text/css",
+      ".json": "application/json",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".ico": "image/x-icon",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2"
+    };
+  }
+});
+
+// cli/cli.ts
+init_help();
+init_deploy2();
+import { readFileSync } from "node:fs";
+import path10 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import minimist7 from "minimist";
 
 // cli/dev.tsx
-import path8 from "node:path";
+import path7 from "node:path";
 import minimist3 from "minimist";
 
 // cli/_dev.ts
-init_output();
+init_bundler();
+init_discover();
+init_ink();
+import React2 from "react";
 
 // cli/_server_common.ts
-import path7 from "node:path";
+init_discover();
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
 import { createServer as createViteServer } from "vite";
-init_output();
 async function loadAgentDef(cwd) {
-  const agentPath = path7.resolve(cwd, "agent.ts");
+  const agentPath = path6.resolve(cwd, "agent.ts");
   const vite = await createViteServer({
     root: cwd,
     logLevel: "silent",
@@ -2623,61 +2634,54 @@ async function resolveServerEnv() {
     Object.entries(process.env).filter((e) => e[1] !== void 0)
   );
   if (!env.ASSEMBLYAI_API_KEY) {
-    try {
-      env.ASSEMBLYAI_API_KEY = await getApiKey();
-    } catch {
-      error2("ASSEMBLYAI_API_KEY not set. Set it in your environment or run `aai env add`.");
-      throw new Error("ASSEMBLYAI_API_KEY is required");
-    }
+    env.ASSEMBLYAI_API_KEY = await getApiKey();
   }
   return env;
 }
-async function loadWsFromProject(cwd) {
-  const wsPath = path7.resolve(cwd, "node_modules", "ws", "index.js");
-  const mod = await import(wsPath);
-  const WS = mod.default ?? mod;
-  return (url, opts) => new WS(url, { headers: opts.headers });
-}
-async function bootServer(agentDef, html, env, port, cwd) {
-  step("Start", `http://localhost:${port}`);
-  const createWebSocket = await loadWsFromProject(cwd);
+async function bootServer(agentDef, clientDir, env, port) {
+  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(path6.join(clientDir, "index.html"), "utf-8");
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = createServer2({
     agent: agentDef,
-    clientHtml: html,
+    clientHtml,
+    clientDir,
     env,
     createWebSocket
   });
   await server.listen(port);
-  step("Ready", `http://localhost:${port}`);
 }
 
 // cli/_dev.ts
-async function _startDevServer(cwd, port) {
+async function _startDevServer(cwd, port, log) {
   const agent = await loadAgent(cwd);
   if (!agent) {
     throw new Error("No agent found \u2014 run `aai init` first");
   }
-  step("Bundle", agent.slug);
-  let html;
+  log(React2.createElement(Step, { action: "Build", msg: agent.slug }));
+  let clientDir;
   try {
     const bundle = await bundleAgent(agent);
-    html = bundle.html;
+    clientDir = bundle.clientDir;
   } catch (err) {
     if (err instanceof BundleError) {
-      error2(err.message);
-      throw new Error("Bundle failed \u2014 fix the errors above");
+      throw new Error(`Bundle failed: ${err.message}`);
     }
     throw err;
   }
-  step("Load", "agent.ts");
   const agentDef = await loadAgentDef(cwd);
   const env = await resolveServerEnv();
-  await bootServer(agentDef, html, env, port, cwd);
+  await bootServer(agentDef, clientDir, env, port);
+  log(React2.createElement(Step, { action: "Ready", msg: `http://localhost:${port}` }));
 }
 
 // cli/dev.tsx
-import { jsx as jsx3 } from "react/jsx-runtime";
+init_discover();
+init_help();
+init_ink();
+init_init2();
 var devCommandDef = {
   name: "dev",
   description: "Start a local development server",
@@ -2701,22 +2705,27 @@ async function runDevCommand(args, version) {
   }
   const cwd = process.env.INIT_CWD || process.cwd();
   const port = Number.parseInt(parsed.port ?? "3000", 10);
-  if (!await fileExists(path8.join(cwd, "agent.ts"))) {
-    await runNewCommand(parsed.yes ? ["-y"] : [], version, { quiet: true });
+  if (!await fileExists(path7.join(cwd, "agent.ts"))) {
+    await runInitCommand(parsed.yes ? ["-y"] : [], version, { quiet: true });
   }
   await getApiKey();
-  await runWithInk("Bundling...", async (log) => {
-    log(/* @__PURE__ */ jsx3(Step, { action: "Dev", msg: `starting on port ${port}` }));
-    await _startDevServer(cwd, port);
+  await runWithInk(async (log) => {
+    await _startDevServer(cwd, port, log);
   });
 }
 
+// cli/cli.ts
+init_init2();
+
 // cli/rag.tsx
+init_discover();
+init_help();
+init_ink();
 import { render as render3, Text as Text3, useApp as useApp2 } from "ink";
 import minimist4 from "minimist";
 import pLimit from "p-limit";
 import { useEffect, useState as useState2 } from "react";
-import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
 var ragCommandDef = {
   name: "rag",
   description: "Ingest a site's llms-full.txt into the vector store",
@@ -2731,7 +2740,7 @@ var ragCommandDef = {
   ]
 };
 var FETCH_TIMEOUT_MS = 6e4;
-var PAD3 = 9;
+var PAD = 9;
 function RagUI({ url, apiKey, serverUrl, slug, chunkSize, onError }) {
   const { exit } = useApp2();
   const { items, log } = useStepLog();
@@ -2750,19 +2759,19 @@ function RagUI({ url, apiKey, serverUrl, slug, chunkSize, onError }) {
           setProgress
         });
       } catch (e) {
-        const error3 = e instanceof Error ? e : new Error(String(e));
-        setErr(error3.message);
-        onError?.(error3);
+        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__ */ jsx4(StepLog, { items }),
-    err && /* @__PURE__ */ jsx4(ErrorLine, { msg: err }),
+    /* @__PURE__ */ jsx5(StepLog, { items }),
+    err && /* @__PURE__ */ jsx5(ErrorLine, { msg: err }),
     progress && /* @__PURE__ */ jsxs3(Text3, { children: [
-      " ".repeat(PAD3 + 1),
+      " ".repeat(PAD + 1),
       "Upsert ",
       progress.completed,
       "/",
@@ -2775,7 +2784,7 @@ function RagUI({ url, apiKey, serverUrl, slug, chunkSize, onError }) {
 }
 async function runRag(opts) {
   const { url, apiKey, serverUrl, slug, chunkSize, log, setProgress } = opts;
-  log(/* @__PURE__ */ jsx4(Step, { action: "Fetch", msg: url }));
+  log(/* @__PURE__ */ jsx5(Step, { action: "Fetch", msg: url }));
   const resp = await fetch(url, {
     headers: { "User-Agent": "aai-cli/1.0" },
     redirect: "follow",
@@ -2786,27 +2795,27 @@ async function runRag(opts) {
   }
   const content = await resp.text();
   if (content.length === 0) {
-    log(/* @__PURE__ */ jsx4(Warn, { msg: "File is empty" }));
+    log(/* @__PURE__ */ jsx5(Warn, { msg: "File is empty" }));
     return;
   }
-  log(/* @__PURE__ */ jsx4(Info, { msg: `${(content.length / 1024).toFixed(0)} KB` }));
+  log(/* @__PURE__ */ jsx5(Info, { msg: `${(content.length / 1024).toFixed(0)} KB` }));
   const origin = new URL(url).origin;
   const pages = splitPages(content);
-  log(/* @__PURE__ */ jsx4(Step, { action: "Parsed", msg: `${pages.length} pages` }));
+  log(/* @__PURE__ */ jsx5(Step, { action: "Parsed", 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__ */ jsx4(Step, { action: "Chunked", msg: `${allChunks.length} chunks` }));
+  log(/* @__PURE__ */ jsx5(Step, { action: "Chunked", msg: `${allChunks.length} chunks` }));
   const vectorUrl = `${serverUrl}/${slug}/vector`;
-  log(/* @__PURE__ */ jsx4(Info, { msg: `target: ${vectorUrl}` }));
+  log(/* @__PURE__ */ jsx5(Info, { msg: `target: ${vectorUrl}` }));
   const result = await upsertChunks(allChunks, vectorUrl, apiKey, setProgress);
-  log(/* @__PURE__ */ jsx4(Step, { action: "Done", msg: `${result.upserted} chunks upserted` }));
+  log(/* @__PURE__ */ jsx5(Step, { action: "Done", msg: `${result.upserted} chunks upserted` }));
   if (result.errors > 0) {
-    log(/* @__PURE__ */ jsx4(Warn, { msg: `${result.errors} failed` }));
-    if (result.lastError) log(/* @__PURE__ */ jsx4(Info, { msg: `last error: ${result.lastError}` }));
+    log(/* @__PURE__ */ jsx5(Warn, { msg: `${result.errors} failed` }));
+    if (result.lastError) log(/* @__PURE__ */ jsx5(Info, { msg: `last error: ${result.lastError}` }));
   }
-  log(/* @__PURE__ */ jsx4(Detail, { msg: `Agent: ${slug}` }));
+  log(/* @__PURE__ */ jsx5(Detail, { msg: `Agent: ${slug}` }));
 }
 async function chunkPages(pages, chunker, origin, siteSlug) {
   const allChunks = [];
@@ -2907,7 +2916,7 @@ async function runRagCommand(args, version) {
   const chunkSize = Number.parseInt(parsed["chunk-size"] ?? "512", 10);
   let thrownError;
   const app = render3(
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsx5(
       RagUI,
       {
         url,
@@ -2971,8 +2980,12 @@ function slugify(s) {
 }
 
 // cli/secret.tsx
+init_discover();
+init_help();
+init_ink();
+init_prompts();
 import minimist5 from "minimist";
-import { jsx as jsx5 } from "react/jsx-runtime";
+import { jsx as jsx6 } from "react/jsx-runtime";
 var secretCommandDef = {
   name: "secret",
   description: "Manage secrets",
@@ -3031,7 +3044,7 @@ async function getServerInfo(cwd) {
   return { serverUrl, slug, apiKey };
 }
 async function secretPut(cwd, name, value) {
-  await runWithInk("Setting...", async (log) => {
+  await runWithInk(async (log) => {
     const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
     const resp = await fetch(`${serverUrl}/${slug}/secret`, {
       method: "PUT",
@@ -3045,12 +3058,12 @@ async function secretPut(cwd, name, value) {
       const text = await resp.text();
       throw new Error(`Failed to set secret: ${text}`);
     }
-    log(/* @__PURE__ */ jsx5(Step, { action: "Set", msg: `${name} for ${slug}` }));
+    log(/* @__PURE__ */ jsx6(Step, { action: "Set", msg: `${name} for ${slug}` }));
   });
 }
 async function secretDelete(cwd, name) {
   if (!name) throw new Error("Usage: aai secret delete <NAME>");
-  await runWithInk("Removing...", async (log) => {
+  await runWithInk(async (log) => {
     const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
     const resp = await fetch(`${serverUrl}/${slug}/secret/${name}`, {
       method: "DELETE",
@@ -3060,11 +3073,11 @@ async function secretDelete(cwd, name) {
       const text = await resp.text();
       throw new Error(`Failed to delete secret: ${text}`);
     }
-    log(/* @__PURE__ */ jsx5(Step, { action: "Deleted", msg: `${name} from ${slug}` }));
+    log(/* @__PURE__ */ jsx6(Step, { action: "Deleted", msg: `${name} from ${slug}` }));
   });
 }
 async function secretList(cwd) {
-  await runWithInk("Loading...", async (log) => {
+  await runWithInk(async (log) => {
     const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
     const resp = await fetch(`${serverUrl}/${slug}/secret`, {
       headers: { Authorization: `Bearer ${apiKey}` }
@@ -3075,34 +3088,38 @@ async function secretList(cwd) {
     }
     const { vars } = await resp.json();
     if (vars.length === 0) {
-      log(/* @__PURE__ */ jsx5(StepInfo, { action: "Secrets", msg: "No secrets set" }));
+      log(/* @__PURE__ */ jsx6(StepInfo, { action: "Secrets", msg: "No secrets set" }));
     } else {
       for (const name of vars) {
-        log(/* @__PURE__ */ jsx5(Detail, { msg: name }));
+        log(/* @__PURE__ */ jsx6(Detail, { msg: name }));
       }
     }
   });
 }
 
 // cli/start.tsx
-import path10 from "node:path";
+init_discover();
+init_help();
+init_ink();
+import path9 from "node:path";
 import minimist6 from "minimist";
 
 // cli/_start.ts
-init_output();
-import fs6 from "node:fs/promises";
-import path9 from "node:path";
-async function _startProductionServer(cwd, port) {
-  const buildDir = path9.join(cwd, ".aai", "build");
-  const html = await fs6.readFile(path9.join(buildDir, "index.html"), "utf-8");
-  step("Load", "agent");
+init_ink();
+import path8 from "node:path";
+import React3 from "react";
+async function _startProductionServer(cwd, port, log) {
+  const clientDir = path8.join(cwd, ".aai", "client");
+  log(React3.createElement(Step, { action: "Load", msg: "agent" }));
   const agentDef = await loadAgentDef(cwd);
   const env = await resolveServerEnv();
-  await bootServer(agentDef, html, env, port, cwd);
+  log(React3.createElement(Step, { action: "Start", msg: `http://localhost:${port}` }));
+  await bootServer(agentDef, clientDir, env, port);
+  log(React3.createElement(Step, { action: "Ready", msg: `http://localhost:${port}` }));
 }
 
 // cli/start.tsx
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { jsx as jsx7 } from "react/jsx-runtime";
 var startCommandDef = {
   name: "start",
   description: "Start the production server from a build",
@@ -3126,20 +3143,20 @@ async function runStartCommand(args, version) {
   }
   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"))) {
+  const buildDir = path9.join(cwd, ".aai", "build");
+  if (!await fileExists(path9.join(buildDir, "worker.js"))) {
     throw new Error("No build found \u2014 run `aai build` first");
   }
   await getApiKey();
-  await runWithInk("Starting...", async (log) => {
-    log(/* @__PURE__ */ jsx6(Step, { action: "Start", msg: `production server on port ${port}` }));
-    await _startProductionServer(cwd, port);
+  await runWithInk(async (log) => {
+    log(/* @__PURE__ */ jsx7(Step, { action: "Start", msg: `production server on port ${port}` }));
+    await _startProductionServer(cwd, port, log);
   });
 }
 
 // cli/cli.ts
-var cliDir = path11.dirname(fileURLToPath3(import.meta.url));
-var pkgJsonPath = path11.join(cliDir, "..", "package.json");
+var cliDir = path10.dirname(fileURLToPath2(import.meta.url));
+var pkgJsonPath = path10.join(cliDir, "..", "package.json");
 var pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
 var VERSION = pkgJson.version;
 async function main(args) {
@@ -3160,8 +3177,7 @@ async function main(args) {
   const subArgs = rest.map(String);
   switch (subcommand) {
     case "init":
-    case "new":
-      await runNewCommand(subArgs, VERSION);
+      await runInitCommand(subArgs, VERSION);
       return;
     case "deploy":
       await runDeployCommand(subArgs, VERSION);
@@ -3179,20 +3195,23 @@ async function main(args) {
       await runRagCommand(subArgs, VERSION);
       return;
     case "help":
-    case void 0:
       console.log(rootHelp(VERSION));
       return;
+    case void 0:
+      await runInitCommand(subArgs, VERSION);
+      return;
     default:
-      error2(`Unknown command: ${subcommand}`);
+      console.error(`Unknown command: ${subcommand}`);
       console.log(rootHelp(VERSION));
       process.exit(1);
   }
 }
-try {
-  await main(process.argv.slice(2));
-} catch (err) {
-  error2(err instanceof Error ? err.message : String(err));
-  process.exit(1);
+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));
+    process.exit(1);
+  });
 }
 export {
   main