theokit 0.24.0 → 0.25.0

package/dist/{agent-7474NDZD.js → agent-GXJNFW6N.js}

@@ -3,7 +3,7 @@ import "tsx/esm";
 import {
   agentCommand,
   createAgentSsrLoader
-} from "./chunk-ZGKGXXZG.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-7474NDZD.js.map
+//# sourceMappingURL=agent-GXJNFW6N.js.map

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

@@ -531,7 +531,7 @@ async function buildCommand(options) {
 `);
 }
 async function runAdapterBuild(target, config, cwd) {
-  const { theoPluginAsync } = await import("./vite-plugin-HSOWPMK4.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-CVWAK4UE.js.map
+//# sourceMappingURL=build-WD2PT5TA.js.map

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

@@ -1155,11 +1155,43 @@ 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 = {
@@ -1216,6 +1248,9 @@ function createInMemoryRunEventCache(opts = {}) {
     return buf;
   }
   return {
+    begin(runId) {
+      getOrCreate(runId);
+    },
     append(runId, data) {
       const buf = getOrCreate(runId);
       const seq = buf.frames.length;
@@ -1313,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;
@@ -1327,23 +1362,10 @@ 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;
+  const hitl = buildAgentHitl(compiled);
   const runId = mintRunId();
   return durableUiMessageStreamResponse(
-    streamAgentUIMessages(compiled, apiKey, { ...input, hitl, signal: request.signal }),
+    streamAgentUIMessages2(compiled, apiKey, { ...input, hitl, signal: request.signal }),
     { runId, cache: getRunEventCache() }
   );
 }
@@ -1459,13 +1481,202 @@ function handleAgentRunReconnect(runId, request, cache) {
   return new Response(stream, { headers: { ...SSE_BASE_HEADERS, [RUN_ID_HEADER]: runId } });
 }
 
-// src/server/agent/serve-aux-routes.ts
+// 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);
@@ -1486,12 +1697,45 @@ async function serveAgentAuxRoute(request, urlPath, deps) {
     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);
@@ -1501,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 {
@@ -1635,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();
@@ -3291,4 +3537,4 @@ export {
   theoPluginAsync,
   theoPlugin
 };
-//# sourceMappingURL=chunk-FARW5PH6.js.map
+//# sourceMappingURL=chunk-2JNG3P4Y.js.map