@alexkroman1/aai 0.6.1 → 0.7.3

package/dist/cli.js

@@ -65,13 +65,13 @@ __export(new_exports, {
   listTemplates: () => listTemplates,
   runNew: () => runNew
 });
-import fs5 from "node:fs/promises";
+import fs4 from "node:fs/promises";
 import path4 from "node:path";
 import glob from "fast-glob";
 import fsExtra from "fs-extra";
 async function listTemplates(dir) {
   const templates = [];
-  const entries = await fs5.readdir(dir, { withFileTypes: true });
+  const entries = await fs4.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory() && !entry.name.startsWith("_")) {
       templates.push(entry.name);
@@ -84,10 +84,10 @@ async function copyDirNoOverwrite(src, dest) {
   for (const file of files) {
     const destPath = path4.join(dest, file);
     try {
-      await fs5.access(destPath);
+      await fs4.access(destPath);
     } catch {
-      await fs5.mkdir(path4.dirname(destPath), { recursive: true });
-      await fs5.copyFile(path4.join(src, file), destPath);
+      await fs4.mkdir(path4.dirname(destPath), { recursive: true });
+      await fs4.copyFile(path4.join(src, file), destPath);
     }
   }
 }
@@ -101,12 +101,12 @@ async function runNew(opts) {
   await fsExtra.copy(path4.join(templatesDir, template), targetDir, { overwrite: true });
   await copyDirNoOverwrite(path4.join(templatesDir, "_shared"), targetDir);
   try {
-    await fs5.copyFile(path4.join(targetDir, ".env.example"), path4.join(targetDir, ".env"));
+    await fs4.copyFile(path4.join(targetDir, ".env.example"), path4.join(targetDir, ".env"));
   } catch {
   }
   const readmePath = path4.join(targetDir, "README.md");
   try {
-    await fs5.access(readmePath);
+    await fs4.access(readmePath);
   } catch {
     const slug = path4.basename(path4.resolve(targetDir));
     const readme = `# ${slug}
@@ -138,7 +138,7 @@ Access secrets in your agent via \`ctx.env.MY_KEY\`.
 
 See \`CLAUDE.md\` for the full agent API reference.
 `;
-    await fs5.writeFile(readmePath, readme);
+    await fs4.writeFile(readmePath, readme);
   }
   _internals2.step("Done", targetDir);
   return targetDir;
@@ -483,16 +483,16 @@ function getBuiltinToolSchemas(names) {
       {
         name,
         description: def.description,
-        parameters: z3.toJSONSchema(def.parameters ?? EMPTY_PARAMS2)
+        parameters: z3.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
       }
     ];
   });
 }
-var EMPTY_PARAMS2, webSearchParams, BRAVE_SEARCH_URL, BraveSearchResponseSchema, MAX_PAGE_CHARS, MAX_HTML_BYTES, visitWebpageParams, fetchJsonParams, runCodeParams, vectorSearchParams, TOOL_CREATORS;
+var webSearchParams, BRAVE_SEARCH_URL, BraveSearchResponseSchema, MAX_PAGE_CHARS, MAX_HTML_BYTES, visitWebpageParams, fetchJsonParams, runCodeParams, vectorSearchParams, TOOL_CREATORS;
 var init_builtin_tools = __esm({
   "dist/sdk/builtin_tools.js"() {
     "use strict";
-    EMPTY_PARAMS2 = z3.object({});
+    init_internal_types();
     webSearchParams = z3.object({
       query: z3.string().describe("The search query"),
       max_results: z3.number().describe("Maximum number of results to return (default 5)").optional()
@@ -601,6 +601,7 @@ var init_kv = __esm({
 });
 
 // dist/sdk/s2s.js
+import { z as z4 } from "zod";
 function uint8ToBase64(bytes) {
   const CHUNK = 32768;
   const parts = [];
@@ -617,6 +618,73 @@ function base64ToUint8(base64) {
   }
   return bytes;
 }
+function dispatchS2sMessage(target, msg) {
+  switch (msg.type) {
+    case "session.ready":
+      target.dispatchEvent(new CustomEvent("ready", {
+        detail: { session_id: msg.session_id }
+      }));
+      break;
+    case "session.updated":
+      target.dispatchEvent(new CustomEvent("session_updated", { detail: msg }));
+      break;
+    case "input.speech.started":
+      target.dispatchEvent(new CustomEvent("speech_started"));
+      break;
+    case "input.speech.stopped":
+      target.dispatchEvent(new CustomEvent("speech_stopped"));
+      break;
+    case "transcript.user.delta":
+      target.dispatchEvent(new CustomEvent("user_transcript_delta", {
+        detail: { text: msg.text }
+      }));
+      break;
+    case "transcript.user":
+      target.dispatchEvent(new CustomEvent("user_transcript", {
+        detail: {
+          item_id: msg.item_id,
+          text: msg.text
+        }
+      }));
+      break;
+    case "reply.started":
+      target.dispatchEvent(new CustomEvent("reply_started", {
+        detail: { reply_id: msg.reply_id }
+      }));
+      break;
+    case "reply.audio": {
+      const audioBytes = base64ToUint8(msg.data);
+      target.dispatchEvent(new CustomEvent("audio", { detail: { audio: audioBytes } }));
+      break;
+    }
+    case "transcript.agent":
+      target.dispatchEvent(new CustomEvent("agent_transcript", {
+        detail: { text: msg.text }
+      }));
+      break;
+    case "tool.call":
+      target.dispatchEvent(new CustomEvent("tool_call", {
+        detail: {
+          call_id: msg.call_id,
+          name: msg.name,
+          args: msg.args
+        }
+      }));
+      break;
+    case "reply.done":
+      target.dispatchEvent(new CustomEvent("reply_done", {
+        detail: { status: msg.status }
+      }));
+      break;
+    case "session.error": {
+      const isExpired = msg.code === "session_not_found" || msg.code === "session_forbidden";
+      target.dispatchEvent(new CustomEvent(isExpired ? "session_expired" : "error", {
+        detail: { code: msg.code, message: msg.message }
+      }));
+      break;
+    }
+  }
+}
 function connectS2s(opts) {
   const { apiKey, config, createWebSocket, logger: log = consoleLogger } = opts;
   return new Promise((resolve, reject) => {
@@ -629,8 +697,7 @@ function connectS2s(opts) {
     function send(msg) {
       if (ws.readyState !== WS_OPEN)
         return;
-      const type = msg.type;
-      if (type !== "input.audio") {
+      if (msg.type !== "input.audio") {
         log.info(`S2S >> ${JSON.stringify(msg)}`);
       }
       ws.send(JSON.stringify(msg));
@@ -659,86 +726,26 @@ function connectS2s(opts) {
       resolve(handle);
     });
     ws.on("message", (data) => {
-      let msg;
+      let raw;
       try {
-        msg = JSON.parse(String(data));
+        raw = JSON.parse(String(data));
       } catch {
         return;
       }
-      const type = msg.type;
-      if (type !== "reply.audio") {
-        log.info(`S2S << ${JSON.stringify(msg)}`);
+      const parsed = S2sServerMessageSchema.safeParse(raw);
+      if (!parsed.success) {
+        log.info(`S2S << unrecognised message: ${JSON.stringify(raw)}`);
+        return;
       }
-      switch (type) {
-        case "session.ready":
-          target.dispatchEvent(new CustomEvent("ready", {
-            detail: { session_id: msg.session_id }
-          }));
-          break;
-        case "session.updated":
-          target.dispatchEvent(new CustomEvent("session_updated", { detail: msg }));
-          break;
-        case "input.speech.started":
-          target.dispatchEvent(new CustomEvent("speech_started"));
-          break;
-        case "input.speech.stopped":
-          target.dispatchEvent(new CustomEvent("speech_stopped"));
-          break;
-        case "transcript.user.delta":
-          target.dispatchEvent(new CustomEvent("user_transcript_delta", {
-            detail: { text: msg.text }
-          }));
-          break;
-        case "transcript.user":
-          target.dispatchEvent(new CustomEvent("user_transcript", {
-            detail: {
-              item_id: msg.item_id,
-              text: msg.text
-            }
-          }));
-          break;
-        case "reply.started":
-          target.dispatchEvent(new CustomEvent("reply_started", {
-            detail: { reply_id: msg.reply_id }
-          }));
-          break;
-        case "reply.audio": {
-          const audioBytes = base64ToUint8(msg.data);
-          target.dispatchEvent(new CustomEvent("audio", { detail: { audio: audioBytes } }));
-          break;
-        }
-        case "transcript.agent":
-          target.dispatchEvent(new CustomEvent("agent_transcript", {
-            detail: { text: msg.text }
-          }));
-          break;
-        case "tool.call":
-          target.dispatchEvent(new CustomEvent("tool_call", {
-            detail: {
-              call_id: msg.call_id,
-              name: msg.name,
-              args: msg.args ?? {}
-            }
-          }));
-          break;
-        case "reply.done":
-          target.dispatchEvent(new CustomEvent("reply_done", {
-            detail: { status: msg.status ?? void 0 }
-          }));
-          break;
-        case "session.error": {
-          const code = msg.code;
-          const isExpired = code === "session_not_found" || code === "session_forbidden";
-          target.dispatchEvent(new CustomEvent(isExpired ? "session_expired" : "error", {
-            detail: { code, message: msg.message }
-          }));
-          break;
-        }
+      const msg = parsed.data;
+      if (msg.type !== "reply.audio") {
+        log.info(`S2S << ${JSON.stringify(msg)}`);
       }
+      dispatchS2sMessage(target, msg);
     });
     ws.on("close", (code, reason) => {
       log.info("S2S WebSocket closed", {
-        code,
+        code: typeof code === "number" ? code : 0,
         reason: reason instanceof Uint8Array ? new TextDecoder().decode(reason) : String(reason ?? "")
       });
       target.dispatchEvent(new CustomEvent("close"));
@@ -756,21 +763,51 @@ function connectS2s(opts) {
     });
   });
 }
-var WS_OPEN;
+var WS_OPEN, S2sServerMessageSchema;
 var init_s2s = __esm({
   "dist/sdk/s2s.js"() {
     "use strict";
     init_runtime();
     WS_OPEN = 1;
+    S2sServerMessageSchema = z4.discriminatedUnion("type", [
+      z4.object({ type: z4.literal("session.ready"), session_id: z4.string() }),
+      z4.object({ type: z4.literal("session.updated") }).passthrough(),
+      z4.object({ type: z4.literal("input.speech.started") }),
+      z4.object({ type: z4.literal("input.speech.stopped") }),
+      z4.object({ type: z4.literal("transcript.user.delta"), text: z4.string() }),
+      z4.object({
+        type: z4.literal("transcript.user"),
+        item_id: z4.string(),
+        text: z4.string()
+      }),
+      z4.object({ type: z4.literal("reply.started"), reply_id: z4.string() }),
+      z4.object({ type: z4.literal("reply.audio"), data: z4.string() }),
+      z4.object({ type: z4.literal("transcript.agent"), text: z4.string() }),
+      z4.object({
+        type: z4.literal("tool.call"),
+        call_id: z4.string(),
+        name: z4.string(),
+        args: z4.record(z4.string(), z4.unknown()).optional().default({})
+      }),
+      z4.object({
+        type: z4.literal("reply.done"),
+        status: z4.string().optional()
+      }),
+      z4.object({
+        type: z4.literal("session.error"),
+        code: z4.string(),
+        message: z4.string()
+      })
+    ]);
   }
 });
 
 // dist/sdk/types.js
-var DEFAULT_INSTRUCTIONS2;
+var DEFAULT_INSTRUCTIONS;
 var init_types = __esm({
   "dist/sdk/types.js"() {
     "use strict";
-    DEFAULT_INSTRUCTIONS2 = `You are AAI, a helpful AI assistant.
+    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.
@@ -787,7 +824,7 @@ Voice-First Rules:
 // dist/sdk/system_prompt.js
 function buildSystemPrompt(config, opts) {
   const { hasTools } = opts;
-  const agentInstructions = config.instructions ? `
+  const agentInstructions = config.instructions && config.instructions !== DEFAULT_INSTRUCTIONS ? `
 
 Agent-Specific Instructions:
 ${config.instructions}` : "";
@@ -798,7 +835,7 @@ ${config.instructions}` : "";
     month: "long",
     day: "numeric"
   });
-  return DEFAULT_INSTRUCTIONS2 + `
+  return DEFAULT_INSTRUCTIONS + `
 
 Today's date is ${today}.` + agentInstructions + toolPreamble + (opts?.voice ? VOICE_RULES : "");
 }
@@ -844,10 +881,10 @@ function createS2sSession(opts) {
       return null;
     }
   }
-  async function invokeHook(hook, ...args) {
+  function invokeHook(hook, arg) {
     if (!hookInvoker)
       return;
-    try {
+    const run = async () => {
       switch (hook) {
         case "onConnect":
           await hookInvoker.onConnect(id, HOOK_TIMEOUT_MS);
@@ -856,20 +893,21 @@ function createS2sSession(opts) {
           await hookInvoker.onDisconnect(id, HOOK_TIMEOUT_MS);
           break;
         case "onTurn":
-          await hookInvoker.onTurn(id, args[0], HOOK_TIMEOUT_MS);
+          await hookInvoker.onTurn(id, arg, HOOK_TIMEOUT_MS);
           break;
         case "onError":
-          await hookInvoker.onError(id, args[0], HOOK_TIMEOUT_MS);
+          await hookInvoker.onError(id, arg, HOOK_TIMEOUT_MS);
           break;
         case "onStep":
-          await hookInvoker.onStep(id, args[0], HOOK_TIMEOUT_MS);
+          await hookInvoker.onStep(id, arg, HOOK_TIMEOUT_MS);
           break;
       }
-    } catch (err) {
+    };
+    run().catch((err) => {
       log.warn(`${hook} hook failed`, {
         err: err instanceof Error ? err.message : String(err)
       });
-    }
+    });
   }
   async function handleToolCall(detail) {
     const { call_id, name, args: parsedArgs } = detail;
@@ -929,6 +967,9 @@ function createS2sSession(opts) {
     pendingTools.push({ call_id, result });
     client.event({ type: "tool_call_done", toolCallId: call_id, result });
   }
+  function on(target, event, handler) {
+    target.addEventListener(event, handler);
+  }
   async function connectAndSetup() {
     try {
       const handle = await _internals3.connectS2s({
@@ -942,54 +983,55 @@ function createS2sSession(opts) {
           session_id: s2sSessionId
         });
         handle.resumeSession(s2sSessionId);
+      } else {
+        handle.updateSession({
+          system_prompt: systemPrompt,
+          tools: s2sTools,
+          ...agentConfig.greeting ? { greeting: agentConfig.greeting } : {}
+        });
       }
-      handle.updateSession({
-        system_prompt: systemPrompt,
-        tools: s2sTools,
-        ...agentConfig.greeting ? { greeting: agentConfig.greeting } : {}
-      });
-      handle.addEventListener("ready", ((e) => {
+      on(handle, "ready", (e) => {
         s2sSessionId = e.detail.session_id;
         log.info("S2S session ready", { session_id: s2sSessionId });
-      }));
-      handle.addEventListener("session_expired", (() => {
+      });
+      on(handle, "session_expired", () => {
         log.info("S2S session expired, reconnecting fresh");
         s2sSessionId = null;
         handle.close();
-      }));
+      });
       handle.addEventListener("speech_started", () => {
         client.event({ type: "speech_started" });
       });
       handle.addEventListener("speech_stopped", () => {
         client.event({ type: "speech_stopped" });
       });
-      handle.addEventListener("user_transcript_delta", ((e) => {
+      on(handle, "user_transcript_delta", (e) => {
         client.event({
           type: "transcript",
           text: e.detail.text,
           isFinal: false
         });
-      }));
-      handle.addEventListener("user_transcript", ((e) => {
+      });
+      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;
       });
-      handle.addEventListener("audio", ((e) => {
+      on(handle, "audio", (e) => {
         client.playAudioChunk(e.detail.audio);
-      }));
-      handle.addEventListener("agent_transcript", ((e) => {
+      });
+      on(handle, "agent_transcript", (e) => {
         const { text } = e.detail;
         client.event({ type: "chat", text });
         conversationMessages.push({ role: "assistant", content: text });
-      }));
-      handle.addEventListener("tool_call", ((e) => {
+      });
+      on(handle, "tool_call", (e) => {
         const p = handleToolCall(e.detail).catch((err) => {
           log.error("Tool call handler failed", {
             err: err instanceof Error ? err.message : String(err)
@@ -999,25 +1041,23 @@ function createS2sSession(opts) {
         turnPromise = (prev ?? Promise.resolve()).then(() => p).finally(() => {
           turnPromise = null;
         });
-      }));
-      handle.addEventListener("reply_done", ((e) => {
+      });
+      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 tool of pendingTools) {
-              s2s?.sendToolResult(tool.call_id, tool.result);
-            }
-            pendingTools = [];
-          } else {
-            client.playAudioDone();
-            client.event({ type: "tts_done" });
+        } else if (pendingTools.length > 0) {
+          for (const tool of pendingTools) {
+            s2s?.sendToolResult(tool.call_id, tool.result);
           }
+          pendingTools = [];
+        } else {
+          client.playAudioDone();
+          client.event({ type: "tts_done" });
         }
-      }));
-      handle.addEventListener("error", ((e) => {
+      });
+      on(handle, "error", (e) => {
         log.error("S2S error", {
           code: e.detail.code,
           message: e.detail.message
@@ -1027,7 +1067,7 @@ function createS2sSession(opts) {
           code: "internal",
           message: e.detail.message
         });
-      }));
+      });
       handle.addEventListener("close", () => {
         log.info("S2S closed");
         s2s = null;
@@ -1106,31 +1146,80 @@ var init_session = __esm({
   }
 });
 
+// dist/sdk/vector.js
+function createMemoryVectorStore() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    upsert(id, data, metadata) {
+      store.set(id, { data, metadata });
+      return Promise.resolve();
+    },
+    query(text, options) {
+      const topK = options?.topK ?? 10;
+      const query = text.toLowerCase();
+      const results = [];
+      for (const [id, entry] of store) {
+        const data = entry.data.toLowerCase();
+        const words = query.split(/\s+/).filter(Boolean);
+        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 Promise.resolve(results.slice(0, topK));
+    },
+    remove(ids) {
+      const idArray = Array.isArray(ids) ? ids : [ids];
+      for (const id of idArray) {
+        store.delete(id);
+      }
+      return Promise.resolve();
+    }
+  };
+}
+var init_vector = __esm({
+  "dist/sdk/vector.js"() {
+    "use strict";
+  }
+});
+
 // dist/sdk/worker_entry.js
-import { z as z4 } from "zod";
+function buildToolContext(opts) {
+  const { env, sessionId, state, kv, vector, messages } = opts;
+  return {
+    sessionId: sessionId ?? "",
+    env: { ...env },
+    abortSignal: AbortSignal.timeout(TOOL_HANDLER_TIMEOUT),
+    state: state ?? {},
+    get kv() {
+      if (!kv)
+        throw new Error("KV not available");
+      return kv;
+    },
+    get vector() {
+      if (!vector)
+        throw new Error("Vector store not available");
+      return vector;
+    },
+    messages: messages ?? []
+  };
+}
 async function executeToolCall(name, args, options) {
-  const { tool, env, sessionId, state, kv, messages } = options;
-  const schema = tool.parameters ?? z4.object({});
+  const { tool } = options;
+  const schema = tool.parameters ?? EMPTY_PARAMS;
   const parsed = schema.safeParse(args);
   if (!parsed.success) {
     const issues = (parsed.error?.issues ?? []).map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join(", ");
     return `Error: Invalid arguments for tool "${name}": ${issues}`;
   }
   try {
-    const abortSignal = AbortSignal.timeout(TOOL_HANDLER_TIMEOUT);
-    const envCopy = { ...env };
-    const ctx = {
-      sessionId: sessionId ?? "",
-      env: envCopy,
-      abortSignal,
-      state: state ?? {},
-      get kv() {
-        if (!kv)
-          throw new Error("KV not available");
-        return kv;
-      },
-      messages: messages ?? []
-    };
+    const ctx = buildToolContext(options);
     const result = await Promise.resolve(tool.execute(parsed.data, ctx));
     if (result == null)
       return "null";
@@ -1148,6 +1237,7 @@ var TOOL_HANDLER_TIMEOUT;
 var init_worker_entry = __esm({
   "dist/sdk/worker_entry.js"() {
     "use strict";
+    init_internal_types();
     TOOL_HANDLER_TIMEOUT = 3e4;
   }
 });
@@ -1173,7 +1263,7 @@ function buildAgentConfig(agent) {
   return config;
 }
 function createDirectExecutor(opts) {
-  const { agent, env, kv = createMemoryKv(), vectorSearch, createWebSocket, logger = consoleLogger, metrics = noopMetrics, s2sConfig = DEFAULT_S2S_CONFIG } = 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 = {
@@ -1198,6 +1288,9 @@ function createDirectExecutor(opts) {
       state: getState(sessionId),
       get kv() {
         return kv;
+      },
+      get vector() {
+        return vector;
       }
     };
   }
@@ -1211,6 +1304,7 @@ function createDirectExecutor(opts) {
       sessionId,
       state: getState(sessionId ?? ""),
       kv,
+      vector,
       messages
     });
   };
@@ -1283,6 +1377,7 @@ var init_direct_executor = __esm({
     init_kv();
     init_runtime();
     init_session();
+    init_vector();
     init_worker_entry();
   }
 });
@@ -1313,6 +1408,64 @@ function createClientSink(ws) {
     }
   };
 }
+function isBinaryData(data) {
+  return globalThis.Buffer?.isBuffer(data) || data instanceof ArrayBuffer || data instanceof Uint8Array;
+}
+function toUint8Array(data) {
+  if (data instanceof Uint8Array)
+    return data;
+  if (data instanceof ArrayBuffer)
+    return new Uint8Array(data);
+  const buf = data;
+  return new Uint8Array(buf.buffer ?? data, buf.byteOffset ?? 0, buf.byteLength);
+}
+function handleBinaryAudio(data, session, log, ctx, sid) {
+  if (!isBinaryData(data))
+    return false;
+  const chunk = toUint8Array(data);
+  if (!isValidAudioChunk(chunk)) {
+    log.warn("Invalid audio chunk, dropping", {
+      ...ctx,
+      sid,
+      bytes: chunk.byteLength,
+      aligned: chunk.byteLength % 2 === 0
+    });
+    return true;
+  }
+  session.onAudio(chunk);
+  return true;
+}
+function handleTextMessage(data, session, log, ctx, sid) {
+  if (typeof data !== "string")
+    return;
+  let json;
+  try {
+    json = JSON.parse(data);
+  } catch {
+    log.warn("Invalid JSON from client", { ...ctx, sid });
+    return;
+  }
+  const parsed = ClientMessageSchema.safeParse(json);
+  if (!parsed.success) {
+    log.warn("Invalid client message", { ...ctx, sid, error: parsed.error.message });
+    return;
+  }
+  const msg = parsed.data;
+  switch (msg.type) {
+    case "audio_ready":
+      session.onAudioReady();
+      break;
+    case "cancel":
+      session.onCancel();
+      break;
+    case "reset":
+      session.onReset();
+      break;
+    case "history":
+      session.onHistory(msg.messages);
+      break;
+  }
+}
 function wireSessionSocket(ws, opts) {
   const { sessions, logger: log = consoleLogger } = opts;
   const sessionId = crypto.randomUUID();
@@ -1337,56 +1490,10 @@ function wireSessionSocket(ws, opts) {
   ws.addEventListener("message", (event) => {
     if (!session)
       return;
-    const msgEvent = event;
-    const { data } = msgEvent;
-    const isBinary = globalThis.Buffer?.isBuffer(data) || data instanceof ArrayBuffer || data instanceof Uint8Array;
-    if (isBinary) {
-      const chunk = data instanceof Uint8Array ? data : new Uint8Array(data.buffer ?? data, data.byteOffset ?? 0, data.byteLength ?? data.byteLength);
-      if (!isValidAudioChunk(chunk)) {
-        log.warn("Invalid audio chunk, dropping", {
-          ...ctx,
-          sid,
-          bytes: chunk.byteLength,
-          aligned: chunk.byteLength % 2 === 0
-        });
-        return;
-      }
-      session.onAudio(chunk);
-      return;
-    }
-    if (typeof data !== "string")
-      return;
-    let json;
-    try {
-      json = JSON.parse(data);
-    } catch {
-      log.warn("Invalid JSON from client", { ...ctx, sid });
+    const { data } = event;
+    if (handleBinaryAudio(data, session, log, 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;
-    }
+    handleTextMessage(data, session, log, ctx, sid);
   });
   ws.addEventListener("close", () => {
     log.info("Session disconnected", { ...ctx, sid });
@@ -1414,11 +1521,12 @@ var init_ws_handler = __esm({
 
 // dist/sdk/winterc_server.js
 function createWintercServer(options) {
-  const { agent, env, kv = createMemoryKv(), vectorSearch, clientHtml, logger = consoleLogger, metrics = noopMetrics, s2sConfig = DEFAULT_S2S_CONFIG } = 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,
@@ -1430,8 +1538,7 @@ function createWintercServer(options) {
     protocolVersion: PROTOCOL_VERSION,
     audioFormat: AUDIO_FORMAT,
     sampleRate: s2sConfig.inputSampleRate,
-    ttsSampleRate: s2sConfig.outputSampleRate,
-    mode: "s2s"
+    ttsSampleRate: s2sConfig.outputSampleRate
   };
   return {
     async fetch(request) {
@@ -1479,6 +1586,7 @@ var init_winterc_server = __esm({
     init_kv();
     init_protocol();
     init_runtime();
+    init_vector();
     init_ws_handler();
   }
 });
@@ -1522,7 +1630,9 @@ function createServer(options) {
         agent,
         env,
         ...kv ? { kv } : {},
-        createWebSocket: wsFactory,
+        createWebSocket: wsFactory ?? (() => {
+          throw new Error("WebSocket factory not loaded");
+        }),
         ...clientHtml !== void 0 ? { clientHtml } : {},
         logger,
         s2sConfig
@@ -1539,46 +1649,9 @@ function createServer(options) {
       await getWsFactory();
       const http = await import("node:http");
       const nodeServer = http.createServer(async (req, res) => {
-        try {
-          const protocol = req.socket.encrypted ? "https" : "http";
-          const host = req.headers.host ?? `localhost:${port}`;
-          const url = new URL(req.url ?? "/", `${protocol}://${host}`);
-          const headers = new Headers();
-          for (const [key, val] of Object.entries(req.headers)) {
-            if (val)
-              headers.set(key, Array.isArray(val) ? val[0] : val);
-          }
-          const request = new Request(url, {
-            method: req.method ?? "GET",
-            headers
-          });
-          const response = await getWinterc().fetch(request);
-          res.writeHead(response.status, Object.fromEntries(response.headers));
-          const body = await response.text();
-          res.end(body);
-        } catch (err) {
-          res.writeHead(500);
-          res.end(err instanceof Error ? err.message : "Internal Server Error");
-        }
+        await nodeHttpHandler(req, res, port, getWinterc);
       });
-      try {
-        const wsMod = await import("ws");
-        const WSServer = wsMod.WebSocketServer;
-        if (WSServer) {
-          const wss = new WSServer({ noServer: true });
-          nodeServer.on("upgrade", (req, socket, head) => {
-            wss.handleUpgrade(req, socket, head, (ws) => {
-              const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
-              const resume = reqUrl.searchParams.has("resume");
-              getWinterc().handleWebSocket(ws, {
-                skipGreeting: resume
-              });
-            });
-          });
-        }
-      } catch {
-        logger.warn("ws package not available for Node.js WebSocket upgrade");
-      }
+      attachWsUpgrade(nodeServer, port, getWinterc, logger);
       await new Promise((resolve) => {
         nodeServer.listen(port, () => {
           logger.info(`Agent "${agent.name}" listening on http://localhost:${port}`);
@@ -1599,6 +1672,43 @@ function createServer(options) {
     }
   };
 }
+async function nodeHttpHandler(req, res, port, getWinterc) {
+  try {
+    const protocol = req.socket.encrypted ? "https" : "http";
+    const host = req.headers.host ?? `localhost:${port}`;
+    const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+    const headers = new Headers();
+    for (const [key, val] of Object.entries(req.headers)) {
+      if (val)
+        headers.set(key, Array.isArray(val) ? val[0] ?? "" : val);
+    }
+    const request = new Request(url, { method: req.method ?? "GET", headers });
+    const response = await getWinterc().fetch(request);
+    res.writeHead(response.status, Object.fromEntries(response.headers));
+    res.end(await response.text());
+  } catch (err) {
+    res.writeHead(500);
+    res.end(err instanceof Error ? err.message : "Internal Server Error");
+  }
+}
+function attachWsUpgrade(nodeServer, port, getWinterc, logger) {
+  import("ws").then((wsMod) => {
+    const WSServer = wsMod.WebSocketServer;
+    if (!WSServer)
+      return;
+    const wss = new WSServer({ noServer: true });
+    nodeServer.on("upgrade", (req, socket, head) => {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
+        getWinterc().handleWebSocket(ws, {
+          skipGreeting: reqUrl.searchParams.has("resume")
+        });
+      });
+    });
+  }).catch(() => {
+    logger.warn("ws package not available for Node.js WebSocket upgrade");
+  });
+}
 var init_server = __esm({
   "dist/sdk/server.js"() {
     init_runtime();
@@ -1844,9 +1954,7 @@ async function loadAgent(dir) {
     slug,
     dir,
     entryPoint: path.join(dir, "agent.ts"),
-    env: {},
-    clientEntry,
-    transport: ["websocket"]
+    clientEntry
   };
 }
 async function ensureClaudeMd(targetDir) {
@@ -1880,7 +1988,7 @@ init_output();
 var _internals = {
   fetch: globalThis.fetch.bind(globalThis)
 };
-async function attemptDeploy(url, slug, apiKey, env, transport, worker, html, config, toolSchemas) {
+async function attemptDeploy(url, slug, apiKey, env, worker, html) {
   return await _internals.fetch(`${url}/${slug}/deploy`, {
     method: "POST",
     headers: {
@@ -1890,21 +1998,14 @@ async function attemptDeploy(url, slug, apiKey, env, transport, worker, html, co
     body: JSON.stringify({
       env,
       worker,
-      html,
-      transport,
-      config,
-      toolSchemas
+      html
     })
   });
 }
 var MAX_RETRIES = 20;
 async function runDeploy(opts) {
-  const manifest = JSON.parse(opts.bundle.manifest);
   const worker = opts.bundle.worker;
   const html = opts.bundle.html;
-  const transport = manifest.transport ?? ["websocket"];
-  const config = manifest.config;
-  const toolSchemas = manifest.toolSchemas;
   let slug = opts.slug;
   if (opts.dryRun) {
     stepInfo("Dry run", "would deploy:");
@@ -1912,17 +2013,7 @@ async function runDeploy(opts) {
     return { slug };
   }
   for (let i = 0; i < MAX_RETRIES; i++) {
-    const resp = await attemptDeploy(
-      opts.url,
-      slug,
-      opts.apiKey,
-      opts.env,
-      transport,
-      worker,
-      html,
-      config,
-      toolSchemas
-    );
+    const resp = await attemptDeploy(opts.url, slug, opts.apiKey, opts.env, worker, html);
     if (resp.ok) {
       step("Deploy", `${slug} -> ${opts.url}/${slug}`);
       try {
@@ -2078,365 +2169,16 @@ async function runWithInk(label, fn) {
 }
 
 // cli/build.ts
-import fs4 from "node:fs/promises";
+import fs3 from "node:fs/promises";
 import path3 from "node:path";
 
 // cli/_bundler.ts
-import fs3 from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import path2 from "node:path";
 import preact from "@preact/preset-vite";
 import tailwindcss from "@tailwindcss/vite";
 import { build } from "vite";
 import { viteSingleFile } from "vite-plugin-singlefile";
-
-// cli/_static_config.ts
-import fs2 from "node:fs/promises";
-import {
-  Project,
-  SyntaxKind
-} from "ts-morph";
-
-// sdk/types.ts
-var 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.`;
-var DEFAULT_GREETING = "Hey there. I'm a voice assistant. What can I help you with?";
-
-// cli/_static_config.ts
-var project = new Project({ useInMemoryFileSystem: true });
-async function extractStaticConfig(agentPath) {
-  const source = await fs2.readFile(agentPath, "utf-8");
-  return extractStaticConfigFromSource(source, agentPath);
-}
-function extractStaticConfigFromSource(source, fileName = "agent.ts") {
-  const sf = project.createSourceFile(fileName, source, { overwrite: true });
-  const call = findDefineAgentCall(sf);
-  if (!call) {
-    throw new BundleError(
-      `Could not find a defineAgent({...}) call in ${fileName}. Make sure your agent.ts has \`export default defineAgent({...})\`.`
-    );
-  }
-  const args = call.getArguments();
-  const arg = args[0];
-  if (!arg || !arg.isKind(SyntaxKind.ObjectLiteralExpression)) {
-    throw new BundleError("The argument to defineAgent() must be an inline object literal");
-  }
-  const obj = arg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-  const config = extractConfig(obj, fileName);
-  const toolSchemas = extractToolSchemas(obj, fileName);
-  return { config, toolSchemas };
-}
-function findDefineAgentCall(sf) {
-  return sf.getFirstDescendant((node) => {
-    if (!node.isKind(SyntaxKind.CallExpression)) return false;
-    const expr = node.getExpression();
-    return expr.isKind(SyntaxKind.Identifier) && expr.getText() === "defineAgent";
-  });
-}
-function extractConfig(obj, fileName) {
-  const name = requireString(obj, "name", fileName);
-  const config = {
-    name,
-    instructions: optionalString(obj, "instructions", fileName) ?? DEFAULT_INSTRUCTIONS,
-    greeting: optionalString(obj, "greeting", fileName) ?? DEFAULT_GREETING,
-    voice: optionalString(obj, "voice", fileName) ?? ""
-  };
-  const mode = optionalString(obj, "mode", fileName);
-  config.mode = mode ?? "s2s";
-  const sttPrompt = optionalString(obj, "sttPrompt", fileName);
-  if (sttPrompt !== void 0) config.sttPrompt = sttPrompt;
-  const maxStepsProp = getProperty(obj, "maxSteps");
-  if (maxStepsProp) {
-    const init = maxStepsProp.getInitializer();
-    if (init.isKind(SyntaxKind.NumericLiteral)) {
-      config.maxSteps = Number(init.getLiteralValue());
-    }
-  }
-  const toolChoiceProp = getProperty(obj, "toolChoice");
-  if (toolChoiceProp) {
-    config.toolChoice = evalLiteral(
-      toolChoiceProp.getInitializer(),
-      "toolChoice",
-      fileName
-    );
-  }
-  const builtinToolsProp = getProperty(obj, "builtinTools");
-  if (builtinToolsProp) {
-    config.builtinTools = evalStringArray(
-      builtinToolsProp.getInitializer(),
-      "builtinTools",
-      fileName
-    );
-  }
-  const activeToolsProp = getProperty(obj, "activeTools");
-  if (activeToolsProp) {
-    config.activeTools = evalStringArray(
-      activeToolsProp.getInitializer(),
-      "activeTools",
-      fileName
-    );
-  }
-  const transportProp = getProperty(obj, "transport");
-  if (transportProp) {
-    const init = transportProp.getInitializer();
-    if (init.isKind(SyntaxKind.StringLiteral)) {
-      config.transport = [init.getLiteralValue()];
-    } else if (init.isKind(SyntaxKind.ArrayLiteralExpression)) {
-      config.transport = evalStringArray(init, "transport", fileName);
-    } else {
-      throw new BundleError(
-        `${fileName}: \`transport\` must be a string literal or array of strings.`
-      );
-    }
-  }
-  return config;
-}
-function extractToolSchemas(obj, fileName) {
-  const toolsProp = getProperty(obj, "tools");
-  if (!toolsProp) return [];
-  const init = toolsProp.getInitializer();
-  if (!init.isKind(SyntaxKind.ObjectLiteralExpression)) {
-    throw new BundleError(`${fileName}: \`tools\` must be an inline object literal.`);
-  }
-  const toolsObj = init.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-  const schemas = [];
-  for (const member of toolsObj.getProperties()) {
-    if (member.isKind(SyntaxKind.SpreadAssignment)) {
-      const text = member.getExpression().getText();
-      throw new BundleError(
-        `${fileName}: Spread expressions like \`...${text}\` in tools cannot be statically analyzed. Define each tool directly in the \`tools\` object.`
-      );
-    }
-    if (!member.isKind(SyntaxKind.PropertyAssignment)) continue;
-    const prop = member;
-    const toolName = prop.getName();
-    const toolInit = prop.getInitializer();
-    if (!toolInit.isKind(SyntaxKind.ObjectLiteralExpression)) {
-      throw new BundleError(`${fileName}: Tool \`${toolName}\` must be an inline object literal.`);
-    }
-    const toolObj = toolInit.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-    const descProp = getProperty(toolObj, "description");
-    if (!descProp) {
-      throw new BundleError(`${fileName}: Tool \`${toolName}\` is missing a \`description\`.`);
-    }
-    const description = evalStringLiteral(descProp.getInitializer(), toolName, fileName);
-    const paramsProp = getProperty(toolObj, "parameters");
-    const parameters = paramsProp ? zodAstToJsonSchema(paramsProp.getInitializer(), toolName, fileName) : { type: "object", properties: {}, additionalProperties: false };
-    schemas.push({ name: toolName, description, parameters });
-  }
-  return schemas;
-}
-function zodAstToJsonSchema(node, toolName, fileName) {
-  return parseZodExpr(node, toolName, fileName).schema;
-}
-function parseZodExpr(node, toolName, fileName) {
-  if (!node.isKind(SyntaxKind.CallExpression)) {
-    throw zodError(node, toolName, fileName);
-  }
-  const call = node.asKindOrThrow(SyntaxKind.CallExpression);
-  const expr = call.getExpression();
-  if (expr.isKind(SyntaxKind.PropertyAccessExpression)) {
-    const propAccess = expr.asKindOrThrow(SyntaxKind.PropertyAccessExpression);
-    const obj = propAccess.getExpression();
-    const method = propAccess.getName();
-    if (obj.isKind(SyntaxKind.Identifier) && obj.getText() === "z") {
-      return parseZodBase(method, call, toolName, fileName);
-    }
-    if (method === "describe") {
-      const result = parseZodExpr(obj, toolName, fileName);
-      const args = call.getArguments();
-      if (args[0]) {
-        result.schema.description = evalStringLiteral(args[0], toolName, fileName);
-      }
-      return result;
-    }
-    if (method === "optional") {
-      const result = parseZodExpr(obj, toolName, fileName);
-      result.optional = true;
-      return result;
-    }
-    if (method === "default" || method === "nullable") {
-      return parseZodExpr(obj, toolName, fileName);
-    }
-    return parseZodExpr(obj, toolName, fileName);
-  }
-  throw zodError(node, toolName, fileName);
-}
-function parseZodBase(method, call, toolName, fileName) {
-  switch (method) {
-    case "string":
-      return { schema: { type: "string" }, optional: false };
-    case "number":
-      return { schema: { type: "number" }, optional: false };
-    case "boolean":
-      return { schema: { type: "boolean" }, optional: false };
-    case "enum": {
-      const args = call.getArguments();
-      const arg = args[0];
-      if (!arg || !arg.isKind(SyntaxKind.ArrayLiteralExpression)) {
-        throw new BundleError(
-          `${fileName}: Tool \`${toolName}\`: z.enum() requires an array literal argument.`
-        );
-      }
-      const arr = arg.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-      const values = arr.getElements().map((el) => {
-        if (!el.isKind(SyntaxKind.StringLiteral)) {
-          throw new BundleError(
-            `${fileName}: Tool \`${toolName}\`: z.enum() values must be string literals.`
-          );
-        }
-        return el.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
-      });
-      return {
-        schema: { type: "string", enum: values },
-        optional: false
-      };
-    }
-    case "array": {
-      const args = call.getArguments();
-      const arg = args[0];
-      if (!arg) {
-        return { schema: { type: "array" }, optional: false };
-      }
-      const items = parseZodExpr(arg, toolName, fileName);
-      return {
-        schema: { type: "array", items: items.schema },
-        optional: false
-      };
-    }
-    case "object": {
-      const args = call.getArguments();
-      const arg = args[0];
-      if (!arg || !arg.isKind(SyntaxKind.ObjectLiteralExpression)) {
-        return {
-          schema: {
-            type: "object",
-            properties: {},
-            additionalProperties: false
-          },
-          optional: false
-        };
-      }
-      const objLit = arg.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-      const properties = {};
-      const required = [];
-      for (const member of objLit.getProperties()) {
-        if (!member.isKind(SyntaxKind.PropertyAssignment)) continue;
-        const prop = member;
-        const propName = prop.getName();
-        const result = parseZodExpr(prop.getInitializer(), toolName, fileName);
-        properties[propName] = result.schema;
-        if (!result.optional) {
-          required.push(propName);
-        }
-      }
-      const schema = {
-        type: "object",
-        properties,
-        additionalProperties: false
-      };
-      if (required.length > 0) {
-        schema.required = required;
-      }
-      return { schema, optional: false };
-    }
-    default:
-      throw new BundleError(
-        `${fileName}: Tool \`${toolName}\`: unsupported Zod type \`z.${method}()\`. Supported: z.string(), z.number(), z.boolean(), z.enum([...]), z.array(...), z.object({...}).`
-      );
-  }
-}
-function zodError(node, toolName, fileName) {
-  const text = node.getText().slice(0, 60);
-  return new BundleError(
-    `${fileName}: Tool \`${toolName}\`: unsupported Zod pattern \`${text}\`. Supported: z.string(), z.number(), z.boolean(), z.enum([...]), z.array(...), z.object({...}), .describe(), .optional().`
-  );
-}
-function getProperty(obj, name) {
-  const prop = obj.getProperty(name);
-  if (!prop) return void 0;
-  if (!prop.isKind(SyntaxKind.PropertyAssignment)) return void 0;
-  return prop;
-}
-function requireString(obj, field, fileName) {
-  const prop = getProperty(obj, field);
-  if (!prop) {
-    throw new BundleError(`${fileName}: The \`${field}\` field is required in defineAgent({...}).`);
-  }
-  return evalStringLiteral(prop.getInitializer(), field, fileName);
-}
-function optionalString(obj, field, fileName) {
-  const prop = getProperty(obj, field);
-  if (!prop) return void 0;
-  return evalStringLiteral(prop.getInitializer(), field, fileName);
-}
-function evalStringLiteral(node, context, fileName) {
-  if (node.isKind(SyntaxKind.StringLiteral)) {
-    return node.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
-  }
-  if (node.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) {
-    return node.asKindOrThrow(SyntaxKind.NoSubstitutionTemplateLiteral).getLiteralValue();
-  }
-  if (node.isKind(SyntaxKind.TemplateExpression)) {
-    throw new BundleError(
-      `${fileName}: \`${context}\` uses template expressions with substitutions, which cannot be statically analyzed. Use a plain string literal.`
-    );
-  }
-  throw new BundleError(
-    `${fileName}: \`${context}\` must be a static string literal. Dynamic expressions cannot be analyzed at build time.`
-  );
-}
-function evalStringArray(node, context, fileName) {
-  if (!node.isKind(SyntaxKind.ArrayLiteralExpression)) {
-    throw new BundleError(`${fileName}: \`${context}\` must be an array literal.`);
-  }
-  const arr = node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression);
-  return arr.getElements().map((el) => evalStringLiteral(el, context, fileName));
-}
-function evalLiteral(node, context, fileName) {
-  if (node.isKind(SyntaxKind.StringLiteral)) {
-    return node.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
-  }
-  if (node.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) {
-    return node.asKindOrThrow(SyntaxKind.NoSubstitutionTemplateLiteral).getLiteralValue();
-  }
-  if (node.isKind(SyntaxKind.NumericLiteral)) {
-    return Number(node.asKindOrThrow(SyntaxKind.NumericLiteral).getLiteralValue());
-  }
-  if (node.isKind(SyntaxKind.TrueKeyword)) return true;
-  if (node.isKind(SyntaxKind.FalseKeyword)) return false;
-  if (node.isKind(SyntaxKind.ArrayLiteralExpression)) {
-    return node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression).getElements().map((el) => evalLiteral(el, context, fileName));
-  }
-  if (node.isKind(SyntaxKind.ObjectLiteralExpression)) {
-    const obj = node.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-    const result = {};
-    for (const member of obj.getProperties()) {
-      if (member.isKind(SyntaxKind.PropertyAssignment)) {
-        const prop = member;
-        result[prop.getName()] = evalLiteral(
-          prop.getInitializer(),
-          context,
-          fileName
-        );
-      }
-    }
-    return result;
-  }
-  throw new BundleError(
-    `${fileName}: \`${context}\` must be a static literal value. Dynamic expressions cannot be analyzed at build time.`
-  );
-}
-
-// cli/_bundler.ts
 var BundleError = class extends Error {
   constructor(message) {
     super(message);
@@ -2558,14 +2300,13 @@ var INDEX_HTML = `<!DOCTYPE html>
 async function bundleAgent(agent, opts) {
   const aaiDir = path2.join(agent.dir, ".aai");
   const buildDir = path2.join(aaiDir, "build");
-  await fs3.mkdir(aaiDir, { recursive: true });
-  const { config: agentConfig, toolSchemas } = await extractStaticConfig(agent.entryPoint);
-  await fs3.writeFile(path2.join(aaiDir, "index.html"), INDEX_HTML);
+  await fs2.mkdir(aaiDir, { recursive: true });
+  await fs2.writeFile(path2.join(aaiDir, "index.html"), INDEX_HTML);
   const stylesPath = path2.join(agent.dir, "styles.css");
   try {
-    await fs3.access(stylesPath);
+    await fs2.access(stylesPath);
   } catch {
-    await fs3.writeFile(stylesPath, DEFAULT_STYLES_CSS);
+    await fs2.writeFile(stylesPath, DEFAULT_STYLES_CSS);
   }
   try {
     await build({
@@ -2610,22 +2351,12 @@ async function bundleAgent(agent, opts) {
       throw new BundleError(err instanceof Error ? err.message : String(err));
     }
   }
-  const worker = await fs3.readFile(path2.join(buildDir, "worker.js"), "utf-8");
+  const worker = await fs2.readFile(path2.join(buildDir, "worker.js"), "utf-8");
   const htmlPath = skipClient ? path2.join(aaiDir, "index.html") : path2.join(buildDir, "index.html");
-  const html = await fs3.readFile(htmlPath, "utf-8");
-  const manifest = JSON.stringify(
-    {
-      transport: agentConfig.transport ?? agent.transport,
-      config: agentConfig,
-      toolSchemas
-    },
-    null,
-    2
-  );
+  const html = await fs2.readFile(htmlPath, "utf-8");
   return {
     worker,
     html,
-    manifest,
     workerBytes: Buffer.byteLength(worker)
   };
 }
@@ -2634,46 +2365,17 @@ async function bundleAgent(agent, opts) {
 init_output();
 async function writeBuildOutput(agentDir, bundle) {
   const buildDir = path3.join(agentDir, ".aai", "build");
-  await fs4.mkdir(buildDir, { recursive: true });
+  await fs3.mkdir(buildDir, { recursive: true });
   await Promise.all([
-    fs4.writeFile(path3.join(buildDir, "worker.js"), bundle.worker),
-    fs4.writeFile(path3.join(buildDir, "manifest.json"), bundle.manifest),
-    fs4.writeFile(path3.join(buildDir, "index.html"), bundle.html)
+    fs3.writeFile(path3.join(buildDir, "worker.js"), bundle.worker),
+    fs3.writeFile(path3.join(buildDir, "index.html"), bundle.html)
   ]);
 }
-async function checkAgent(agentDir) {
-  const userFiles = ["agent.ts"];
-  for (const f of ["client.tsx", "components.tsx"]) {
-    try {
-      await fs4.stat(path3.join(agentDir, f));
-      userFiles.push(f);
-    } catch {
-    }
-  }
-  const checks = [{ args: ["--noEmit", ...userFiles], label: "Type-check" }];
-  const results = await Promise.allSettled(
-    checks.map(({ args }) => execFileAsync("npx", ["tsc", ...args], { cwd: agentDir }))
-  );
-  const errors = [];
-  for (let i = 0; i < results.length; i++) {
-    const r = results[i];
-    if (r.status === "rejected") {
-      const msg = r.reason.stderr?.trim() ?? String(r.reason);
-      error2(`${checks[i].label}: ${msg}`);
-      errors.push(checks[i].label);
-    }
-  }
-  if (errors.length > 0) {
-    throw new Error(`${errors.join(", ")} failed \u2014 fix the errors above`);
-  }
-}
 async function runBuild(opts) {
   const agent = await loadAgent(opts.agentDir);
   if (!agent) {
     throw new Error("No agent found \u2014 run `aai new` first");
   }
-  step("Check", agent.slug);
-  await checkAgent(opts.agentDir);
   step("Bundle", agent.slug);
   let bundle;
   try {
@@ -2691,7 +2393,7 @@ async function runBuild(opts) {
 
 // cli/new.tsx
 init_colors();
-import fs6 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import path5 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import minimist from "minimist";
@@ -2767,14 +2469,14 @@ async function runNewCommand(args, version) {
     if (isDevMode()) {
       const monorepoRoot = path5.join(cliDir2, "..");
       const pkgJsonPath2 = path5.join(cwd, "package.json");
-      const pkgJson2 = JSON.parse(await fs6.readFile(pkgJsonPath2, "utf-8"));
+      const pkgJson2 = JSON.parse(await fs5.readFile(pkgJsonPath2, "utf-8"));
       for (const pkg of ["sdk", "ui"]) {
         const localPkgPath = path5.join(monorepoRoot, pkg, "package.json");
-        const localPkg = JSON.parse(await fs6.readFile(localPkgPath, "utf-8"));
+        const localPkg = JSON.parse(await fs5.readFile(localPkgPath, "utf-8"));
         const pkgName = localPkg.name;
         pkgJson2.dependencies[pkgName] = `file:${path5.join(monorepoRoot, pkg)}`;
       }
-      await fs6.writeFile(pkgJsonPath2, `${JSON.stringify(pkgJson2, null, 2)}
+      await fs5.writeFile(pkgJsonPath2, `${JSON.stringify(pkgJson2, null, 2)}
 `);
     }
     await ensureClaudeMd(cwd);
@@ -2868,7 +2570,9 @@ async function loadAgentDef(cwd) {
   }
 }
 async function resolveServerEnv() {
-  const env = { ...process.env };
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter((e) => e[1] !== void 0)
+  );
   if (!env.ASSEMBLYAI_API_KEY) {
     try {
       env.ASSEMBLYAI_API_KEY = await getApiKey();
@@ -3042,14 +2746,26 @@ async function runRag(opts) {
   log(/* @__PURE__ */ jsx4(Step, { action: "Parsed", msg: `${pages.length} pages` }));
   const { RecursiveChunker } = await import("@chonkiejs/core");
   const chunker = await RecursiveChunker.create({ chunkSize });
-  const allChunks = [];
   const siteSlug = slugify(origin);
+  const allChunks = await chunkPages(pages, chunker, origin, siteSlug);
+  log(/* @__PURE__ */ jsx4(Step, { action: "Chunked", msg: `${allChunks.length} chunks` }));
+  const vectorUrl = `${serverUrl}/${slug}/vector`;
+  log(/* @__PURE__ */ jsx4(Info, { msg: `target: ${vectorUrl}` }));
+  const result = await upsertChunks(allChunks, vectorUrl, apiKey, setProgress);
+  log(/* @__PURE__ */ jsx4(Step, { action: "Done", msg: `${result.upserted} chunks upserted` }));
+  if (result.errors > 0) {
+    log(/* @__PURE__ */ jsx4(Warn, { msg: `${result.errors} failed` }));
+    if (result.lastError) log(/* @__PURE__ */ jsx4(Info, { msg: `last error: ${result.lastError}` }));
+  }
+  log(/* @__PURE__ */ jsx4(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 (let i = 0; i < raw.length; i++) {
-      const c = raw[i];
+    for (const [i, c] of raw.entries()) {
       const data = page.title ? `${page.title}
 
 ${c.text}` : c.text;
@@ -3065,10 +2781,10 @@ ${c.text}` : c.text;
       });
     }
   }
-  log(/* @__PURE__ */ jsx4(Step, { action: "Chunked", msg: `${allChunks.length} chunks` }));
-  const vectorUrl = `${serverUrl}/${slug}/vector`;
-  log(/* @__PURE__ */ jsx4(Info, { msg: `target: ${vectorUrl}` }));
-  const total = allChunks.length;
+  return allChunks;
+}
+async function upsertChunks(chunks, vectorUrl, apiKey, setProgress) {
+  const total = chunks.length;
   let completed = 0;
   let upserted = 0;
   let errors = 0;
@@ -3076,7 +2792,7 @@ ${c.text}` : c.text;
   setProgress({ completed: 0, total });
   const limit = pLimit(5);
   await Promise.all(
-    allChunks.map(
+    chunks.map(
       (chunk) => limit(async () => {
         try {
           const r = await fetch(vectorUrl, {
@@ -3107,12 +2823,7 @@ ${c.text}` : c.text;
       })
     )
   );
-  log(/* @__PURE__ */ jsx4(Step, { action: "Done", msg: `${upserted} chunks upserted` }));
-  if (errors > 0) {
-    log(/* @__PURE__ */ jsx4(Warn, { msg: `${errors} failed` }));
-    if (lastError) log(/* @__PURE__ */ jsx4(Info, { msg: `last error: ${lastError}` }));
-  }
-  log(/* @__PURE__ */ jsx4(Detail, { msg: `Agent: ${slug}` }));
+  return { upserted, errors, lastError };
 }
 async function runRagCommand(args, version) {
   const parsed = minimist4(args, {
@@ -3170,34 +2881,38 @@ function splitPages(content) {
   for (const section of raw) {
     const trimmed = section.trim();
     if (!trimmed) continue;
-    let title = "";
-    let body = trimmed;
-    const dashIndex = trimmed.search(/^-{3,}$/m);
-    if (dashIndex !== -1) {
-      const frontmatter = trimmed.slice(0, dashIndex);
-      body = trimmed.slice(dashIndex).replace(/^-+$/m, "").trim();
-      const titleMatch = frontmatter.match(/^title:\s*(.+)$/m);
-      if (titleMatch) {
-        title = titleMatch[1].trim();
-      }
+    const page = parsePage(trimmed);
+    if (page.body.length > 0) {
+      pages.push(page);
     }
-    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 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() ?? "";
       }
     }
-    if (body.length > 0) {
-      pages.push({ title, body });
-    }
   }
-  return pages;
+  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();
@@ -3247,7 +2962,7 @@ async function runSecretCommand(args, version) {
   }
   switch (sub) {
     case "put":
-      await secretPut(cwd, String(parsed._[1] ?? ""), secretValue);
+      await secretPut(cwd, String(parsed._[1] ?? ""), secretValue ?? "");
       break;
     case "delete":
       await secretDelete(cwd, String(parsed._[1] ?? ""));
@@ -3326,11 +3041,11 @@ import minimist6 from "minimist";
 
 // cli/_start.ts
 init_output();
-import fs7 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import path9 from "node:path";
 async function _startProductionServer(cwd, port) {
   const buildDir = path9.join(cwd, ".aai", "build");
-  const html = await fs7.readFile(path9.join(buildDir, "index.html"), "utf-8");
+  const html = await fs6.readFile(path9.join(buildDir, "index.html"), "utf-8");
   step("Load", "agent");
   const agentDef = await loadAgentDef(cwd);
   const env = await resolveServerEnv();