theokit 0.12.0 → 0.13.0

package/dist/{chunk-7CBRKNQA.js → chunk-RYTZYFSD.js}

@@ -8,7 +8,7 @@ import {
 import {
   loadEnv,
   resolveTransformer
-} from "./chunk-PIVX3DYW.js";
+} from "./chunk-3S3BNW5K.js";
 import {
   BATCH_PATH,
   TRACE_HEADER,
@@ -36,10 +36,11 @@ import {
 } from "./chunk-JQSKBMXP.js";
 import {
   matchRoute,
+  scanAgents,
   scanServerActions,
   scanServerRoutes,
   scanWebSocketRoutes
-} from "./chunk-223EFY5X.js";
+} from "./chunk-2J7XU3PW.js";
 import {
   CSP_REPORT_PATH,
   CsrfReadinessStore,
@@ -47,12 +48,21 @@ import {
   handleCspReport,
   handleCsrfReadiness
 } from "./chunk-JBCHWRKF.js";
+import {
+  validateCsrfRequest
+} from "./chunk-TSLSIRBR.js";
+import {
+  resolveProvider
+} from "./chunk-EXP56GFQ.js";
 import {
   generateNonce
 } from "./chunk-C3ZZ56YZ.js";
 import {
   importUserModule
 } from "./chunk-7MQOHNHE.js";
+import {
+  uiMessageStreamResponse
+} from "./chunk-NHJMZCAS.js";
 
 // src/vite-plugin/index.ts
 import { existsSync as existsSync9 } from "fs";
@@ -974,6 +984,177 @@ function createActionMiddleware(vite, serverDir, options) {
   };
 }
 
+// src/vite-plugin/agent-middleware.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/server/agent/mount-agent.ts
+import { compileAgentModule, streamAgentUIMessages } from "@theokit/agents";
+function partText(part) {
+  if (typeof part !== "object" || part === null) return "";
+  const p = part;
+  return p.type === "text" && typeof p.text === "string" ? p.text : "";
+}
+function jsonError(status, code, message) {
+  return new Response(JSON.stringify({ error: { code, message } }), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+function parseAgentRequestBody(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const b = body;
+  if (Array.isArray(b.messages) && b.messages.length > 0) {
+    const last = b.messages[b.messages.length - 1];
+    const parts = Array.isArray(last.parts) ? last.parts : [];
+    const text = parts.map(partText).join("");
+    if (text.length === 0) return null;
+    const sessionId = typeof b.id === "string" && b.id.length > 0 ? b.id : crypto.randomUUID();
+    return { message: text, sessionId };
+  }
+  if (typeof b.message === "string" && b.message.length > 0) {
+    const sessionId = typeof b.sessionId === "string" && b.sessionId.length > 0 ? b.sessionId : crypto.randomUUID();
+    return { message: b.message, sessionId };
+  }
+  return null;
+}
+async function mountAgent(mod, request, apiKey, source = "agent module", csrfMode = "strict") {
+  if (csrfMode !== "off") {
+    const csrf = validateCsrfRequest(request);
+    if (!csrf.valid && csrfMode === "strict") {
+      return jsonError(403, "CSRF_FAILED", `CSRF check failed: ${csrf.reason}`);
+    }
+  }
+  const compiled = compileAgentModule(mod, source);
+  let body = null;
+  try {
+    body = await request.json();
+  } catch {
+  }
+  const input = parseAgentRequestBody(body);
+  if (input === null) {
+    return jsonError(400, "BAD_REQUEST", "Request must contain a non-empty message or messages[].");
+  }
+  return uiMessageStreamResponse(streamAgentUIMessages(compiled, apiKey, input));
+}
+
+// src/server/http/node-web-adapter.ts
+import { Readable } from "stream";
+function incomingMessageToWebRequest(req) {
+  const host = pickHeaderString(req.headers.host) ?? "localhost";
+  const url = `http://${host}${req.url ?? "/"}`;
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      headers.set(key, value.join(", "));
+    } else {
+      headers.set(key, value);
+    }
+  }
+  const method = (req.method ?? "GET").toUpperCase();
+  const hasBody = method !== "GET" && method !== "HEAD";
+  if (!hasBody) {
+    return new Request(url, { method, headers });
+  }
+  const webStream = Readable.toWeb(req);
+  return new Request(url, {
+    method,
+    headers,
+    body: webStream,
+    // EC-2: Node 18+ requires `duplex: 'half'` when body is a stream.
+    // The `RequestInit` type omits it (Web spec gap); cast accordingly.
+    ...{ duplex: "half" }
+  });
+}
+async function writeWebResponseToServerResponse(response, res) {
+  const setCookies = response.headers.getSetCookie();
+  if (setCookies.length > 0) {
+    res.setHeader("Set-Cookie", setCookies);
+  }
+  const otherHeaders = {};
+  for (const [key, value] of response.headers.entries()) {
+    if (key.toLowerCase() === "set-cookie") continue;
+    otherHeaders[key] = value;
+  }
+  res.writeHead(response.status, response.statusText, otherHeaders);
+  if (response.body === null) {
+    res.end();
+    return;
+  }
+  const reader = response.body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      res.write(value);
+    }
+    res.end();
+  } finally {
+    reader.releaseLock();
+  }
+}
+function pickHeaderString(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    for (const v of value) if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+
+// src/vite-plugin/agent-middleware.ts
+var PREFIX2 = "/api/agents/";
+function createAgentMiddleware(vite, projectRoot, csrfMode = "strict") {
+  const loadModule = createViteLoader(vite);
+  return (req, res, next) => {
+    void (async () => {
+      const url = req.url ?? "";
+      if (!url.startsWith(PREFIX2)) {
+        next();
+        return;
+      }
+      const requestId = randomUUID2();
+      const start = Date.now();
+      res.setHeader("x-request-id", requestId);
+      const urlPath = url.split("?")[0];
+      const agent = scanAgents(projectRoot).find((a) => a.agentPath === urlPath);
+      if (!agent) {
+        next();
+        return;
+      }
+      const method = (req.method ?? "POST").toUpperCase();
+      if (method !== "POST") {
+        sendError(
+          res,
+          "METHOD_NOT_ALLOWED",
+          "Agent endpoints accept POST",
+          405,
+          void 0,
+          requestId
+        );
+        logRequest({ method, url, status: 405, duration: Date.now() - start, requestId });
+        return;
+      }
+      try {
+        const mod = await loadModule(agent.filePath);
+        const apiKey = resolveProvider().apiKey;
+        const request = incomingMessageToWebRequest(req);
+        const response = await mountAgent(mod, request, apiKey, agent.filePath, csrfMode);
+        await writeWebResponseToServerResponse(response, res);
+      } catch (err) {
+        sendError(
+          res,
+          "INTERNAL",
+          err instanceof Error ? err.message : "Agent handler failed",
+          500,
+          void 0,
+          requestId
+        );
+      }
+      logRequest({ method, url, status: res.statusCode, duration: Date.now() - start, requestId });
+    })();
+  };
+}
+
 // src/vite-plugin/api-middleware.ts
 function shouldBypassApiMiddleware(url, prefixes) {
   if (!url.startsWith("/api/")) return true;
@@ -1303,6 +1484,7 @@ async function runConfigureServer(server, ctx) {
       disallowed: ctx.disallowed
     })
   );
+  server.middlewares.use(createAgentMiddleware(server, ctx.projectRoot, ctx.csrfMode));
   const servicesProxyPrefixes = ctx.services && Object.keys(ctx.services).length > 0 ? Object.values(ctx.services).map((s) => s.proxy) : [];
   const csrfReadinessStore = ctx.csrfReadinessStoreOverride ?? new CsrfReadinessStore();
   server.middlewares.use(
@@ -1348,7 +1530,7 @@ async function runConfigureServer(server, ctx) {
   server.watcher.on("unlink", handleRouteChange);
   if (ctx.resolvedOpenApi !== void 0) {
     const openApiCfg = ctx.resolvedOpenApi;
-    const { reEmitOpenApi } = await import("./dev-emit-O4EGOSNV.js");
+    const { reEmitOpenApi } = await import("./dev-emit-QH2YGZXN.js");
     const openApiServerDir = resolve6(ctx.projectRoot, "server");
     const openApiDistDir = resolve6(ctx.projectRoot, ctx.resolvedDistDir);
     const isRouteFileForOpenApi = (file) => file.startsWith(openApiServerDir) && /\.(ts|tsx|js|mjs)$/.test(file);
@@ -2334,17 +2516,26 @@ async function theoPluginAsync(rootOrOptions) {
       })
     );
   }
-  const { appTypedClientPlugin } = await import("./app-typed-client-5GYEOYP3.js");
+  const { appTypedClientPlugin } = await import("./app-typed-client-7PBFWZUE.js");
   const appClientPlugin = appTypedClientPlugin({
     cwd: projectRoot,
     serverDir: resolve9(projectRoot, "server"),
     distDir: resolve9(projectRoot, ".theokit")
   });
-  const { actionsVirtualModule } = await import("./actions-virtual-module-PNPRCEOS.js");
+  const { actionsVirtualModule } = await import("./actions-virtual-module-EIPXX4ZB.js");
   const actionsPlugin = actionsVirtualModule({
     serverDir: resolve9(projectRoot, "server"),
     distDir: resolve9(projectRoot, ".theokit")
   });
+  const { agentsTypedClientPlugin } = await import("./agents-typed-client-SAWAAH7K.js");
+  const { generateManifest } = await import("./internal-api-4YTJDITC.js");
+  const agentsClientPlugin = agentsTypedClientPlugin({
+    projectRoot,
+    distDir: resolve9(projectRoot, ".theokit"),
+    // Agents live at <projectRoot>/agents; generateManifest scans them via the server dir's
+    // parent, which is projectRoot for the canonical layout.
+    scanManifest: () => generateManifest(resolve9(projectRoot, "server"), projectRoot)
+  });
   const { serverRoutesHmrPlugin } = await import("./server-routes-hmr-PBHSKCQJ.js");
   const routesHmrPlugin = serverRoutesHmrPlugin({
     serverDir: resolve9(projectRoot, "server")
@@ -2355,6 +2546,7 @@ async function theoPluginAsync(rootOrOptions) {
     ...servicesPlugins,
     appClientPlugin,
     actionsPlugin,
+    agentsClientPlugin,
     routesHmrPlugin
   ];
 }
@@ -2514,4 +2706,4 @@ export {
   theoPluginAsync,
   theoPlugin
 };
-//# sourceMappingURL=chunk-7CBRKNQA.js.map
+//# sourceMappingURL=chunk-RYTZYFSD.js.map