theokit 0.23.1 → 0.25.0

package/dist/{agent-7IGDT55V.js → agent-GXJNFW6N.js}

@@ -3,7 +3,7 @@ import "tsx/esm";
 import {
   agentCommand,
   createAgentSsrLoader
-} from "./chunk-JITNAZXE.js";
+} from "./chunk-LVGDYTU2.js";
 import "./chunk-M6NMS5LR.js";
 import "./chunk-GDN3PXFH.js";
 import "./chunk-TERFLG67.js";
@@ -12,4 +12,4 @@ export {
   agentCommand,
   createAgentSsrLoader
 };
-//# sourceMappingURL=agent-7IGDT55V.js.map
+//# sourceMappingURL=agent-GXJNFW6N.js.map

package/dist/{build-G7WWVZTL.js → build-WD2PT5TA.js}

@@ -531,7 +531,7 @@ async function buildCommand(options) {
 `);
 }
 async function runAdapterBuild(target, config, cwd) {
-  const { theoPluginAsync } = await import("./vite-plugin-A7WGYEMD.js");
+  const { theoPluginAsync } = await import("./vite-plugin-ST4JZQRJ.js");
   const { default: react } = await import("@vitejs/plugin-react");
   const ctx = {
     // `react()` may return Plugin or Plugin[] depending on version; spread the
@@ -616,4 +616,4 @@ function relativize3(absPath, root) {
 export {
   buildCommand
 };
-//# sourceMappingURL=build-G7WWVZTL.js.map
+//# sourceMappingURL=build-WD2PT5TA.js.map

package/dist/{chunk-BLL5LY7R.js → chunk-2JNG3P4Y.js}

@@ -44,9 +44,6 @@ import {
 import {
   importUserModule
 } from "./chunk-7MQOHNHE.js";
-import {
-  uiMessageStreamResponse
-} from "./chunk-JZHT3LW7.js";
 import {
   BATCH_PATH,
   TRACE_HEADER,
@@ -1158,11 +1155,164 @@ function handleListApprovals(registry2) {
 }
 
 // src/server/agent/mount-agent.ts
+import { compileAgentModule as compileAgentModule3, resolveEnabledSkills as resolveEnabledSkills2, streamAgentUIMessages as streamAgentUIMessages2 } from "@theokit/agents";
+
+// src/server/agent/build-agent-streamer.ts
 import {
   compileAgentModule as compileAgentModule2,
   resolveEnabledSkills,
   streamAgentUIMessages
 } from "@theokit/agents";
+function buildAgentHitl(compiled) {
+  const gated = compiled.hitl;
+  if (gated === void 0 || gated.size === 0) return void 0;
+  const registry2 = getApprovalRegistry();
+  return {
+    gated,
+    awaitApproval: (approvalId, opts, toolName) => registry2.register(approvalId, {
+      timeoutMs: opts.timeout ?? 3e5,
+      onTimeout: opts.onTimeout ?? "abort",
+      toolName,
+      question: opts.question,
+      ...opts.payloadSchema !== void 0 ? { payloadSchema: opts.payloadSchema } : {}
+    })
+  };
+}
+function makeThreadStartRun(mod, apiKey, source) {
+  return (sessionId, message) => (async function* () {
+    const compiled = compileAgentModule2(mod, source);
+    if (compiled.skillsResolver) {
+      const enabled = await resolveEnabledSkills(
+        compiled.skillsResolver,
+        compiled.runContext ?? {}
+      );
+      if (enabled !== void 0) compiled.skills = { enabled, autoInject: true };
+    }
+    const hitl = buildAgentHitl(compiled);
+    yield* streamAgentUIMessages(compiled, apiKey, { message, sessionId, hitl });
+  })();
+}
+
+// src/server/agent/durable-ui-message-stream-response.ts
+var SSE_BASE_HEADERS = {
+  "content-type": "text/event-stream",
+  "x-vercel-ai-ui-message-stream": "v1"
+};
+var RUN_ID_HEADER = "x-theokit-run-id";
+var SSE_DONE_FRAME = "data: [DONE]\n\n";
+function formatSseFrame(seq, data) {
+  return `id: ${seq}
+data: ${data}
+
+`;
+}
+function encodeSse(text) {
+  return new TextEncoder().encode(text);
+}
+function durableUiMessageStreamResponse(chunks, deps) {
+  const { runId, cache } = deps;
+  const stream = new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const chunk of chunks) {
+          const data = JSON.stringify(chunk);
+          const seq = cache.append(runId, data);
+          controller.enqueue(encodeSse(formatSseFrame(seq, data)));
+        }
+      } catch {
+      } finally {
+        cache.end(runId);
+        controller.enqueue(encodeSse(SSE_DONE_FRAME));
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: { ...SSE_BASE_HEADERS, [RUN_ID_HEADER]: runId }
+  });
+}
+
+// src/server/agent/run-event-cache.ts
+var DEFAULT_EVICT_AFTER_MS = 5 * 6e4;
+var NOOP_UNSUBSCRIBE = () => {
+};
+function createInMemoryRunEventCache(opts = {}) {
+  const evictAfterMs = opts.evictAfterMs ?? DEFAULT_EVICT_AFTER_MS;
+  const runs = /* @__PURE__ */ new Map();
+  function getOrCreate(runId) {
+    let buf = runs.get(runId);
+    if (buf === void 0) {
+      buf = { frames: [], ended: false, listeners: /* @__PURE__ */ new Set() };
+      runs.set(runId, buf);
+    }
+    return buf;
+  }
+  return {
+    begin(runId) {
+      getOrCreate(runId);
+    },
+    append(runId, data) {
+      const buf = getOrCreate(runId);
+      const seq = buf.frames.length;
+      const frame = { seq, data };
+      buf.frames.push(frame);
+      for (const l of buf.listeners) {
+        try {
+          l.onFrame(frame);
+        } catch {
+        }
+      }
+      return seq;
+    },
+    has(runId) {
+      return runs.has(runId);
+    },
+    end(runId) {
+      const buf = runs.get(runId);
+      if (buf === void 0 || buf.ended) return;
+      buf.ended = true;
+      for (const l of buf.listeners) {
+        try {
+          l.onEnd();
+        } catch {
+        }
+      }
+      buf.listeners.clear();
+      buf.evictTimer = setTimeout(() => runs.delete(runId), evictAfterMs);
+      buf.evictTimer.unref();
+    },
+    attach(runId, afterSeq, onFrame, onEnd) {
+      const buf = runs.get(runId);
+      if (buf === void 0) {
+        return { known: false, replay: [], ended: false, unsubscribe: NOOP_UNSUBSCRIBE };
+      }
+      const replay = buf.frames.filter((f) => f.seq > afterSeq);
+      if (buf.ended) {
+        return { known: true, replay, ended: true, unsubscribe: NOOP_UNSUBSCRIBE };
+      }
+      const listener = { onFrame, onEnd };
+      buf.listeners.add(listener);
+      return {
+        known: true,
+        replay,
+        ended: false,
+        unsubscribe: () => {
+          buf.listeners.delete(listener);
+        }
+      };
+    }
+  };
+}
+var serverCache;
+function getRunEventCache() {
+  serverCache ??= createInMemoryRunEventCache();
+  return serverCache;
+}
+function mintRunId() {
+  return `run-${crypto.randomUUID()}`;
+}
+
+// src/server/agent/mount-agent.ts
 function partText(part) {
   if (typeof part !== "object" || part === null) return "";
   const p = part;
@@ -1198,9 +1348,9 @@ async function mountAgent(mod, request, apiKey, source = "agent module", csrfMod
       return jsonError2(403, "CSRF_FAILED", `CSRF check failed: ${csrf.reason}`);
     }
   }
-  const compiled = compileAgentModule2(mod, source);
+  const compiled = compileAgentModule3(mod, source);
   if (compiled.skillsResolver) {
-    const enabled = await resolveEnabledSkills(compiled.skillsResolver, compiled.runContext ?? {});
+    const enabled = await resolveEnabledSkills2(compiled.skillsResolver, compiled.runContext ?? {});
     if (enabled !== void 0) compiled.skills = { enabled, autoInject: true };
   }
   let body = null;
@@ -1212,22 +1362,11 @@ async function mountAgent(mod, request, apiKey, source = "agent module", csrfMod
   if (input === null) {
     return jsonError2(400, "BAD_REQUEST", "Request must contain a non-empty message or messages[].");
   }
-  const gated = compiled.hitl;
-  const registry2 = getApprovalRegistry();
-  const hitl = gated && gated.size > 0 ? {
-    gated,
-    awaitApproval: (approvalId, opts, toolName) => registry2.register(approvalId, {
-      timeoutMs: opts.timeout ?? 3e5,
-      onTimeout: opts.onTimeout ?? "abort",
-      // M14 — surface toolName + question in GET /approvals (the plugin forwards c.name).
-      toolName,
-      question: opts.question,
-      // M20 — carry the declared custom-payload schema into GET /approvals.
-      ...opts.payloadSchema !== void 0 ? { payloadSchema: opts.payloadSchema } : {}
-    })
-  } : void 0;
-  return uiMessageStreamResponse(
-    streamAgentUIMessages(compiled, apiKey, { ...input, hitl, signal: request.signal })
+  const hitl = buildAgentHitl(compiled);
+  const runId = mintRunId();
+  return durableUiMessageStreamResponse(
+    streamAgentUIMessages2(compiled, apiKey, { ...input, hitl, signal: request.signal }),
+    { runId, cache: getRunEventCache() }
   );
 }
 
@@ -1271,13 +1410,273 @@ function resolveProvider() {
   );
 }
 
-// src/server/agent/serve-aux-routes.ts
+// src/server/agent/handle-agent-run-reconnect.ts
+var RUN_STREAM_PATH = /^\/api\/agents\/([^/]+)\/runs\/([^/]+)\/stream$/;
+function isAgentRunStreamPath(urlPath) {
+  const m = RUN_STREAM_PATH.exec(urlPath);
+  return m ? { name: decodeURIComponent(m[1]), runId: decodeURIComponent(m[2]) } : null;
+}
+function parseLastEventId(raw) {
+  if (raw === null) return -1;
+  const n = Number.parseInt(raw, 10);
+  return Number.isInteger(n) && n >= 0 ? n : -1;
+}
+function handleAgentRunReconnect(runId, request, cache) {
+  if (!cache.has(runId)) {
+    return new Response(
+      JSON.stringify({ error: { code: "RUN_NOT_FOUND", message: `Unknown run '${runId}'.` } }),
+      {
+        status: 404,
+        headers: { "content-type": "application/json" }
+      }
+    );
+  }
+  const afterSeq = parseLastEventId(request.headers.get("last-event-id"));
+  const stream = new ReadableStream({
+    start(controller) {
+      let closed = false;
+      const safeEnqueue = (text) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encodeSse(text));
+        } catch {
+        }
+      };
+      const close = () => {
+        if (closed) return;
+        safeEnqueue(SSE_DONE_FRAME);
+        closed = true;
+        try {
+          controller.close();
+        } catch {
+        }
+      };
+      const res = cache.attach(
+        runId,
+        afterSeq,
+        (frame) => {
+          safeEnqueue(formatSseFrame(frame.seq, frame.data));
+        },
+        () => {
+          close();
+        }
+      );
+      if (!res.known) {
+        close();
+        return;
+      }
+      for (const frame of res.replay) {
+        safeEnqueue(formatSseFrame(frame.seq, frame.data));
+      }
+      if (res.ended) {
+        close();
+        return;
+      }
+      request.signal.addEventListener("abort", () => {
+        res.unsubscribe();
+        close();
+      });
+    }
+  });
+  return new Response(stream, { headers: { ...SSE_BASE_HEADERS, [RUN_ID_HEADER]: runId } });
+}
+
+// src/server/agent/thread-dispatcher.ts
+function postThreadFollowUp(deps, sessionId, message) {
+  if (deps.registry.getActive(sessionId) !== null) {
+    deps.registry.queue(sessionId, { message });
+    return { queued: true };
+  }
+  return { runId: startAndPump(deps, sessionId, message) };
+}
+function startAndPump(deps, sessionId, message) {
+  const runId = mintRunId();
+  deps.cache.begin(runId);
+  deps.registry.startRun(sessionId, runId);
+  pumpIntoCache(deps, sessionId, runId, deps.startRun(sessionId, message));
+  return runId;
+}
+function pumpIntoCache(deps, sessionId, runId, chunks) {
+  void (async () => {
+    try {
+      for await (const chunk of chunks) {
+        deps.cache.append(runId, JSON.stringify(chunk));
+      }
+    } catch {
+    } finally {
+      deps.cache.end(runId);
+      const next = deps.registry.endRun(sessionId, runId);
+      if (next !== void 0) startAndPump(deps, sessionId, next.message);
+    }
+  })();
+}
+
+// src/server/agent/thread-run-registry.ts
+function createInProcessThreadRunRegistry() {
+  const threads = /* @__PURE__ */ new Map();
+  const ensure = (sessionId) => {
+    let s = threads.get(sessionId);
+    if (s === void 0) {
+      s = { activeRunId: null, queue: [], waiters: /* @__PURE__ */ new Set() };
+      threads.set(sessionId, s);
+    }
+    return s;
+  };
+  return {
+    getActive(sessionId) {
+      return threads.get(sessionId)?.activeRunId ?? null;
+    },
+    startRun(sessionId, runId) {
+      const s = ensure(sessionId);
+      s.activeRunId = runId;
+      const waiters = [...s.waiters];
+      s.waiters.clear();
+      for (const cb of waiters) cb(runId);
+    },
+    endRun(sessionId, runId) {
+      const s = threads.get(sessionId);
+      if (s?.activeRunId !== runId) return void 0;
+      s.activeRunId = null;
+      return s.queue.shift();
+    },
+    queue(sessionId, followUp) {
+      ensure(sessionId).queue.push(followUp);
+    },
+    onNextRun(sessionId, cb) {
+      const s = ensure(sessionId);
+      s.waiters.add(cb);
+      return () => {
+        s.waiters.delete(cb);
+      };
+    }
+  };
+}
+var serverRegistry2;
+function getThreadRunRegistry() {
+  serverRegistry2 ??= createInProcessThreadRunRegistry();
+  return serverRegistry2;
+}
+
+// src/server/agent/handle-thread-routes.ts
+var THREAD_MESSAGE_PATH = /^\/api\/agents\/([^/]+)\/threads\/([^/]+)\/message$/;
+var THREAD_STREAM_PATH = /^\/api\/agents\/([^/]+)\/threads\/([^/]+)\/stream$/;
+var DEFAULT_IDLE_WAIT_MS = 3e4;
+function matchThread(re, urlPath) {
+  const m = re.exec(urlPath);
+  return m ? { name: decodeURIComponent(m[1]), sessionId: decodeURIComponent(m[2]) } : null;
+}
+var isThreadMessagePath = (urlPath) => matchThread(THREAD_MESSAGE_PATH, urlPath);
+var isThreadStreamPath = (urlPath) => matchThread(THREAD_STREAM_PATH, urlPath);
 function jsonError3(status, code, message) {
   return new Response(JSON.stringify({ error: { code, message } }), {
     status,
     headers: { "content-type": "application/json; charset=utf-8" }
   });
 }
+async function handleThreadMessage(args) {
+  const { mod, apiKey, sessionId, request, source, csrfMode = "strict" } = args;
+  if (csrfMode === "strict") {
+    const csrf = validateCsrfRequest(request);
+    if (!csrf.valid) return jsonError3(403, "CSRF_FAILED", `CSRF check failed: ${csrf.reason}`);
+  }
+  let body = null;
+  try {
+    body = await request.json();
+  } catch {
+  }
+  const input = parseAgentRequestBody(body);
+  if (input === null) {
+    return jsonError3(400, "BAD_REQUEST", "Request must contain a non-empty message.");
+  }
+  const result = postThreadFollowUp(
+    {
+      registry: getThreadRunRegistry(),
+      cache: getRunEventCache(),
+      startRun: makeThreadStartRun(mod, apiKey, source)
+    },
+    sessionId,
+    input.message
+  );
+  const headers = { "content-type": "application/json; charset=utf-8" };
+  if ("runId" in result) headers[RUN_ID_HEADER] = result.runId;
+  return new Response(JSON.stringify(result), { status: 202, headers });
+}
+function handleThreadStream(sessionId, request, registry2 = getThreadRunRegistry(), cache = getRunEventCache(), idleWaitMs = DEFAULT_IDLE_WAIT_MS) {
+  const active = registry2.getActive(sessionId);
+  if (active !== null && cache.has(active)) {
+    return handleAgentRunReconnect(active, request, cache);
+  }
+  return waitThenAttachStream(sessionId, request, registry2, cache, idleWaitMs);
+}
+function waitThenAttachStream(sessionId, request, registry2, cache, idleWaitMs) {
+  const stream = new ReadableStream({
+    start(controller) {
+      let closed = false;
+      const send = (text) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encodeSse(text));
+        } catch {
+        }
+      };
+      let detachAttach;
+      const close = () => {
+        if (closed) return;
+        send(SSE_DONE_FRAME);
+        closed = true;
+        try {
+          controller.close();
+        } catch {
+        }
+      };
+      const offNext = registry2.onNextRun(sessionId, (runId) => {
+        const res = cache.attach(
+          runId,
+          -1,
+          (frame) => {
+            send(formatSseFrame(frame.seq, frame.data));
+          },
+          () => {
+            close();
+          }
+        );
+        if (!res.known) {
+          close();
+          return;
+        }
+        for (const frame of res.replay) send(formatSseFrame(frame.seq, frame.data));
+        if (res.ended) {
+          close();
+          return;
+        }
+        detachAttach = res.unsubscribe;
+      });
+      const teardownWaiter = () => {
+        offNext();
+        detachAttach?.();
+      };
+      const timer = setTimeout(() => {
+        teardownWaiter();
+        close();
+      }, idleWaitMs);
+      timer.unref();
+      request.signal.addEventListener("abort", () => {
+        teardownWaiter();
+        clearTimeout(timer);
+        close();
+      });
+    }
+  });
+  return new Response(stream, { headers: { ...SSE_BASE_HEADERS } });
+}
+
+// src/server/agent/serve-aux-routes.ts
+function jsonError4(status, code, message) {
+  return new Response(JSON.stringify({ error: { code, message } }), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
 async function serveAgentAuxRoute(request, urlPath, deps) {
   const method = request.method.toUpperCase();
   const cardName = isAgentCardPath(urlPath);
@@ -1292,12 +1691,51 @@ async function serveAgentAuxRoute(request, urlPath, deps) {
     if (method !== "GET") return null;
     return handleListApprovals(getApprovalRegistry());
   }
+  const runStream = isAgentRunStreamPath(urlPath);
+  if (runStream !== null) {
+    if (method !== "GET") return null;
+    if (!deps.agents.some((a) => a.name === runStream.name)) return null;
+    return handleAgentRunReconnect(runStream.runId, request, getRunEventCache());
+  }
+  const threadResponse = await serveThreadRoute(request, method, urlPath, deps);
+  if (threadResponse !== null) return threadResponse;
   const mcpName = isMcpPath(urlPath);
   if (mcpName !== null) {
     return serveMcpRoute(request, method, mcpName, deps);
   }
   return null;
 }
+async function serveThreadRoute(request, method, urlPath, deps) {
+  const stream = isThreadStreamPath(urlPath);
+  if (stream !== null) {
+    if (method !== "GET") return null;
+    if (!deps.agents.some((a) => a.name === stream.name)) return null;
+    return handleThreadStream(stream.sessionId, request);
+  }
+  const msg = isThreadMessagePath(urlPath);
+  if (msg !== null) {
+    if (method !== "POST") return null;
+    const agent = deps.agents.find((a) => a.name === msg.name);
+    if (!agent) return null;
+    if (deps.resolveApiKey === void 0) {
+      return jsonError4(
+        501,
+        "NOT_CONFIGURED",
+        "Thread follow-up requires a provider API key (resolveApiKey was not provided to serveAgentAuxRoute)."
+      );
+    }
+    const mod = await deps.loadModule(agent.filePath);
+    return handleThreadMessage({
+      mod,
+      apiKey: deps.resolveApiKey(),
+      sessionId: msg.sessionId,
+      request,
+      source: `agent "${msg.name}"`,
+      csrfMode: deps.csrfMode ?? "strict"
+    });
+  }
+  return null;
+}
 async function serveMcpRoute(request, method, mcpName, deps) {
   if (method !== "POST") return null;
   const agent = deps.agents.find((a) => a.name === mcpName);
@@ -1307,7 +1745,7 @@ async function serveMcpRoute(request, method, mcpName, deps) {
   const csrfMode = deps.csrfMode ?? "strict";
   if (csrfMode === "strict") {
     const csrf = validateCsrfRequest(request);
-    if (!csrf.valid) return jsonError3(403, "CSRF_FAILED", `CSRF check failed: ${csrf.reason}`);
+    if (!csrf.valid) return jsonError4(403, "CSRF_FAILED", `CSRF check failed: ${csrf.reason}`);
   }
   let body = null;
   try {
@@ -1441,7 +1879,9 @@ async function serveAux(req, res, next, urlPath, deps) {
       agents: scanAgents(deps.projectRoot, deps.agentsDir),
       loadModule: deps.loadModule,
       baseUrl: `http://${req.headers.host ?? "localhost"}`,
-      csrfMode: deps.csrfMode
+      csrfMode: deps.csrfMode,
+      // M39 — the thread follow-up route drives the agent; resolve the key on demand.
+      resolveApiKey: () => resolveProvider().apiKey
     });
     if (response === null) {
       next();
@@ -3097,4 +3537,4 @@ export {
   theoPluginAsync,
   theoPlugin
 };
-//# sourceMappingURL=chunk-BLL5LY7R.js.map
+//# sourceMappingURL=chunk-2JNG3P4Y.js.map