@alexkroman1/aai 0.8.8 → 0.9.0

package/dist/cli.js

@@ -1,2811 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// sdk/_utils.ts
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-var init_utils = __esm({
-  "sdk/_utils.ts"() {
-    "use strict";
-  }
-});
-
-// cli/_ink.tsx
-import { Spinner, StatusMessage } from "@inkjs/ui";
-import chalk from "chalk";
-import { Box, render, Static, Text, useApp } from "ink";
-import React, { useRef, useState } from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-function primary(s) {
-  return chalk.hex(COLORS.primary)(s);
-}
-function interactive(s) {
-  return chalk.hex(COLORS.interactive)(s);
-}
-function StepBase({ action, msg, color }) {
-  return /* @__PURE__ */ jsxs(Text, { children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, color, children: action }),
-    /* @__PURE__ */ jsxs(Text, { children: [
-      " ",
-      msg
-    ] })
-  ] });
-}
-function Step({ action, msg }) {
-  return /* @__PURE__ */ jsx(StepBase, { action, msg, color: COLORS.primary });
-}
-function StepInfo({ action, msg }) {
-  return /* @__PURE__ */ jsx(StepBase, { action, msg, color: COLORS.interactive });
-}
-function Info({ msg }) {
-  return /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
-    "  ",
-    msg
-  ] });
-}
-function Detail({ msg }) {
-  return /* @__PURE__ */ jsxs(Text, { children: [
-    "  ",
-    msg
-  ] });
-}
-function Warn({ msg }) {
-  return /* @__PURE__ */ jsx(StatusMessage, { variant: "warning", children: msg });
-}
-function ErrorLine({ msg }) {
-  return /* @__PURE__ */ jsx(StatusMessage, { variant: "error", children: msg });
-}
-function StepLog({ items }) {
-  return /* @__PURE__ */ jsx(Static, { items, children: (item) => /* @__PURE__ */ jsx(Box, { children: item.node }, item.id) });
-}
-function useStepLog() {
-  const [items, setItems] = useState([]);
-  const nextId = useRef(0);
-  const log = (node) => {
-    const id = nextId.current++;
-    setItems((prev) => [...prev, { id, node }]);
-  };
-  return { items, log };
-}
-function CommandRunner({
-  run,
-  onError
-}) {
-  const { exit } = useApp();
-  const { items, log } = useStepLog();
-  const [spinning, setSpinning] = useState(true);
-  const [currentStep, setCurrentStep] = useState(null);
-  const [statusLine, setStatusLine] = useState(null);
-  const [err, setErr] = useState(null);
-  const currentStepRef = useRef(null);
-  const wrappedLog = (node) => {
-    if (currentStepRef.current) {
-      log(currentStepRef.current);
-    }
-    currentStepRef.current = node;
-    setCurrentStep(node);
-  };
-  const started = useRef(false);
-  React.useEffect(() => {
-    if (started.current) return;
-    started.current = true;
-    (async () => {
-      try {
-        await run({ log: wrappedLog, setStatus: setStatusLine });
-      } catch (e) {
-        const error = e instanceof Error ? e : new Error(String(e));
-        setErr(error.message);
-        onError?.(error);
-      }
-      if (currentStepRef.current) {
-        log(currentStepRef.current);
-        currentStepRef.current = null;
-      }
-      setCurrentStep(null);
-      setStatusLine(null);
-      setSpinning(false);
-      setTimeout(() => exit(), 0);
-    })();
-  });
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    /* @__PURE__ */ jsx(StepLog, { items }),
-    err && /* @__PURE__ */ jsx(ErrorLine, { msg: err }),
-    spinning && currentStep && /* @__PURE__ */ jsxs(Box, { children: [
-      /* @__PURE__ */ jsx(Spinner, {}),
-      /* @__PURE__ */ jsx(Text, { children: " " }),
-      currentStep
-    ] }),
-    spinning && statusLine && /* @__PURE__ */ jsx(Box, { children: statusLine })
-  ] });
-}
-async function runWithInk(fn) {
-  let thrownError;
-  const app = render(
-    /* @__PURE__ */ jsx(
-      CommandRunner,
-      {
-        onError: (e) => {
-          thrownError = e;
-        },
-        run: fn
-      }
-    )
-  );
-  await app.waitUntilExit();
-  if (thrownError) throw thrownError;
-}
-var COLORS;
-var init_ink = __esm({
-  "cli/_ink.tsx"() {
-    "use strict";
-    if (chalk.level === 0 && !process.env.NO_COLOR) {
-      const ct = process.env.COLORTERM;
-      if (ct === "truecolor" || ct === "24bit") {
-        chalk.level = 3;
-      } else if (ct || /-256(color)?$/i.test(process.env.TERM ?? "")) {
-        chalk.level = 2;
-      } else if (process.env.TERM_PROGRAM) {
-        chalk.level = 1;
-      }
-    }
-    COLORS = {
-      primary: "#fab283",
-      interactive: "#56b6c2",
-      error: "#e06c75",
-      warning: "#f5a742",
-      success: "#7fd88f",
-      accent: "#9d7cd8",
-      muted: "#808080"
-    };
-  }
-});
-
-// cli/_prompts.tsx
-import { ConfirmInput, PasswordInput, Select, TextInput } from "@inkjs/ui";
-import { Box as Box2, render as render2, Text as Text2 } from "ink";
-import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
-function inkPrompt(ui) {
-  return new Promise((resolve) => {
-    const app = render2(
-      ui((value) => {
-        resolve(value);
-        app.unmount();
-      })
-    );
-  });
-}
-function askPassword(message) {
-  return inkPrompt((done) => /* @__PURE__ */ jsxs2(Box2, { children: [
-    /* @__PURE__ */ jsxs2(Text2, { children: [
-      message,
-      ": "
-    ] }),
-    /* @__PURE__ */ jsx2(PasswordInput, { onSubmit: done })
-  ] }));
-}
-function askText(message, defaultValue) {
-  return inkPrompt((done) => /* @__PURE__ */ jsxs2(Box2, { children: [
-    /* @__PURE__ */ jsxs2(Text2, { color: COLORS.interactive, children: [
-      message,
-      " \u203A "
-    ] }),
-    /* @__PURE__ */ jsx2(TextInput, { placeholder: defaultValue, onSubmit: (value) => done(value || defaultValue) })
-  ] }));
-}
-var init_prompts = __esm({
-  "cli/_prompts.tsx"() {
-    "use strict";
-    init_ink();
-  }
-});
-
-// cli/_discover.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-import { humanId } from "human-id";
-function resolveCwd() {
-  return process.env.INIT_CWD || process.cwd();
-}
-function isDevMode(script) {
-  script ??= process.argv[1] ?? "";
-  return script.endsWith(".ts") || script.endsWith(".tsx");
-}
-function generateSlug() {
-  return humanId({ separator: "-", capitalize: false });
-}
-async function readAuthConfig() {
-  try {
-    return JSON.parse(await fs.readFile(CONFIG_FILE, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-async function writeAuthConfig(config) {
-  await fs.mkdir(CONFIG_DIR, { recursive: true });
-  await fs.writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
-`);
-  if (process.platform !== "win32") {
-    await fs.chmod(CONFIG_FILE, 384);
-  }
-}
-async function getApiKey() {
-  const config = await readAuthConfig();
-  if (config.assemblyai_api_key) {
-    process.env.ASSEMBLYAI_API_KEY = config.assemblyai_api_key;
-    return config.assemblyai_api_key;
-  }
-  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 fs.readFile(path.join(agentDir, ".aai", "project.json"), "utf-8"));
-  } catch {
-    return null;
-  }
-}
-async function writeProjectConfig(agentDir, data) {
-  const aaiDir = path.join(agentDir, ".aai");
-  await fs.mkdir(aaiDir, { recursive: true });
-  await fs.writeFile(path.join(aaiDir, "project.json"), `${JSON.stringify(data, null, 2)}
-`);
-}
-async function getServerInfo(cwd, explicitServer, explicitApiKey) {
-  const config = await readProjectConfig(cwd);
-  if (!config) {
-    throw new Error("No .aai/project.json found \u2014 deploy first with `aai deploy`");
-  }
-  const apiKey = explicitApiKey ?? await getApiKey();
-  const serverUrl = resolveServerUrl(explicitServer, config.serverUrl);
-  return { serverUrl, slug: config.slug, apiKey };
-}
-function resolveServerUrl(explicit, configUrl) {
-  return explicit || configUrl || (isDevMode() ? "http://localhost:3100" : DEFAULT_SERVER);
-}
-async function fileExists(p) {
-  try {
-    await fs.access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function loadAgent(dir) {
-  const hasAgentTs = await fileExists(path.join(dir, "agent.ts"));
-  if (!hasAgentTs) return null;
-  const config = await readProjectConfig(dir);
-  const slug = config?.slug ?? generateSlug();
-  const clientEntry = await fileExists(path.join(dir, "client.tsx")) ? path.join(dir, "client.tsx") : "";
-  return {
-    slug,
-    dir,
-    entryPoint: path.join(dir, "agent.ts"),
-    clientEntry
-  };
-}
-var CONFIG_DIR, CONFIG_FILE, DEFAULT_SERVER;
-var init_discover = __esm({
-  "cli/_discover.ts"() {
-    "use strict";
-    init_prompts();
-    CONFIG_DIR = path.join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "aai");
-    CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-    DEFAULT_SERVER = "https://aai-agent.fly.dev";
-  }
-});
-
-// cli/_init.ts
-var init_exports = {};
-__export(init_exports, {
-  listTemplates: () => listTemplates,
-  runInit: () => runInit
-});
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
-async function listTemplates(dir) {
-  const templates = [];
-  const entries = await fs2.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.isDirectory() && !entry.name.startsWith("_")) {
-      templates.push(entry.name);
-    }
-  }
-  return templates.sort();
-}
-async function copyDirNoOverwrite(src, dest) {
-  const entries = await fs2.readdir(src, { recursive: true, withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    const rel = path2.relative(src, path2.join(entry.parentPath, entry.name));
-    const destPath = path2.join(dest, rel);
-    await fs2.mkdir(path2.dirname(destPath), { recursive: true });
-    try {
-      await fs2.copyFile(path2.join(src, rel), destPath, fs2.constants.COPYFILE_EXCL);
-    } catch (err) {
-      if (err.code !== "EEXIST") throw err;
-    }
-  }
-}
-async function runInit(opts) {
-  const { targetDir, template, templatesDir } = opts;
-  const available = await listTemplates(templatesDir);
-  if (!available.includes(template)) {
-    throw new Error(`unknown template '${template}' -- available: ${available.join(", ")}`);
-  }
-  await fs2.cp(path2.join(templatesDir, template), targetDir, { recursive: true, force: true });
-  await copyDirNoOverwrite(path2.join(templatesDir, "_shared"), targetDir);
-  try {
-    await fs2.copyFile(path2.join(targetDir, ".env.example"), path2.join(targetDir, ".env"));
-  } catch {
-  }
-  const readmePath = path2.join(targetDir, "README.md");
-  const slug = path2.basename(path2.resolve(targetDir));
-  const readme = `# ${slug}
-
-A voice agent built with [aai](https://github.com/anthropics/aai).
-
-## Getting started
-
-\`\`\`sh
-npm install        # Install dependencies
-npm run dev        # Run locally (opens browser)
-npm run deploy     # Deploy to production
-\`\`\`
-
-## Environment variables
-
-Secrets are managed on the server, not in local files:
-
-\`\`\`sh
-aai env add MY_KEY # Set a secret (prompts for value)
-aai env ls         # List secret names
-aai env pull       # Pull names into .env for reference
-aai env rm MY_KEY  # Remove a secret
-\`\`\`
-
-Access secrets in your agent via \`ctx.env.MY_KEY\`.
-
-## Learn more
-
-See \`CLAUDE.md\` for the full agent API reference.
-`;
-  try {
-    await fs2.writeFile(readmePath, readme, { flag: "wx" });
-  } catch (err) {
-    if (err.code !== "EEXIST") throw err;
-  }
-  return targetDir;
-}
-var init_init = __esm({
-  "cli/_init.ts"() {
-    "use strict";
-  }
-});
-
-// cli/_bundler.ts
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
-import preact from "@preact/preset-vite";
-import tailwindcss from "@tailwindcss/vite";
-import { build } from "vite";
-function workerEntryPlugin() {
-  const virtualId = "virtual:worker-entry";
-  const resolvedId = `\0${virtualId}`;
-  return {
-    name: "aai-worker-entry",
-    resolveId(source) {
-      return source === virtualId ? resolvedId : null;
-    },
-    load(id) {
-      if (id !== resolvedId) return null;
-      return [
-        `import agent from "./agent.ts";`,
-        `import { initWorker } from "@alexkroman1/aai/worker-shim";`,
-        `initWorker(agent);`
-      ].join("\n");
-    }
-  };
-}
-async function readDirFiles(dir) {
-  let entries;
-  try {
-    entries = await fs3.readdir(dir, { recursive: true, withFileTypes: true });
-  } catch {
-    return {};
-  }
-  const files = {};
-  await Promise.all(
-    entries.filter((e) => e.isFile()).map(async (e) => {
-      const full = path3.join(e.parentPath, e.name);
-      files[path3.relative(dir, full)] = await fs3.readFile(full, "utf-8");
-    })
-  );
-  return files;
-}
-async function bundleAgent(agent, opts) {
-  const aaiDir = path3.join(agent.dir, ".aai");
-  const buildDir = path3.join(aaiDir, "build");
-  const clientDir = path3.join(aaiDir, "client");
-  const devMode = isDevMode();
-  const devResolve = devMode ? { conditions: ["source"] } : {};
-  try {
-    await build({
-      configFile: false,
-      root: agent.dir,
-      logLevel: "warn",
-      plugins: [workerEntryPlugin()],
-      resolve: devResolve,
-      build: {
-        rollupOptions: {
-          input: "virtual:worker-entry",
-          output: { format: "es", entryFileNames: "worker.js" }
-        },
-        outDir: buildDir,
-        emptyOutDir: true,
-        minify: true,
-        target: "es2022"
-      }
-    });
-  } catch (err) {
-    throw new BundleError(errorMessage(err));
-  }
-  const skipClient = opts?.skipClient || !agent.clientEntry;
-  if (!skipClient) {
-    try {
-      await build({
-        root: agent.dir,
-        base: "./",
-        logLevel: "warn",
-        plugins: [preact(), tailwindcss()],
-        resolve: {
-          ...devResolve,
-          ...devMode && { dedupe: ["preact", "@preact/signals"] }
-        },
-        build: {
-          outDir: clientDir,
-          emptyOutDir: true,
-          minify: true,
-          target: "es2022"
-        }
-      });
-    } catch (err) {
-      throw new BundleError(errorMessage(err));
-    }
-  }
-  const worker = await fs3.readFile(path3.join(buildDir, "worker.js"), "utf-8");
-  const clientFiles = await readDirFiles(clientDir);
-  return {
-    worker,
-    clientFiles,
-    clientDir,
-    workerBytes: Buffer.byteLength(worker)
-  };
-}
-var BundleError;
-var init_bundler = __esm({
-  "cli/_bundler.ts"() {
-    "use strict";
-    init_utils();
-    init_discover();
-    BundleError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "BundleError";
-      }
-    };
-  }
-});
-
-// cli/_build.tsx
-var build_exports = {};
-__export(build_exports, {
-  buildAgentBundle: () => buildAgentBundle,
-  runBuildCommand: () => runBuildCommand
-});
-import { jsx as jsx3 } from "react/jsx-runtime";
-async function buildAgentBundle(cwd, log, opts) {
-  const agent = await loadAgent(cwd);
-  if (!agent) {
-    throw new Error("No agent found \u2014 run `aai init` first");
-  }
-  log(/* @__PURE__ */ jsx3(Step, { action: "Bundle", msg: agent.slug }));
-  let bundle;
-  try {
-    bundle = await bundleAgent(agent);
-  } catch (err) {
-    if (err instanceof BundleError) {
-      throw new Error(`Bundle failed: ${err.message}`);
-    }
-    throw err;
-  }
-  const kb = (bundle.workerBytes / 1024).toFixed(1);
-  const clientCount = Object.keys(bundle.clientFiles).length;
-  log(/* @__PURE__ */ jsx3(Info, { msg: `worker: ${kb} KB, client: ${clientCount} file(s)` }));
-  if (agent.clientEntry && !opts?.skipRenderCheck) {
-    const renderCheckPath = "../ui/_render_check.ts";
-    const mod = await import(
-      /* @vite-ignore */
-      renderCheckPath
-    ).catch(() => null);
-    if (mod) {
-      log(/* @__PURE__ */ jsx3(Step, { action: "Render", msg: "check" }));
-      try {
-        await mod.renderCheck(agent.clientEntry, cwd);
-      } catch (err) {
-        throw new Error(`Render check failed: ${errorMessage(err)}`);
-      }
-    }
-  }
-  return bundle;
-}
-async function runBuildCommand(cwd) {
-  await runWithInk(async ({ log }) => {
-    await buildAgentBundle(cwd, log);
-    log(/* @__PURE__ */ jsx3(Step, { action: "Build", msg: "ok" }));
-  });
-}
-var init_build = __esm({
-  "cli/_build.tsx"() {
-    "use strict";
-    init_utils();
-    init_bundler();
-    init_discover();
-    init_ink();
-  }
-});
-
-// cli/_deploy.ts
-async function attemptDeploy(fetchFn, url, slug, apiKey, env, worker, clientFiles) {
-  try {
-    return await fetchFn(`${url}/${slug}/deploy`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        env,
-        worker,
-        clientFiles
-      })
-    });
-  } catch {
-    throw new Error(`deployment failed: could not reach ${url}`);
-  }
-}
-async function runDeploy(opts) {
-  const { worker, clientFiles } = opts.bundle;
-  const fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
-  let slug = opts.slug;
-  for (let i = 0; i < MAX_RETRIES; i++) {
-    const resp = await attemptDeploy(
-      fetchFn,
-      opts.url,
-      slug,
-      opts.apiKey,
-      opts.env,
-      worker,
-      clientFiles
-    );
-    if (resp.ok) {
-      return { slug };
-    }
-    const text = await resp.text();
-    if (resp.status === 403 && text.includes("Slug")) {
-      slug = generateSlug();
-      continue;
-    }
-    throw new Error(`deploy failed (${resp.status}): ${text}`);
-  }
-  throw new Error(`deploy failed: could not find available slug after ${MAX_RETRIES} attempts`);
-}
-var MAX_RETRIES;
-var init_deploy = __esm({
-  "cli/_deploy.ts"() {
-    "use strict";
-    init_discover();
-    MAX_RETRIES = 20;
-  }
-});
-
-// cli/deploy.tsx
-var deploy_exports = {};
-__export(deploy_exports, {
-  runDeployCommand: () => runDeployCommand
-});
-import { jsx as jsx4 } from "react/jsx-runtime";
-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,
-    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(opts) {
-  const { cwd } = opts;
-  const dryRun = opts.dryRun ?? false;
-  const apiKey = dryRun ? "" : await getApiKey();
-  const projectConfig = await readProjectConfig(cwd);
-  const serverUrl = resolveServerUrl(opts.server, projectConfig?.serverUrl);
-  const slug = projectConfig?.slug ?? generateSlug();
-  await runWithInk(async ({ log }) => {
-    const bundle = await buildAgentBundle(cwd, log);
-    if (dryRun) {
-      log(/* @__PURE__ */ jsx4(StepInfo, { action: "Dry run", msg: `would deploy as ${slug}` }));
-      return;
-    }
-    await deployBundle({ bundle, serverUrl, apiKey, slug, cwd, log });
-  });
-}
-var init_deploy2 = __esm({
-  "cli/deploy.tsx"() {
-    "use strict";
-    init_build();
-    init_deploy();
-    init_discover();
-    init_ink();
-  }
-});
-
-// cli/init.tsx
-var init_exports2 = {};
-__export(init_exports2, {
-  runInitCommand: () => runInitCommand
-});
-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 { jsx as jsx5 } 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__ */ jsx5(Step, { action: "Install", msg: deps.join(", ") }));
-  }
-  if (devDeps.length > 0) {
-    log(/* @__PURE__ */ jsx5(Step, { action: "Install", msg: `dev: ${devDeps.join(", ")}` }));
-  }
-  try {
-    await execFileAsync("npm", ["install"], { cwd });
-  } catch {
-    log(/* @__PURE__ */ jsx5(Warn, { msg: "npm install failed" }));
-  }
-}
-async function runInitCommand(opts, extra) {
-  await getApiKey();
-  let dir = opts.dir;
-  if (!dir) {
-    dir = await askText("What is your project named?", "my-voice-agent");
-  }
-  const cwd = path4.resolve(resolveCwd(), dir);
-  if (!opts.force && await fileExists(path4.join(cwd, "agent.ts"))) {
-    throw new Error(
-      `agent.ts already exists in this directory. Use ${interactive("--force")} to overwrite.`
-    );
-  }
-  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 = opts.template || "simple";
-  await runWithInk(async ({ log }) => {
-    log(/* @__PURE__ */ jsx5(Step, { action: "Create", msg: dir }));
-    await runInit2({ targetDir: cwd, template, templatesDir });
-    if (isDevMode()) {
-      await rewriteDevDeps(cwd, cliDir2);
-    }
-    await installDeps(cwd, log);
-  });
-  process.chdir(cwd);
-  delete process.env.INIT_CWD;
-  if (!extra?.quiet) {
-    const { runDeployCommand: runDeployCommand2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
-    await runDeployCommand2({ cwd });
-  }
-  return cwd;
-}
-var execFileAsync;
-var init_init2 = __esm({
-  "cli/init.tsx"() {
-    "use strict";
-    init_discover();
-    init_ink();
-    init_prompts();
-    execFileAsync = promisify(execFile);
-  }
-});
-
-// sdk/protocol.ts
-import { z } from "zod";
-var DEFAULT_TTS_SAMPLE_RATE, AUDIO_FORMAT, KvRequestSchema, VectorRequestSchema, HOOK_TIMEOUT_MS, TOOL_EXECUTION_TIMEOUT_MS, SessionErrorCodeSchema, ev, textEv, turnOrder, ClientEventSchema, ClientMessageSchema;
-var init_protocol = __esm({
-  "sdk/protocol.ts"() {
-    "use strict";
-    DEFAULT_TTS_SAMPLE_RATE = 24e3;
-    AUDIO_FORMAT = "pcm16";
-    KvRequestSchema = 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()
-      }),
-      z.object({ op: z.literal("keys"), pattern: z.string().optional() })
-    ]);
-    VectorRequestSchema = z.discriminatedUnion("op", [
-      z.object({
-        op: z.literal("upsert"),
-        id: z.string().min(1),
-        data: z.string().min(1),
-        metadata: z.record(z.string(), z.unknown()).optional()
-      }),
-      z.object({
-        op: z.literal("query"),
-        text: z.string().min(1),
-        topK: z.number().int().positive().max(100).optional(),
-        filter: z.string().optional()
-      }),
-      z.object({
-        op: z.literal("remove"),
-        ids: z.array(z.string().min(1)).min(1)
-      })
-    ]);
-    HOOK_TIMEOUT_MS = 5e3;
-    TOOL_EXECUTION_TIMEOUT_MS = 3e4;
-    SessionErrorCodeSchema = z.enum([
-      "stt",
-      "llm",
-      "tts",
-      "tool",
-      "protocol",
-      "connection",
-      "audio",
-      "internal"
-    ]);
-    ev = (t) => z.object({ type: z.literal(t) });
-    textEv = (t) => z.object({ type: z.literal(t), text: z.string() });
-    turnOrder = z.number().int().nonnegative().optional();
-    ClientEventSchema = z.discriminatedUnion("type", [
-      ev("speech_started"),
-      ev("speech_stopped"),
-      z.object({ type: z.literal("transcript"), text: z.string(), isFinal: z.boolean(), turnOrder }),
-      textEv("turn").extend({ turnOrder }),
-      textEv("chat"),
-      textEv("chat_delta"),
-      z.object({
-        type: z.literal("tool_call_start"),
-        toolCallId: z.string(),
-        toolName: z.string(),
-        args: z.record(z.string(), z.unknown())
-      }),
-      z.object({
-        type: z.literal("tool_call_done"),
-        toolCallId: z.string(),
-        result: z.string().max(4e3)
-      }),
-      ev("tts_done"),
-      ev("cancelled"),
-      ev("reset"),
-      z.object({ type: z.literal("error"), code: SessionErrorCodeSchema, message: z.string() })
-    ]);
-    ClientMessageSchema = z.discriminatedUnion("type", [
-      ev("audio_ready"),
-      ev("cancel"),
-      ev("reset"),
-      z.object({
-        type: z.literal("history"),
-        messages: z.array(z.object({ role: z.enum(["user", "assistant"]), text: z.string().max(1e5) })).max(200)
-      })
-    ]);
-  }
-});
-
-// sdk/runtime.ts
-var _log, consoleLogger, noopMetrics, DEFAULT_S2S_CONFIG;
-var init_runtime = __esm({
-  "sdk/runtime.ts"() {
-    "use strict";
-    init_protocol();
-    _log = (m) => (msg, ctx) => console[m](msg, ...ctx ? [ctx] : []);
-    consoleLogger = {
-      info: _log("log"),
-      warn: _log("warn"),
-      error: _log("error"),
-      debug: _log("debug")
-    };
-    noopMetrics = {
-      sessionsTotal: { inc() {
-      } },
-      sessionsActive: { inc() {
-      }, dec() {
-      } }
-    };
-    DEFAULT_S2S_CONFIG = {
-      wssUrl: "wss://speech-to-speech.us.assemblyai.com/v1/realtime",
-      inputSampleRate: DEFAULT_TTS_SAMPLE_RATE,
-      outputSampleRate: DEFAULT_TTS_SAMPLE_RATE
-    };
-  }
-});
-
-// sdk/s2s.ts
-var s2s_exports = {};
-__export(s2s_exports, {
-  connectS2s: () => connectS2s,
-  wrapOnStyleWebSocket: () => wrapOnStyleWebSocket
-});
-import { z as z2 } from "zod";
-function uint8ToBase64(bytes) {
-  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
-}
-function base64ToUint8(base64) {
-  const buf = Buffer.from(base64, "base64");
-  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-function wrapOnStyleWebSocket(ws) {
-  const target = new EventTarget();
-  ws.on("open", () => target.dispatchEvent(new Event("open")));
-  ws.on("message", (data) => target.dispatchEvent(new MessageEvent("message", { data })));
-  ws.on("close", (code, reason) => {
-    const init = { reason: String(reason ?? "") };
-    if (typeof code === "number") init.code = code;
-    target.dispatchEvent(new CloseEvent("close", init));
-  });
-  ws.on(
-    "error",
-    (err) => target.dispatchEvent(
-      new ErrorEvent("error", {
-        message: errorMessage(err)
-      })
-    )
-  );
-  Object.defineProperties(target, {
-    readyState: { get: () => ws.readyState, enumerable: true },
-    send: { value: (data) => ws.send(data), enumerable: true },
-    close: { value: () => ws.close(), enumerable: true }
-  });
-  return target;
-}
-function dispatchS2sMessage(target, msg) {
-  const entry = S2S_DISPATCH[msg.type]?.(msg);
-  if (entry) target.dispatchEvent(new CustomEvent(entry[0], { detail: entry[1] }));
-}
-function connectS2s(opts) {
-  const { apiKey, config, createWebSocket, logger: log = consoleLogger } = opts;
-  return new Promise((resolve, reject) => {
-    log.info("S2S connecting", { url: config.wssUrl });
-    const ws = createWebSocket(config.wssUrl, {
-      headers: { Authorization: `Bearer ${apiKey}` }
-    });
-    const target = new EventTarget();
-    let opened = false;
-    function send(msg) {
-      if (ws.readyState !== WS_OPEN) return;
-      const json = JSON.stringify(msg);
-      if (msg.type !== "input.audio") {
-        log.info(
-          `S2S >> ${msg.type}`,
-          msg.type === "session.update" ? { payload: json } : void 0
-        );
-      }
-      ws.send(json);
-    }
-    const handle = Object.assign(target, {
-      sendAudio(audio) {
-        if (ws.readyState !== WS_OPEN) return;
-        ws.send(`{"type":"input.audio","audio":"${uint8ToBase64(audio)}"}`);
-      },
-      sendToolResult(callId, result) {
-        const msg = { type: "tool.result", call_id: callId, result };
-        log.info("S2S >> tool.result", { call_id: callId, resultLength: result.length });
-        send(msg);
-      },
-      updateSession(sessionConfig) {
-        send({ type: "session.update", session: sessionConfig });
-      },
-      resumeSession(sessionId) {
-        send({ type: "session.resume", session_id: sessionId });
-      },
-      close() {
-        log.info("S2S closing");
-        ws.close();
-      }
-    });
-    ws.addEventListener("open", () => {
-      opened = true;
-      log.info("S2S WebSocket open");
-      resolve(handle);
-    });
-    function tryParseJson(data) {
-      try {
-        return JSON.parse(String(data));
-      } catch {
-        log.warn("S2S << invalid JSON", { data: String(data).slice(0, 200) });
-        return void 0;
-      }
-    }
-    function handleAudioFastPath(obj) {
-      if (obj.type === "reply.audio" && typeof obj.data === "string") {
-        const audioBytes = base64ToUint8(obj.data);
-        target.dispatchEvent(new CustomEvent("audio", { detail: { audio: audioBytes } }));
-        return true;
-      }
-      return false;
-    }
-    function logIncoming(obj) {
-      if (obj.type === "reply.audio" || obj.type === "input.audio") return;
-      log.info(
-        `S2S << ${obj.type}`,
-        obj.type === "transcript.agent.delta" ? { delta: obj.delta } : void 0
-      );
-    }
-    function handleS2sMessage(ev2) {
-      const raw = tryParseJson(ev2.data);
-      if (raw === void 0) return;
-      const obj = raw;
-      logIncoming(obj);
-      if (handleAudioFastPath(obj)) return;
-      const parsed = S2sServerMessageSchema.safeParse(raw);
-      if (!parsed.success) {
-        log.warn(
-          `S2S << unrecognised message type: ${obj.type ?? JSON.stringify(raw).slice(0, 200)}`
-        );
-        return;
-      }
-      dispatchS2sMessage(target, parsed.data);
-    }
-    ws.addEventListener("message", handleS2sMessage);
-    ws.addEventListener("close", ((ev2) => {
-      log.info("S2S WebSocket closed", {
-        code: ev2.code ?? 0,
-        reason: ev2.reason ?? ""
-      });
-      target.dispatchEvent(new CustomEvent("close"));
-    }));
-    ws.addEventListener("error", ((ev2) => {
-      const message = ev2 instanceof ErrorEvent ? ev2.message : "WebSocket error";
-      const errObj = new Error(message);
-      log.error("S2S WebSocket error", { error: errObj.message });
-      if (!opened) {
-        reject(errObj);
-      } else {
-        target.dispatchEvent(
-          new CustomEvent("error", {
-            detail: { code: "ws_error", message: errObj.message }
-          })
-        );
-      }
-    }));
-  });
-}
-var WS_OPEN, S2sServerMessageSchema, S2S_DISPATCH;
-var init_s2s = __esm({
-  "sdk/s2s.ts"() {
-    "use strict";
-    init_utils();
-    init_runtime();
-    WS_OPEN = 1;
-    S2sServerMessageSchema = z2.discriminatedUnion("type", [
-      z2.object({ type: z2.literal("session.ready"), session_id: z2.string() }),
-      z2.object({ type: z2.literal("session.updated") }).passthrough(),
-      z2.object({ type: z2.literal("input.speech.started") }),
-      z2.object({ type: z2.literal("input.speech.stopped") }),
-      z2.object({ type: z2.literal("transcript.user.delta"), text: z2.string() }),
-      z2.object({
-        type: z2.literal("transcript.user"),
-        item_id: z2.string(),
-        text: z2.string()
-      }),
-      z2.object({ type: z2.literal("reply.started"), reply_id: z2.string() }),
-      // reply.audio is handled on the fast path before Zod.
-      z2.object({ type: z2.literal("transcript.agent.delta"), delta: z2.string() }).passthrough(),
-      z2.object({ type: z2.literal("transcript.agent"), text: z2.string() }),
-      z2.object({ type: z2.literal("reply.content_part.started") }).passthrough(),
-      z2.object({ type: z2.literal("reply.content_part.done") }).passthrough(),
-      z2.object({
-        type: z2.literal("tool.call"),
-        call_id: z2.string(),
-        name: z2.string(),
-        args: z2.record(z2.string(), z2.unknown()).optional().default({})
-      }),
-      z2.object({
-        type: z2.literal("reply.done"),
-        status: z2.string().optional()
-      }),
-      z2.object({
-        type: z2.literal("session.error"),
-        code: z2.string(),
-        message: z2.string()
-      }),
-      // Connection-level error (bare "error" without "session." prefix).
-      z2.object({
-        type: z2.literal("error"),
-        message: z2.string()
-      })
-    ]);
-    S2S_DISPATCH = {
-      "session.ready": (m) => ["ready", { session_id: m.session_id }],
-      "session.updated": (m) => ["session_updated", m],
-      "input.speech.started": () => ["speech_started", void 0],
-      "input.speech.stopped": () => ["speech_stopped", void 0],
-      "transcript.user.delta": (m) => ["user_transcript_delta", { text: m.text }],
-      "transcript.user": (m) => ["user_transcript", { item_id: m.item_id, text: m.text }],
-      "reply.started": (m) => ["reply_started", { reply_id: m.reply_id }],
-      "transcript.agent.delta": (m) => ["agent_transcript_delta", { text: m.delta }],
-      "transcript.agent": (m) => ["agent_transcript", { text: m.text }],
-      "tool.call": (m) => ["tool_call", { call_id: m.call_id, name: m.name, args: m.args }],
-      "reply.done": (m) => ["reply_done", { status: m.status }],
-      "session.error": (m) => [
-        m.code === "session_not_found" || m.code === "session_forbidden" ? "session_expired" : "error",
-        { code: m.code, message: m.message }
-      ],
-      error: (m) => ["error", { code: "connection", message: m.message }],
-      "reply.content_part.started": () => void 0,
-      "reply.content_part.done": () => void 0
-    };
-  }
-});
-
-// sdk/_internal_types.ts
-import { z as z3 } from "zod";
-function agentToolsToSchemas(tools) {
-  return Object.entries(tools).map(([name, def]) => ({
-    name,
-    description: def.description,
-    parameters: z3.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
-  }));
-}
-var EMPTY_PARAMS;
-var init_internal_types = __esm({
-  "sdk/_internal_types.ts"() {
-    "use strict";
-    EMPTY_PARAMS = z3.object({});
-  }
-});
-
-// sdk/types.ts
-function tool(def) {
-  return def;
-}
-var DEFAULT_INSTRUCTIONS;
-var init_types = __esm({
-  "sdk/types.ts"() {
-    "use strict";
-    DEFAULT_INSTRUCTIONS = `You are AAI, a helpful AI assistant.
-
-Voice-First Rules:
-- Optimize for natural speech. Avoid jargon unless central to the answer. Use short, punchy sentences.
-- Never mention "search results," "sources," or "the provided text." Speak as if the knowledge is your own.
-- No visual formatting. Do not say "bullet point," "bold," or "bracketed one." If you need to list items, say "First," "Next," and "Finally."
-- Start with the most important information. No introductory filler.
-- Be concise. Keep answers to 1-3 sentences. For complex topics, provide a high-level summary.
-- Be confident. Avoid hedging phrases like "It seems that" or "I believe."
-- If you don't have enough information, say so directly rather than guessing.
-- Never use exclamation points. Keep your tone calm and conversational.`;
-  }
-});
-
-// sdk/builtin_tools.ts
-import { convert } from "html-to-text";
-import { z as z4 } from "zod";
-function fetchSignal(toolSignal) {
-  return AbortSignal.any([toolSignal, AbortSignal.timeout(FETCH_TIMEOUT_MS)]);
-}
-function htmlToText(html) {
-  return convert(html, { wordwrap: false });
-}
-function createWebSearch(fetchFn = globalThis.fetch) {
-  return {
-    description: "Search the web for current information, facts, news, or answers to questions. Returns a list of results with title, URL, and description. Use this when the user asks about something you don't know, need up-to-date information, or want to verify facts.",
-    parameters: webSearchParams,
-    async execute(args, ctx) {
-      const { query, max_results: maxResults = 5 } = args;
-      const apiKey = ctx.env.BRAVE_API_KEY ?? "";
-      if (!apiKey) {
-        return { error: "BRAVE_API_KEY is not set \u2014 web search unavailable" };
-      }
-      const url = `${BRAVE_SEARCH_URL}?${new URLSearchParams({
-        q: query,
-        count: String(maxResults),
-        text_decorations: "false"
-      })}`;
-      const resp = await fetchFn(url, {
-        headers: { "X-Subscription-Token": apiKey },
-        signal: fetchSignal(ctx.abortSignal)
-      });
-      if (!resp.ok) return [];
-      const raw = await resp.json();
-      const data = BraveSearchResponseSchema.safeParse(raw);
-      if (!data.success) return [];
-      return (data.data.web?.results ?? []).slice(0, maxResults).map((r) => ({
-        title: r.title,
-        url: r.url,
-        description: r.description
-      }));
-    }
-  };
-}
-function createVisitWebpage(fetchFn = globalThis.fetch) {
-  return {
-    description: "Fetch a webpage and return its content as clean text. Use this to read the full content of a URL found via web_search, or any link the user shares. Good for reading articles, documentation, blog posts, or product pages.",
-    parameters: visitWebpageParams,
-    async execute(args, ctx) {
-      const { url } = args;
-      const resp = await fetchFn(url, {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (compatible; VoiceAgent/1.0; +https://github.com/AssemblyAI/aai)",
-          Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
-        },
-        redirect: "follow",
-        signal: fetchSignal(ctx.abortSignal)
-      });
-      if (!resp.ok) {
-        return { error: `Failed to fetch: ${resp.status} ${resp.statusText}`, url };
-      }
-      const htmlContent = await resp.text();
-      const trimmedHtml = htmlContent.length > MAX_HTML_BYTES ? htmlContent.slice(0, MAX_HTML_BYTES) : htmlContent;
-      const text = htmlToText(trimmedHtml);
-      const truncated = text.length > MAX_PAGE_CHARS;
-      const content = truncated ? text.slice(0, MAX_PAGE_CHARS) : text;
-      return {
-        url,
-        content,
-        ...truncated ? { truncated: true, totalChars: text.length } : {}
-      };
-    }
-  };
-}
-function createFetchJson(fetchFn = globalThis.fetch) {
-  return {
-    description: "Call a REST API endpoint via HTTP GET and return the JSON response. Use this to fetch structured data from APIs \u2014 for example, weather data, stock prices, exchange rates, or any public JSON API. Supports custom headers for authenticated APIs.",
-    parameters: fetchJsonParams,
-    async execute(args, ctx) {
-      const { url, headers } = args;
-      const resp = await fetchFn(url, {
-        ...headers && { headers },
-        signal: fetchSignal(ctx.abortSignal)
-      });
-      if (!resp.ok) {
-        return { error: `HTTP ${resp.status} ${resp.statusText}`, url };
-      }
-      try {
-        return await resp.json();
-      } catch {
-        return { error: "Response was not valid JSON", url };
-      }
-    }
-  };
-}
-function createRunCode() {
-  return {
-    description: "Execute JavaScript code in a secure sandbox and return the output. Use this for calculations, data transformations, string manipulation, or any task that benefits from running code. Output is captured from console.log(). No network or filesystem access.",
-    parameters: runCodeParams,
-    async execute(args) {
-      const { code } = args;
-      const output = [];
-      function capture(...captureArgs) {
-        output.push(captureArgs.map(String).join(" "));
-      }
-      const fakeConsole = {
-        log: capture,
-        info: capture,
-        warn: capture,
-        error: capture,
-        debug: capture
-      };
-      const AsyncFunction = Object.getPrototypeOf(async () => {
-      }).constructor;
-      try {
-        const fn = new AsyncFunction("console", code);
-        await Promise.race([
-          fn(fakeConsole),
-          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)";
-      } catch (err) {
-        return { error: errorMessage(err) };
-      }
-    }
-  };
-}
-function createVectorSearch(vectorSearchFn) {
-  return {
-    description: "Search the agent's knowledge base for relevant information. Use this when the user asks a question that might be answered by previously ingested documents or data. Returns the most relevant matches ranked by similarity.",
-    parameters: vectorSearchParams,
-    async execute(args) {
-      const { query, topK = 5 } = args;
-      return vectorSearchFn(query, topK);
-    }
-  };
-}
-function resolveBuiltin(name, opts) {
-  const entry = TOOL_REGISTRY[name];
-  if (!entry) return [];
-  if ("multi" in entry) return Object.entries(entry.multi());
-  if (name === "vector_search" && !opts?.vectorSearch) return [];
-  return [[name, entry.create(opts)]];
-}
-function getBuiltinToolDefs(names, opts) {
-  const defs = {};
-  for (const name of names) {
-    for (const [k, v] of resolveBuiltin(name, opts)) defs[k] = v;
-  }
-  return defs;
-}
-function getBuiltinToolSchemas(names) {
-  return names.flatMap(
-    (name) => resolveBuiltin(name, { vectorSearch: async () => "" }).map(([toolName, def]) => ({
-      name: toolName,
-      description: def.description,
-      parameters: z4.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
-    }))
-  );
-}
-function memoryTools() {
-  return {
-    save_memory: tool({
-      description: "Save a piece of information to persistent memory. Use a descriptive key like 'user:name' or 'project:status'.",
-      parameters: z4.object({
-        key: z4.string().describe("A descriptive key for this memory (e.g. 'user:name', 'preference:color')"),
-        value: z4.string().describe("The information to remember")
-      }),
-      execute: async ({ key, value }, ctx) => {
-        await ctx.kv.set(key, value);
-        return { saved: key };
-      }
-    }),
-    recall_memory: tool({
-      description: "Retrieve a previously saved memory by its key.",
-      parameters: z4.object({
-        key: z4.string().describe("The key to look up")
-      }),
-      execute: async ({ key }, ctx) => {
-        const value = await ctx.kv.get(key);
-        if (value === null) return { found: false, key };
-        return { found: true, key, value };
-      }
-    }),
-    list_memories: tool({
-      description: "List all saved memory keys, optionally filtered by a prefix (e.g. 'user:').",
-      parameters: z4.object({
-        prefix: z4.string().describe("Prefix to filter keys (e.g. 'user:'). Use empty string for all.").optional()
-      }),
-      execute: async ({ prefix }, ctx) => {
-        const entries = await ctx.kv.list(prefix ?? "");
-        return { count: entries.length, keys: entries.map((e) => e.key) };
-      }
-    }),
-    forget_memory: tool({
-      description: "Delete a previously saved memory by its key.",
-      parameters: z4.object({
-        key: z4.string().describe("The key to delete")
-      }),
-      execute: async ({ key }, ctx) => {
-        await ctx.kv.delete(key);
-        return { deleted: key };
-      }
-    })
-  };
-}
-var FETCH_TIMEOUT_MS, RUN_CODE_TIMEOUT, webSearchParams, BRAVE_SEARCH_URL, BraveSearchResponseSchema, MAX_PAGE_CHARS, MAX_HTML_BYTES, visitWebpageParams, fetchJsonParams, runCodeParams, vectorSearchParams, TOOL_REGISTRY;
-var init_builtin_tools = __esm({
-  "sdk/builtin_tools.ts"() {
-    "use strict";
-    init_internal_types();
-    init_utils();
-    init_types();
-    FETCH_TIMEOUT_MS = 15e3;
-    RUN_CODE_TIMEOUT = 5e3;
-    webSearchParams = z4.object({
-      query: z4.string().describe("The search query"),
-      max_results: z4.number().describe("Maximum number of results to return (default 5)").optional()
-    });
-    BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search";
-    BraveSearchResponseSchema = z4.object({
-      web: z4.object({
-        results: z4.array(
-          z4.object({
-            title: z4.string(),
-            url: z4.string(),
-            description: z4.string()
-          })
-        )
-      }).optional()
-    });
-    MAX_PAGE_CHARS = 1e4;
-    MAX_HTML_BYTES = 2e5;
-    visitWebpageParams = z4.object({
-      url: z4.string().describe("The full URL to fetch (e.g., 'https://example.com/page')")
-    });
-    fetchJsonParams = z4.object({
-      url: z4.string().describe("The URL to fetch JSON from"),
-      headers: z4.record(z4.string(), z4.string()).describe("Optional HTTP headers to include in the request").optional()
-    });
-    runCodeParams = z4.object({
-      code: z4.string().describe("JavaScript code to execute. Use console.log() for output.")
-    });
-    vectorSearchParams = z4.object({
-      query: z4.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: z4.number().describe("Maximum results to return (default: 5)").optional()
-    });
-    TOOL_REGISTRY = {
-      web_search: { create: (opts) => createWebSearch(opts?.fetch) },
-      visit_webpage: { create: (opts) => createVisitWebpage(opts?.fetch) },
-      fetch_json: { create: (opts) => createFetchJson(opts?.fetch) },
-      run_code: { create: createRunCode },
-      vector_search: { create: (opts) => createVectorSearch(opts?.vectorSearch ?? (async () => "")) },
-      memory: { multi: memoryTools }
-    };
-  }
-});
-
-// sdk/kv.ts
-function sortAndPaginate(entries, options) {
-  entries.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-  if (options?.reverse) entries.reverse();
-  if (options?.limit && options.limit > 0) {
-    entries.length = Math.min(entries.length, options.limit);
-  }
-  return entries;
-}
-function createMemoryKv() {
-  const store = /* @__PURE__ */ new Map();
-  function isExpired(entry) {
-    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
-  }
-  return {
-    get(key) {
-      const entry = store.get(key);
-      if (!entry || isExpired(entry)) {
-        if (entry) store.delete(key);
-        return Promise.resolve(null);
-      }
-      return Promise.resolve(JSON.parse(entry.raw));
-    },
-    set(key, value, options) {
-      const raw = JSON.stringify(value);
-      if (raw.length > MAX_VALUE_SIZE) {
-        throw new Error(`Value exceeds max size of ${MAX_VALUE_SIZE} bytes`);
-      }
-      const expireIn = options?.expireIn;
-      const entry = { raw };
-      if (expireIn && expireIn > 0) {
-        entry.expiresAt = Date.now() + expireIn;
-      }
-      store.set(key, entry);
-      return Promise.resolve();
-    },
-    delete(key) {
-      store.delete(key);
-      return Promise.resolve();
-    },
-    async list(prefix, options) {
-      const now = Date.now();
-      const entries = [];
-      let i = 0;
-      for (const [key, entry] of store) {
-        if (++i % 500 === 0) await new Promise((r) => setTimeout(r, 0));
-        if (entry.expiresAt && entry.expiresAt <= now) {
-          store.delete(key);
-          continue;
-        }
-        if (key.startsWith(prefix)) {
-          entries.push({ key, value: JSON.parse(entry.raw) });
-        }
-      }
-      return sortAndPaginate(entries, options);
-    }
-  };
-}
-var MAX_VALUE_SIZE;
-var init_kv = __esm({
-  "sdk/kv.ts"() {
-    "use strict";
-    MAX_VALUE_SIZE = 65536;
-  }
-});
-
-// sdk/session.ts
-function createS2sSession(opts) {
-  const {
-    id,
-    agent,
-    client,
-    toolSchemas,
-    apiKey,
-    s2sConfig,
-    executeTool,
-    createWebSocket,
-    hookInvoker,
-    logger: log = consoleLogger,
-    metrics = noopMetrics
-  } = opts;
-  const agentLabel = { agent };
-  const agentConfig = opts.skipGreeting ? { ...opts.agentConfig, greeting: "" } : opts.agentConfig;
-  const hasTools = toolSchemas.length > 0 || (agentConfig.builtinTools?.length ?? 0) > 0;
-  const systemPrompt = buildSystemPrompt(agentConfig, {
-    hasTools,
-    voice: true
-  });
-  const s2sTools = toolSchemas.map((ts) => ({
-    type: "function",
-    name: ts.name,
-    description: ts.description,
-    parameters: ts.parameters
-  }));
-  let s2s = null;
-  const sessionAbort = new AbortController();
-  let toolCallCount = 0;
-  let turnPromise = null;
-  let conversationMessages = [];
-  let pendingTools = [];
-  async function resolveTurnConfig() {
-    if (!hookInvoker) return null;
-    try {
-      return await hookInvoker.resolveTurnConfig(id, HOOK_TIMEOUT_MS);
-    } catch (err) {
-      log.warn("resolveTurnConfig hook failed", { err: errorMessage(err) });
-      return null;
-    }
-  }
-  function invokeHook(hook, arg) {
-    if (!hookInvoker) return;
-    try {
-      const h = hookInvoker[hook];
-      Promise.resolve(h.call(hookInvoker, id, arg, HOOK_TIMEOUT_MS)).catch((err) => {
-        log.warn(`${hook} hook failed`, { err: errorMessage(err) });
-      });
-    } catch (err) {
-      log.warn(`${hook} hook failed`, { err: errorMessage(err) });
-    }
-  }
-  function checkTurnLimits(turnConfig, name) {
-    const maxSteps = turnConfig?.maxSteps ?? agentConfig.maxSteps;
-    toolCallCount++;
-    if (maxSteps !== void 0 && toolCallCount > maxSteps) {
-      log.info("maxSteps exceeded, refusing tool call", { toolCallCount, maxSteps });
-      return "Maximum tool steps reached. Please respond to the user now.";
-    }
-    if (turnConfig?.activeTools && !turnConfig.activeTools.includes(name)) {
-      log.info("Tool filtered by activeTools", { name });
-      return JSON.stringify({ error: `Tool "${name}" is not available at this step.` });
-    }
-    return null;
-  }
-  async function handleToolCall(detail) {
-    const { call_id, name, args: parsedArgs } = detail;
-    client.event({
-      type: "tool_call_start",
-      toolCallId: call_id,
-      toolName: name,
-      args: parsedArgs
-    });
-    const turnConfig = await resolveTurnConfig();
-    const refused = checkTurnLimits(turnConfig, name);
-    if (refused !== null) {
-      pendingTools.push({ call_id, result: refused });
-      client.event({ type: "tool_call_done", toolCallId: call_id, result: refused });
-      return;
-    }
-    invokeHook("onStep", {
-      stepNumber: toolCallCount - 1,
-      toolCalls: [{ toolName: name, args: parsedArgs }],
-      text: ""
-    });
-    log.info("S2S tool call", { tool: name, call_id, args: parsedArgs, agent });
-    let result;
-    try {
-      result = await executeTool(name, parsedArgs, id, conversationMessages);
-    } catch (err) {
-      const msg = errorMessage(err);
-      log.error("Tool execution failed", { tool: name, error: msg });
-      result = JSON.stringify({ error: msg });
-    }
-    log.info("S2S tool result", {
-      tool: name,
-      call_id,
-      resultLength: result.length
-    });
-    pendingTools.push({ call_id, result });
-    client.event({ type: "tool_call_done", toolCallId: call_id, result });
-  }
-  function on(target, event, handler) {
-    target.addEventListener(event, handler);
-  }
-  function setupListeners(handle) {
-    on(handle, "ready", (e) => {
-      log.info("S2S session ready", { session_id: e.detail.session_id });
-    });
-    on(handle, "session_expired", () => {
-      log.info("S2S session expired");
-      handle.close();
-    });
-    for (const type of ["speech_started", "speech_stopped"]) {
-      handle.addEventListener(type, () => client.event({ type }));
-    }
-    on(handle, "user_transcript_delta", (e) => {
-      client.event({ type: "transcript", text: e.detail.text, isFinal: false });
-    });
-    on(handle, "user_transcript", (e) => {
-      const { text } = e.detail;
-      log.info("S2S user transcript", { text });
-      client.event({ type: "transcript", text, isFinal: true });
-      client.event({ type: "turn", text });
-      conversationMessages.push({ role: "user", content: text });
-      invokeHook("onTurn", text);
-    });
-    handle.addEventListener("reply_started", () => {
-      toolCallCount = 0;
-    });
-    on(handle, "audio", (e) => {
-      client.playAudioChunk(e.detail.audio);
-    });
-    on(handle, "agent_transcript_delta", (e) => {
-      client.event({ type: "chat_delta", text: e.detail.text });
-    });
-    on(handle, "agent_transcript", (e) => {
-      const { text } = e.detail;
-      client.event({ type: "chat", text });
-      conversationMessages.push({ role: "assistant", content: text });
-    });
-    on(handle, "tool_call", (e) => {
-      const p = handleToolCall(e.detail).catch((err) => {
-        log.error("Tool call handler failed", { err: errorMessage(err) });
-      });
-      turnPromise = (turnPromise ?? Promise.resolve()).then(() => p);
-    });
-    on(handle, "reply_done", (e) => {
-      if (e.detail.status === "interrupted") {
-        log.info("S2S reply interrupted (barge-in)");
-        pendingTools = [];
-        client.event({ type: "cancelled" });
-      } else if (pendingTools.length > 0) {
-        for (const tool2 of pendingTools) s2s?.sendToolResult(tool2.call_id, tool2.result);
-        pendingTools = [];
-      } else {
-        client.playAudioDone();
-        client.event({ type: "tts_done" });
-      }
-    });
-    on(handle, "error", (e) => {
-      log.error("S2S error", { code: e.detail.code, message: e.detail.message });
-      client.event({ type: "error", code: "internal", message: e.detail.message });
-      handle.close();
-    });
-    handle.addEventListener("close", () => {
-      log.info("S2S closed");
-      s2s = null;
-    });
-  }
-  async function connectAndSetup() {
-    try {
-      const handle = await _internals.connectS2s({
-        apiKey,
-        config: s2sConfig,
-        createWebSocket,
-        logger: log
-      });
-      setupListeners(handle);
-      handle.updateSession({
-        system_prompt: systemPrompt,
-        tools: s2sTools,
-        ...agentConfig.greeting ? { greeting: agentConfig.greeting } : {}
-      });
-      s2s = handle;
-    } catch (err) {
-      const msg = errorMessage(err);
-      log.error("S2S connect failed", { error: msg });
-      client.event({ type: "error", code: "internal", message: msg });
-    }
-  }
-  return {
-    async start() {
-      metrics.sessionsTotal.inc(agentLabel);
-      metrics.sessionsActive.inc(agentLabel);
-      invokeHook("onConnect");
-      await connectAndSetup();
-    },
-    async stop() {
-      if (sessionAbort.signal.aborted) return;
-      sessionAbort.abort();
-      metrics.sessionsActive.dec(agentLabel);
-      if (turnPromise) await turnPromise;
-      s2s?.close();
-      invokeHook("onDisconnect");
-    },
-    onAudio(data) {
-      s2s?.sendAudio(data);
-    },
-    onAudioReady() {
-    },
-    onCancel() {
-      client.event({ type: "cancelled" });
-    },
-    onReset() {
-      conversationMessages = [];
-      toolCallCount = 0;
-      turnPromise = null;
-      pendingTools = [];
-      s2s?.close();
-      client.event({ type: "reset" });
-      connectAndSetup().catch((err) => {
-        log.error("S2S reset reconnect failed", { error: errorMessage(err) });
-      });
-    },
-    onHistory(incoming) {
-      for (const msg of incoming) {
-        conversationMessages.push({ role: msg.role, content: msg.text });
-      }
-    },
-    waitForTurn() {
-      return turnPromise ?? Promise.resolve();
-    }
-  };
-}
-function buildSystemPrompt(config, opts) {
-  const { hasTools } = opts;
-  const agentInstructions = config.instructions && config.instructions !== DEFAULT_INSTRUCTIONS ? `
-
-Agent-Specific Instructions:
-${config.instructions}` : "";
-  const toolPreamble = hasTools ? '\n\nWhen you decide to use a tool, ALWAYS say a brief natural phrase BEFORE the tool call (e.g. "Let me look that up" or "One moment while I check"). This fills silence while the tool executes. Keep preambles to one short sentence.' : "";
-  const today = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric"
-  });
-  return DEFAULT_INSTRUCTIONS + `
-
-Today's date is ${today}.` + agentInstructions + toolPreamble + (opts.voice ? VOICE_RULES : "");
-}
-var _internals, VOICE_RULES;
-var init_session = __esm({
-  "sdk/session.ts"() {
-    "use strict";
-    init_utils();
-    init_protocol();
-    init_runtime();
-    init_s2s();
-    init_types();
-    _internals = {
-      connectS2s
-    };
-    VOICE_RULES = '\n\nCRITICAL OUTPUT RULES \u2014 you MUST follow these for EVERY response:\nYour response will be spoken aloud by a TTS system and displayed as plain text.\n- NEVER use markdown: no **, no *, no _, no #, no `, no [](), no ---\n- NEVER use bullet points (-, *, \u2022) or numbered lists (1., 2.)\n- NEVER use code blocks or inline code\n- NEVER mention tools, search, APIs, or technical failures to the user. If a tool returns no results, just answer naturally without explaining why.\n- Write exactly as you would say it out loud to a friend\n- Use short conversational sentences. To list things, say "First," "Next," "Finally,"\n- Keep responses concise \u2014 1 to 3 sentences max';
-  }
-});
-
-// sdk/vector.ts
-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({
-  "sdk/vector.ts"() {
-    "use strict";
-  }
-});
-
-// sdk/worker_entry.ts
-function buildToolContext(opts) {
-  const { env, state, kv, vector, messages } = opts;
-  return {
-    env: { ...env },
-    abortSignal: AbortSignal.timeout(TOOL_EXECUTION_TIMEOUT_MS),
-    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: tool2 } = options;
-  const schema = tool2.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(tool2.execute(parsed.data, ctx));
-    await yieldTick();
-    if (result == null) return "null";
-    return typeof result === "string" ? result : JSON.stringify(result);
-  } catch (err) {
-    console.warn(`[tool-executor] Tool execution failed: ${name}`, err);
-    return `Error: ${errorMessage(err)}`;
-  }
-}
-var yieldTick;
-var init_worker_entry = __esm({
-  "sdk/worker_entry.ts"() {
-    "use strict";
-    init_internal_types();
-    init_utils();
-    init_protocol();
-    yieldTick = () => new Promise((r) => setTimeout(r, 0));
-  }
-});
-
-// sdk/direct_executor.ts
-function buildAgentConfig(agent) {
-  const config = {
-    name: agent.name,
-    instructions: agent.instructions,
-    greeting: agent.greeting
-  };
-  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 {
-      env: frozenEnv,
-      state: getState(sessionId),
-      get kv() {
-        return kv;
-      },
-      get vector() {
-        return vector;
-      }
-    };
-  }
-  const executeTool = async (name, args, sessionId, messages) => {
-    const tool2 = allTools[name];
-    if (!tool2) return JSON.stringify({ error: `Unknown tool: ${name}` });
-    return executeToolCall(name, args, {
-      tool: tool2,
-      env: frozenEnv,
-      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, 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;
-    }
-  };
-  function createSession(sessionOpts) {
-    if (!createWebSocket) {
-      throw new Error("createWebSocket not provided \u2014 pass it in DirectExecutorOptions");
-    }
-    const apiKey = frozenEnv.ASSEMBLYAI_API_KEY ?? "";
-    return createS2sSession({
-      id: sessionOpts.id,
-      agent: sessionOpts.agent,
-      client: sessionOpts.client,
-      agentConfig,
-      toolSchemas,
-      apiKey,
-      s2sConfig,
-      executeTool,
-      createWebSocket,
-      hookInvoker,
-      skipGreeting: sessionOpts.skipGreeting ?? false,
-      logger,
-      metrics
-    });
-  }
-  return { executeTool, hookInvoker, toolSchemas, createSession };
-}
-var init_direct_executor = __esm({
-  "sdk/direct_executor.ts"() {
-    "use strict";
-    init_internal_types();
-    init_builtin_tools();
-    init_kv();
-    init_runtime();
-    init_session();
-    init_vector();
-    init_worker_entry();
-  }
-});
-
-// sdk/ws_handler.ts
-function createClientSink(ws) {
-  function safeSend(data) {
-    try {
-      if (ws.readyState === 1) ws.send(data);
-    } catch {
-    }
-  }
-  return {
-    get open() {
-      return ws.readyState === 1;
-    },
-    event(e) {
-      safeSend(JSON.stringify(e));
-    },
-    playAudioChunk(chunk) {
-      safeSend(chunk);
-    },
-    playAudioDone() {
-      safeSend(JSON.stringify({ type: "audio_done" }));
-    }
-  };
-}
-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) {
-  if (!isBinaryData(data)) return false;
-  session.onAudio(toUint8Array(data));
-  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 }));
-    session.start().then(() => {
-      log.info("Session ready", { ...ctx, sid });
-    }).catch((err) => {
-      log.error("Session start failed", { ...ctx, sid, error: errorMessage(err) });
-    });
-  }
-  if (ws.readyState === 1) {
-    onOpen();
-  } else {
-    ws.addEventListener("open", onOpen);
-  }
-  ws.addEventListener("message", (event) => {
-    if (!session) return;
-    const { data } = event;
-    if (handleBinaryAudio(data, session)) 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 init_ws_handler = __esm({
-  "sdk/ws_handler.ts"() {
-    "use strict";
-    init_utils();
-    init_protocol();
-    init_runtime();
-  }
-});
-
-// sdk/winterc_server.ts
-import { Hono } from "hono";
-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
-  };
-  const app = new Hono();
-  app.get("/health", (c) => c.json({ status: "ok", name: agent.name }));
-  app.get("/", (c) => {
-    if (clientHtml) {
-      return c.html(clientHtml);
-    }
-    return c.html(
-      `<!DOCTYPE html><html><body><h1>${agent.name}</h1><p>Agent server running.</p></body></html>`
-    );
-  });
-  return {
-    async fetch(request) {
-      return app.fetch(request);
-    },
-    handleWebSocket(ws, wsOpts) {
-      wireSessionSocket(ws, {
-        sessions,
-        createSession: (sid, client) => executor.createSession({
-          id: sid,
-          agent: agent.name,
-          client,
-          skipGreeting: wsOpts?.skipGreeting ?? false
-        }),
-        readyConfig,
-        logger
-      });
-    },
-    async close() {
-      for (const session of sessions.values()) {
-        await session.stop();
-      }
-      sessions.clear();
-    }
-  };
-}
-var init_winterc_server = __esm({
-  "sdk/winterc_server.ts"() {
-    "use strict";
-    init_direct_executor();
-    init_kv();
-    init_protocol();
-    init_runtime();
-    init_vector();
-    init_ws_handler();
-  }
-});
-
-// sdk/server.ts
-var server_exports = {};
-__export(server_exports, {
-  createServer: () => createServer
-});
-import { serve } from "@hono/node-server";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { Hono as Hono2 } from "hono";
-async function loadWsFactory() {
-  try {
-    const mod = await import("ws");
-    const WS = mod.default ?? mod;
-    return (url, opts) => wrapOnStyleWebSocket(new WS(url, { headers: opts.headers }));
-  } catch {
-    throw new Error(
-      "WebSocket factory not provided and `ws` package not found. Install `ws` (`npm install ws`) or pass `createWebSocket` option."
-    );
-  }
-}
-function resolveEnv(env) {
-  return Object.fromEntries(Object.entries(env).filter(([, v]) => v !== void 0));
-}
-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 : {})
-  );
-  let wsFactory = options.createWebSocket ?? null;
-  async function getWsFactory() {
-    if (!wsFactory) {
-      wsFactory = await loadWsFactory();
-    }
-    return wsFactory;
-  }
-  let winterc = null;
-  function getWinterc() {
-    if (!winterc) {
-      winterc = createWintercServer({
-        agent,
-        env,
-        ...kv ? { kv } : {},
-        createWebSocket: wsFactory ?? (() => {
-          throw new Error("WebSocket factory not loaded");
-        }),
-        ...clientHtml !== void 0 ? { clientHtml } : {},
-        logger,
-        s2sConfig
-      });
-    }
-    return winterc;
-  }
-  let serverHandle = null;
-  return {
-    fetch(request) {
-      return getWinterc().fetch(request);
-    },
-    async listen(port = 3e3) {
-      await getWsFactory();
-      const wintercServer = getWinterc();
-      const app = new Hono2();
-      app.onError((err, c) => {
-        logger.error(`${c.req.method} ${new URL(c.req.url).pathname} error: ${err.message}`);
-        return c.json({ error: "Internal Server Error" }, 500);
-      });
-      app.use("/*", async (c, next) => {
-        const start = Date.now();
-        await next();
-        const ms = Date.now() - start;
-        const status = c.res.status;
-        const method = c.req.method;
-        const path8 = new URL(c.req.url).pathname;
-        if (status >= 400) {
-          logger.error(`${method} ${path8} ${status} ${ms}ms`);
-        } else {
-          logger.info(`${method} ${path8} ${status} ${ms}ms`);
-        }
-      });
-      if (clientDir) {
-        app.use("/*", serveStatic({ root: clientDir }));
-      }
-      app.all("/*", (c) => wintercServer.fetch(c.req.raw));
-      const nodeServer = serve({ fetch: app.fetch, port });
-      await new Promise((resolve) => {
-        nodeServer.on("listening", resolve);
-      });
-      try {
-        const wsMod = await import("ws");
-        const wss = new wsMod.WebSocketServer({ noServer: true });
-        nodeServer.on("upgrade", (req, socket, head) => {
-          const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
-          const resume = reqUrl.searchParams.has("resume");
-          logger.info(`WS upgrade ${reqUrl.pathname}${resume ? " (resume)" : ""}`);
-          wss.handleUpgrade(req, socket, head, (ws) => {
-            wintercServer.handleWebSocket(ws, {
-              skipGreeting: resume
-            });
-          });
-        });
-      } catch {
-        logger.warn("ws package not available for Node.js WebSocket upgrade");
-      }
-      serverHandle = {
-        async shutdown() {
-          await new Promise((resolve, reject) => {
-            nodeServer.close((err) => err ? reject(err) : resolve());
-          });
-        }
-      };
-    },
-    async close() {
-      await winterc?.close();
-      await serverHandle?.shutdown();
-    }
-  };
-}
-var init_server = __esm({
-  "sdk/server.ts"() {
-    "use strict";
-    init_runtime();
-    init_s2s();
-    init_winterc_server();
-  }
-});
-
-// cli/_server_common.ts
-import fs5 from "node:fs/promises";
-import path5 from "node:path";
-import { tsImport } from "tsx/esm/api";
-async function loadAgentDef(cwd) {
-  const agentPath = path5.resolve(cwd, "agent.ts");
-  const agentModule = await tsImport(agentPath, cwd);
-  let agentDef = agentModule.default;
-  if (agentDef?.__esModule && agentDef.default) {
-    agentDef = agentDef.default;
-  }
-  if (!agentDef || typeof agentDef !== "object" || !agentDef.name) {
-    throw new Error("agent.ts must export a default agent definition (from defineAgent())");
-  }
-  return agentDef;
-}
-async function resolveServerEnv(baseEnv) {
-  const env = Object.fromEntries(
-    Object.entries(baseEnv ?? process.env).filter((e) => e[1] !== void 0)
-  );
-  if (!env.ASSEMBLYAI_API_KEY) {
-    env.ASSEMBLYAI_API_KEY = await getApiKey();
-  }
-  return env;
-}
-async function bootServer(agentDef, clientDir, env, port) {
-  const { wrapOnStyleWebSocket: wrapOnStyleWebSocket2 } = await Promise.resolve().then(() => (init_s2s(), s2s_exports));
-  const wsMod = await import("ws");
-  const WS = wsMod.default ?? wsMod;
-  const createWebSocket = (url, opts) => wrapOnStyleWebSocket2(new WS(url, { headers: opts.headers }));
-  const clientHtml = await fs5.readFile(path5.join(clientDir, "index.html"), "utf-8");
-  const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-  const server = createServer2({
-    agent: agentDef,
-    clientHtml,
-    clientDir,
-    env,
-    createWebSocket
-  });
-  await server.listen(port);
-}
-var init_server_common = __esm({
-  "cli/_server_common.ts"() {
-    "use strict";
-    init_discover();
-  }
-});
-
-// cli/dev.tsx
-var dev_exports = {};
-__export(dev_exports, {
-  _startDevServer: () => _startDevServer,
-  runDevCommand: () => runDevCommand
-});
-import { jsx as jsx6 } from "react/jsx-runtime";
-async function _startDevServer(cwd, port, log) {
-  const bundle = await buildAgentBundle(cwd, log, { skipRenderCheck: true });
-  const agentDef = await loadAgentDef(cwd);
-  const env = await resolveServerEnv();
-  await bootServer(agentDef, bundle.clientDir, env, port);
-  log(/* @__PURE__ */ jsx6(Step, { action: "Ready", msg: `http://localhost:${port}` }));
-}
-async function runDevCommand(opts) {
-  const port = Number.parseInt(opts.port, 10);
-  await runWithInk(async ({ log }) => {
-    await _startDevServer(opts.cwd, port, log);
-  });
-}
-var init_dev = __esm({
-  "cli/dev.tsx"() {
-    "use strict";
-    init_build();
-    init_ink();
-    init_server_common();
-  }
-});
-
-// cli/start.tsx
-var start_exports = {};
-__export(start_exports, {
-  _startProductionServer: () => _startProductionServer,
-  runStartCommand: () => runStartCommand
-});
-import path6 from "node:path";
-import { jsx as jsx7 } from "react/jsx-runtime";
-async function _startProductionServer(cwd, port, log) {
-  const clientDir = path6.join(cwd, ".aai", "client");
-  log(/* @__PURE__ */ jsx7(Step, { action: "Start", msg: "loading agent" }));
-  const agentDef = await loadAgentDef(cwd);
-  const env = await resolveServerEnv();
-  await bootServer(agentDef, clientDir, env, port);
-  log(/* @__PURE__ */ jsx7(Step, { action: "Ready", msg: `http://localhost:${port}` }));
-}
-async function runStartCommand(opts) {
-  const port = Number.parseInt(opts.port, 10);
-  const buildDir = path6.join(opts.cwd, ".aai", "build");
-  if (!await fileExists(path6.join(buildDir, "worker.js"))) {
-    throw new Error("No build found \u2014 run `aai build` first");
-  }
-  await runWithInk(async ({ log }) => {
-    log(/* @__PURE__ */ jsx7(Step, { action: "Start", msg: `production server on port ${port}` }));
-    await _startProductionServer(opts.cwd, port, log);
-  });
-}
-var init_start = __esm({
-  "cli/start.tsx"() {
-    "use strict";
-    init_discover();
-    init_ink();
-    init_server_common();
-  }
-});
-
-// cli/secret.tsx
-var secret_exports = {};
-__export(secret_exports, {
-  runSecretDelete: () => runSecretDelete,
-  runSecretList: () => runSecretList,
-  runSecretPut: () => runSecretPut
-});
-import { jsx as jsx8 } from "react/jsx-runtime";
-async function apiFetch(cwd, pathSuffix, init) {
-  const { serverUrl, slug, apiKey } = await getServerInfo(cwd);
-  const resp = await fetch(`${serverUrl}/${slug}/secret${pathSuffix}`, {
-    ...init,
-    headers: { Authorization: `Bearer ${apiKey}`, ...init?.headers }
-  });
-  if (!resp.ok) {
-    const text = await resp.text();
-    throw new Error(`Secret operation failed: ${text}`);
-  }
-  return { resp, slug };
-}
-async function runSecretPut(cwd, name) {
-  const value = await askPassword(`Enter value for ${name}`);
-  if (!value) throw new Error("No value provided");
-  await runWithInk(async ({ log }) => {
-    const { slug } = await apiFetch(cwd, "", {
-      method: "PUT",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ [name]: value })
-    });
-    log(/* @__PURE__ */ jsx8(Step, { action: "Set", msg: `${name} for ${slug}` }));
-  });
-}
-async function runSecretDelete(cwd, name) {
-  await runWithInk(async ({ log }) => {
-    const { slug } = await apiFetch(cwd, `/${name}`, { method: "DELETE" });
-    log(/* @__PURE__ */ jsx8(Step, { action: "Deleted", msg: `${name} from ${slug}` }));
-  });
-}
-async function runSecretList(cwd) {
-  await runWithInk(async ({ log }) => {
-    const { resp } = await apiFetch(cwd, "");
-    const { vars } = await resp.json();
-    if (vars.length === 0) {
-      log(/* @__PURE__ */ jsx8(StepInfo, { action: "Secrets", msg: "none set" }));
-    } else {
-      for (const name of vars) {
-        log(/* @__PURE__ */ jsx8(Detail, { msg: name }));
-      }
-    }
-  });
-}
-var init_secret = __esm({
-  "cli/secret.tsx"() {
-    "use strict";
-    init_discover();
-    init_ink();
-    init_prompts();
-  }
-});
-
-// cli/rag.tsx
-var rag_exports = {};
-__export(rag_exports, {
-  chunkPages: () => chunkPages,
-  parsePage: () => parsePage,
-  runRagCommand: () => runRagCommand,
-  slugify: () => slugify,
-  splitPages: () => splitPages,
-  stripNoise: () => stripNoise,
-  upsertChunks: () => upsertChunks
-});
-import { Text as Text3 } from "ink";
-import pLimit from "p-limit";
-import { jsx as jsx9, jsxs as jsxs3 } from "react/jsx-runtime";
-async function runRag(opts) {
-  const { url, apiKey, serverUrl, slug, chunkSize, log, setStatus } = opts;
-  log(/* @__PURE__ */ jsx9(Step, { action: "Fetch", msg: url }));
-  const resp = await fetch(url, {
-    headers: { "User-Agent": "aai-cli/1.0" },
-    redirect: "follow",
-    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS2)
-  });
-  if (!resp.ok) {
-    throw new Error(`Failed to fetch: ${resp.status} ${resp.statusText}`);
-  }
-  const content = await resp.text();
-  if (content.length === 0) {
-    log(/* @__PURE__ */ jsx9(Warn, { msg: "File is empty" }));
-    return;
-  }
-  log(/* @__PURE__ */ jsx9(Info, { msg: `${(content.length / 1024).toFixed(0)} KB` }));
-  const origin = new URL(url).origin;
-  const pages = splitPages(content);
-  log(/* @__PURE__ */ jsx9(Step, { action: "Parse", msg: `${pages.length} pages` }));
-  const { RecursiveChunker } = await import("@chonkiejs/core");
-  const chunker = await RecursiveChunker.create({ chunkSize });
-  const siteSlug = slugify(origin);
-  const allChunks = await chunkPages(pages, chunker, origin, siteSlug);
-  log(/* @__PURE__ */ jsx9(Step, { action: "Chunk", msg: `${allChunks.length} chunks` }));
-  const vectorUrl = `${serverUrl}/${slug}/vector`;
-  log(/* @__PURE__ */ jsx9(Info, { msg: `target: ${vectorUrl}` }));
-  const result = await upsertChunks(allChunks, vectorUrl, apiKey, setStatus);
-  log(/* @__PURE__ */ jsx9(Step, { action: "Done", msg: `${result.upserted} chunks upserted` }));
-  if (result.errors > 0) {
-    log(/* @__PURE__ */ jsx9(Warn, { msg: `${result.errors} failed` }));
-    if (result.lastError) log(/* @__PURE__ */ jsx9(Info, { msg: `last error: ${result.lastError}` }));
-  }
-  log(/* @__PURE__ */ jsx9(Detail, { msg: `Agent: ${slug}` }));
-}
-async function chunkPages(pages, chunker, origin, siteSlug) {
-  const allChunks = [];
-  for (const page of pages) {
-    page.body = stripNoise(page.body);
-    if (!page.body) continue;
-    const raw = await chunker.chunk(page.body);
-    for (const [i, c] of raw.entries()) {
-      const data = page.title ? `${page.title}
-
-${c.text}` : c.text;
-      const id = `${siteSlug}:${slugify(page.title || "page")}:${i}`;
-      allChunks.push({
-        id,
-        data,
-        metadata: {
-          source: origin,
-          ...page.title ? { title: page.title } : {},
-          tokenCount: c.tokenCount
-        }
-      });
-    }
-  }
-  return allChunks;
-}
-async function upsertChunks(chunks, vectorUrl, apiKey, setStatus, fetchFn = globalThis.fetch) {
-  const total = chunks.length;
-  let completed = 0;
-  let upserted = 0;
-  let errors = 0;
-  let lastError = "";
-  const updateStatus = () => {
-    const pct = Math.round(completed / total * 100);
-    setStatus(
-      /* @__PURE__ */ jsxs3(Text3, { children: [
-        "   ",
-        "Upsert ",
-        completed,
-        "/",
-        total,
-        " (",
-        pct,
-        "%)"
-      ] })
-    );
-  };
-  updateStatus();
-  const limit = pLimit(5);
-  await Promise.all(
-    chunks.map(
-      (chunk) => limit(async () => {
-        try {
-          const r = await fetchFn(vectorUrl, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${apiKey}`
-            },
-            body: JSON.stringify({
-              op: "upsert",
-              id: chunk.id,
-              data: chunk.data,
-              metadata: chunk.metadata
-            })
-          });
-          if (!r.ok) {
-            lastError = await r.text();
-            errors++;
-          } else {
-            upserted++;
-          }
-        } catch (err) {
-          lastError = errorMessage(err);
-          errors++;
-        }
-        completed++;
-        updateStatus();
-      })
-    )
-  );
-  setStatus(null);
-  return { upserted, errors, lastError };
-}
-async function runRagCommand(opts) {
-  const { url, cwd } = opts;
-  try {
-    new URL(url);
-  } catch {
-    throw new Error(`Invalid URL: ${url}`);
-  }
-  const { apiKey, serverUrl, slug } = await getServerInfo(cwd, opts.server);
-  const chunkSize = Number.parseInt(opts.chunkSize ?? "512", 10);
-  await runWithInk(async ({ log, setStatus }) => {
-    await runRag({ url, apiKey, serverUrl, slug, chunkSize, log, setStatus });
-  });
-}
-function splitPages(content) {
-  const raw = content.split(/^\*{3,}$/m);
-  const pages = [];
-  for (const section of raw) {
-    const trimmed = section.trim();
-    if (!trimmed) continue;
-    const page = parsePage(trimmed);
-    if (page.body.length > 0) {
-      pages.push(page);
-    }
-  }
-  return pages;
-}
-function parsePage(trimmed) {
-  let title = "";
-  let body = trimmed;
-  const dashIndex = trimmed.search(/^-{3,}$/m);
-  if (dashIndex !== -1) {
-    const frontmatter = trimmed.slice(0, dashIndex);
-    body = trimmed.slice(dashIndex).replace(/^-+$/m, "").trim();
-    const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
-    if (titleMatch) {
-      title = titleMatch[1]?.trim() ?? "";
-    }
-  }
-  if (!title) {
-    const titleLineMatch = body.match(/^#{1,2}\s+title:\s*(.+)$/m);
-    if (titleLineMatch) {
-      title = titleLineMatch[1]?.trim() ?? "";
-      body = body.replace(/^#{1,2}\s+title:\s*.+\n?/m, "").trim();
-    } else {
-      const headingMatch = body.match(/^(#{1,3})\s+(.+)$/m);
-      if (headingMatch) {
-        title = headingMatch[2]?.trim() ?? "";
-      }
-    }
-  }
-  return { title, body };
-}
-function stripNoise(text) {
-  return text.replace(/^(`{3,}|~{3,}).*[\s\S]*?^\1/gm, "").replace(/^(?:[ ]{4,}|\t).+$/gm, "").replace(/`[^`]+`/g, "").replace(/\{\/\*[\s\S]*?\*\/\}/g, "").replace(/<[^>]+>/g, "").replace(/^\s*\}[^}\n]*$/gm, "").replace(/^\s+$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
-}
-function slugify(s) {
-  return s.replace(/^https?:\/\//, "").replace(/^#+\s*/, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 80);
-}
-var FETCH_TIMEOUT_MS2;
-var init_rag = __esm({
-  "cli/rag.tsx"() {
-    "use strict";
-    init_utils();
-    init_discover();
-    init_ink();
-    FETCH_TIMEOUT_MS2 = 6e4;
-  }
-});
-
-// cli/cli.ts
-init_utils();
-init_discover();
-init_ink();
-import { readFileSync } from "node:fs";
-import path7 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import chalk2 from "chalk";
-import { Command } from "commander";
-var cliDir = path7.dirname(fileURLToPath2(import.meta.url));
-var pkgJsonPath = path7.join(cliDir, "..", "package.json");
-var pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-var VERSION = pkgJson.version;
-var banner = [
-  "",
-  `  ${primary(chalk2.bold(" \u2584\u2580\u2588 \u2584\u2580\u2588 \u2588"))}   ${chalk2.dim("Voice agent development kit")}`,
-  `  ${primary(chalk2.bold(" \u2588\u2580\u2588 \u2588\u2580\u2588 \u2588"))}   ${primary(`v${VERSION}`)}`,
-  ""
-].join("\n");
-var gettingStarted = [
-  "",
-  `  ${chalk2.bold(interactive("Getting started"))}`,
-  "",
-  `    ${chalk2.dim("$")} ${primary("aai init")} ${interactive("my-agent")}`,
-  `    ${chalk2.dim("$")} ${primary("cd")} ${interactive("my-agent")}`,
-  `    ${chalk2.dim("$")} ${primary("aai dev")}`,
-  ""
-].join("\n");
-async function ensureAgent(cwd, yes) {
-  if (!await fileExists(path7.join(cwd, "agent.ts"))) {
-    const { runInitCommand: runInitCommand2 } = await Promise.resolve().then(() => (init_init2(), init_exports2));
-    await runInitCommand2({ yes }, { quiet: true });
-  }
-}
-function withCwd(cmd) {
-  return cmd.hook("preAction", (thisCmd) => {
-    thisCmd.setOptionValue("cwd", resolveCwd());
-  });
-}
-function withAgentGuard(cmd) {
-  return cmd.hook("preAction", async (thisCmd) => {
-    await ensureAgent(thisCmd.getOptionValue("cwd"), thisCmd.opts().yes);
-  });
-}
-function withApiKey(cmd) {
-  return cmd.hook("preAction", async () => {
-    await getApiKey();
-  });
-}
-function createProgram() {
-  const program = new Command();
-  program.name("aai").version(VERSION, "-V, --version").addHelpText("before", banner).addHelpText("after", gettingStarted);
-  program.command("init").description("Scaffold a new agent project").argument("[dir]", "Project directory").option("-t, --template <template>", "Template to use").option("-f, --force", "Overwrite existing agent.ts").option("-y, --yes", "Accept defaults (no prompts)").action(
-    async (dir, opts) => {
-      const { runInitCommand: runInitCommand2 } = await Promise.resolve().then(() => (init_init2(), init_exports2));
-      await runInitCommand2({ dir, ...opts });
-    }
-  );
-  withApiKey(
-    withAgentGuard(
-      withCwd(
-        program.command("dev").description("Start a local development server").option("-p, --port <number>", "Port to listen on", "3000").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
-          const { runDevCommand: runDevCommand2 } = await Promise.resolve().then(() => (init_dev(), dev_exports));
-          await runDevCommand2(opts);
-        })
-      )
-    )
-  );
-  withAgentGuard(
-    withCwd(
-      program.command("build").description("Bundle and validate (no server or deploy)").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
-        const { runBuildCommand: runBuildCommand2 } = await Promise.resolve().then(() => (init_build(), build_exports));
-        await runBuildCommand2(opts.cwd);
-      })
-    )
-  );
-  withAgentGuard(
-    withCwd(
-      program.command("deploy").description("Bundle and deploy to production").option("-s, --server <url>", "Server URL").option("--dry-run", "Validate and bundle without deploying").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
-        const { runDeployCommand: runDeployCommand2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
-        await runDeployCommand2(opts);
-      })
-    )
-  );
-  withApiKey(
-    withCwd(
-      program.command("start").description("Start production server from build").option("-p, --port <number>", "Port to listen on", "3000").option("-y, --yes", "Accept defaults (no prompts)").action(async (opts) => {
-        const { runStartCommand: runStartCommand2 } = await Promise.resolve().then(() => (init_start(), start_exports));
-        await runStartCommand2(opts);
-      })
-    )
-  );
-  const secret = program.command("secret").description("Manage secrets").action(() => secret.help());
-  withApiKey(withCwd(secret));
-  secret.command("put").description("Create or update a secret").argument("<name>", "Secret name").action(async (name, _opts, cmd) => {
-    const cwd = cmd.parent?.getOptionValue("cwd");
-    const { runSecretPut: runSecretPut2 } = await Promise.resolve().then(() => (init_secret(), secret_exports));
-    await runSecretPut2(cwd, name);
-  });
-  secret.command("delete").description("Delete a secret").argument("<name>", "Secret name").action(async (name, _opts, cmd) => {
-    const cwd = cmd.parent?.getOptionValue("cwd");
-    const { runSecretDelete: runSecretDelete2 } = await Promise.resolve().then(() => (init_secret(), secret_exports));
-    await runSecretDelete2(cwd, name);
-  });
-  secret.command("list").description("List secret names").action(async (_opts, cmd) => {
-    const cwd = cmd.parent?.getOptionValue("cwd");
-    const { runSecretList: runSecretList2 } = await Promise.resolve().then(() => (init_secret(), secret_exports));
-    await runSecretList2(cwd);
-  });
-  withApiKey(
-    withCwd(
-      program.command("rag").description("Ingest a site's llms-full.txt into the vector store").argument("<url>", "URL to ingest").option("-s, --server <url>", "Server URL").option("--chunk-size <n>", "Max chunk size in tokens", "512").option("-y, --yes", "Accept defaults (no prompts)").action(async (url, opts) => {
-        const { runRagCommand: runRagCommand2 } = await Promise.resolve().then(() => (init_rag(), rag_exports));
-        await runRagCommand2({ url, ...opts });
-      })
-    )
-  );
-  return program;
-}
-async function main(args) {
-  if (args.length === 0) {
-    const { runInitCommand: runInitCommand2 } = await Promise.resolve().then(() => (init_init2(), init_exports2));
-    await runInitCommand2({});
-    return;
-  }
-  const program = createProgram();
-  await program.parseAsync(args, { from: "user" });
-}
-if (process.env.VITEST !== "true") {
-  process.on("SIGINT", () => process.exit(0));
-  main(process.argv.slice(2)).catch((err) => {
-    console.error(errorMessage(err));
-    process.exit(1);
-  });
-}
-export {
-  createProgram,
-  main
-};