theokit 0.15.2 → 0.17.0

package/dist/{chunk-ZJDKAD3L.js → chunk-4FOPDXKT.js}

@@ -7,11 +7,11 @@ import {
   mountAgent,
   resolveTransformer,
   writeWebResponseToServerResponse
-} from "./chunk-OTFIRP6S.js";
+} from "./chunk-4JDYVNSY.js";
 import {
   getApprovalRegistry,
   resolveProvider
-} from "./chunk-NBWB4S46.js";
+} from "./chunk-M6NMS5LR.js";
 import {
   isRouteFile,
   scanRoutes
@@ -392,12 +392,268 @@ function createActionMiddleware(vite, serverDir, options) {
 
 // src/vite-plugin/agent-middleware.ts
 import { randomUUID as randomUUID2 } from "crypto";
+
+// src/server/agent/agent-card-handler.ts
+import {
+  buildAgentCard,
+  compileAgentModule
+} from "@theokit/agents";
+var WELL_KNOWN = /^\/\.well-known\/([^/]+)\/agent-card\.json$/;
+function isAgentCardPath(urlPath) {
+  const match = WELL_KNOWN.exec(urlPath);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function toManifestEntry(name, route, mod) {
+  const compiled = compileAgentModule(mod, `agent card for "${name}"`);
+  return {
+    name,
+    route,
+    stream: compiled.stream,
+    mainLoop: { method: "", strategy: "" },
+    guards: [],
+    interceptors: [],
+    tools: compiled.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      approval: false,
+      trace: false,
+      audit: false
+    })),
+    subAgents: []
+  };
+}
+function handleAgentCard(mod, name, route, baseUrl) {
+  try {
+    const card = buildAgentCard(toManifestEntry(name, route, mod), { baseUrl });
+    return new Response(JSON.stringify(card), {
+      status: 200,
+      headers: { "content-type": "application/json; charset=utf-8" }
+    });
+  } catch (err) {
+    return new Response(
+      JSON.stringify({ error: { code: "AGENT_CARD_FAILED", message: err instanceof Error ? err.message : "card build failed" } }),
+      { status: 500, headers: { "content-type": "application/json; charset=utf-8" } }
+    );
+  }
+}
+
+// src/server/agent/list-approvals-handler.ts
+var LIST_PATH = /^\/api\/agents\/([^/]+)\/approvals$/;
+function isListApprovalsPath(urlPath) {
+  const match = LIST_PATH.exec(urlPath);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function handleListApprovals(registry) {
+  return new Response(JSON.stringify({ approvals: registry.list() }), {
+    status: 200,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+
+// src/server/agent/mcp-handler.ts
+import {
+  buildMcpToolDescriptors,
+  compileAgentModule as compileAgentModule2,
+  mcpServerInfo
+} from "@theokit/agents";
+
+// src/server/agent/mcp-app-resources.ts
+function buildResourceDescriptors(resources) {
+  return resources.map((r) => ({
+    uri: r.uri,
+    name: r.name,
+    mimeType: r.mimeType,
+    ...r.description !== void 0 ? { description: r.description } : {}
+  }));
+}
+function readAppResource(resources, uri) {
+  const found = resources.find((r) => r.uri === uri);
+  if (!found) return null;
+  return { contents: [{ uri: found.uri, mimeType: "text/html", text: found.html }] };
+}
+
+// src/server/agent/mcp-handler.ts
+var MCP_PATH = /^\/api\/agents\/([^/]+)\/mcp$/;
+function isMcpPath(urlPath) {
+  const match = MCP_PATH.exec(urlPath);
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function isJsonRpcRequest(body) {
+  return typeof body === "object" && body !== null && body.jsonrpc === "2.0" && typeof body.method === "string";
+}
+function jsonResponse(payload) {
+  return new Response(JSON.stringify(payload), {
+    status: 200,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+function toEntry(name, mod) {
+  const compiled = compileAgentModule2(mod, `mcp server for "${name}"`);
+  return {
+    name,
+    route: `/api/agents/${name}`,
+    stream: compiled.stream,
+    mainLoop: { method: "", strategy: "" },
+    guards: [],
+    interceptors: [],
+    tools: compiled.tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      approval: false,
+      trace: false,
+      audit: false
+    })),
+    subAgents: []
+  };
+}
+function handleMcpJsonRpc(mod, name, body, appResources = []) {
+  if (!isJsonRpcRequest(body)) {
+    return jsonResponse({
+      jsonrpc: "2.0",
+      id: null,
+      error: { code: -32600, message: "Invalid Request" }
+    });
+  }
+  const { id, method, params } = body;
+  try {
+    const entry = toEntry(name, mod);
+    if (method === "initialize") {
+      const info = mcpServerInfo(entry);
+      const capabilities = { tools: {} };
+      if (appResources.length > 0) capabilities.resources = {};
+      return jsonResponse({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          protocolVersion: info.protocolVersion,
+          capabilities,
+          serverInfo: { name: info.name, version: info.version }
+        }
+      });
+    }
+    if (method === "tools/list") {
+      return jsonResponse({ jsonrpc: "2.0", id, result: { tools: buildMcpToolDescriptors(entry) } });
+    }
+    if (method === "resources/list") {
+      return jsonResponse({
+        jsonrpc: "2.0",
+        id,
+        result: { resources: buildResourceDescriptors(appResources) }
+      });
+    }
+    if (method === "resources/read") {
+      const uri = params?.uri;
+      if (typeof uri !== "string") {
+        return jsonResponse({
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32602, message: "resources/read requires a string `uri` param." }
+        });
+      }
+      const contents = readAppResource(appResources, uri);
+      if (contents === null) {
+        return jsonResponse({
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32602, message: `Resource not found: ${uri}` }
+        });
+      }
+      return jsonResponse({ jsonrpc: "2.0", id, result: contents });
+    }
+    return jsonResponse({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message: `Method not found: ${method}` }
+    });
+  } catch (err) {
+    return jsonResponse({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32603, message: err instanceof Error ? err.message : "Internal error" }
+    });
+  }
+}
+
+// src/vite-plugin/agent-middleware.ts
 var PREFIX2 = "/api/agents/";
+async function serveApprove(req, res, urlPath, csrfMode, log) {
+  const method = (req.method ?? "POST").toUpperCase();
+  if (method !== "POST") {
+    sendError(res, "METHOD_NOT_ALLOWED", "Approve endpoints accept POST", 405, void 0, log.requestId);
+    logRequest({ method, url: req.url ?? "", status: 405, duration: Date.now() - log.start, requestId: log.requestId });
+    return;
+  }
+  try {
+    const response = await handleAgentApproval(incomingMessageToWebRequest(req), urlPath, getApprovalRegistry(), csrfMode);
+    await writeWebResponseToServerResponse(response, res);
+  } catch (err) {
+    sendError(res, "INTERNAL", err instanceof Error ? err.message : "Approve handler failed", 500, void 0, log.requestId);
+  }
+  logRequest({ method, url: req.url ?? "", status: res.statusCode, duration: Date.now() - log.start, requestId: log.requestId });
+}
+async function serveMcp(req, res, next, mcpAgentName, deps) {
+  const requestId = randomUUID2();
+  const start = Date.now();
+  res.setHeader("x-request-id", requestId);
+  const method = (req.method ?? "POST").toUpperCase();
+  const agent = scanAgents(deps.projectRoot).find((a) => a.name === mcpAgentName);
+  if (method !== "POST" || !agent) {
+    next();
+    return;
+  }
+  try {
+    const body = await incomingMessageToWebRequest(req).json();
+    const mod = await deps.loadModule(agent.filePath);
+    await writeWebResponseToServerResponse(handleMcpJsonRpc(mod, agent.name, body), res);
+  } catch (err) {
+    sendError(res, "INTERNAL", err instanceof Error ? err.message : "MCP handler failed", 500, void 0, requestId);
+  }
+  logRequest({ method, url: req.url ?? "", status: res.statusCode, duration: Date.now() - start, requestId });
+}
+async function serveListApprovals(req, res, next, log) {
+  const method = (req.method ?? "GET").toUpperCase();
+  if (method !== "GET") {
+    next();
+    return;
+  }
+  await writeWebResponseToServerResponse(handleListApprovals(getApprovalRegistry()), res);
+  logRequest({
+    method,
+    url: req.url ?? "",
+    status: res.statusCode,
+    duration: Date.now() - log.start,
+    requestId: log.requestId
+  });
+}
+async function serveAgentCard(req, res, next, cardAgentName, deps) {
+  const requestId = randomUUID2();
+  const start = Date.now();
+  res.setHeader("x-request-id", requestId);
+  const method = (req.method ?? "GET").toUpperCase();
+  const agent = scanAgents(deps.projectRoot).find((a) => a.name === cardAgentName);
+  if (method !== "GET" || !agent) {
+    next();
+    return;
+  }
+  try {
+    const mod = await deps.loadModule(agent.filePath);
+    const baseUrl = `http://${req.headers.host ?? "localhost"}`;
+    await writeWebResponseToServerResponse(handleAgentCard(mod, agent.name, agent.agentPath, baseUrl), res);
+  } catch (err) {
+    sendError(res, "INTERNAL", err instanceof Error ? err.message : "Agent card failed", 500, void 0, requestId);
+  }
+  logRequest({ method, url: req.url ?? "", status: res.statusCode, duration: Date.now() - start, requestId });
+}
 function createAgentMiddleware(vite, projectRoot, csrfMode = "strict") {
   const loadModule = createViteLoader(vite);
   return (req, res, next) => {
     void (async () => {
       const url = req.url ?? "";
+      const cardAgentName = isAgentCardPath(url.split("?")[0]);
+      if (cardAgentName) {
+        await serveAgentCard(req, res, next, cardAgentName, { projectRoot, loadModule });
+        return;
+      }
       if (!url.startsWith(PREFIX2)) {
         next();
         return;
@@ -407,39 +663,16 @@ function createAgentMiddleware(vite, projectRoot, csrfMode = "strict") {
       res.setHeader("x-request-id", requestId);
       const urlPath = url.split("?")[0];
       if (isApprovalPath(urlPath)) {
-        const method2 = (req.method ?? "POST").toUpperCase();
-        if (method2 !== "POST") {
-          sendError(
-            res,
-            "METHOD_NOT_ALLOWED",
-            "Approve endpoints accept POST",
-            405,
-            void 0,
-            requestId
-          );
-          logRequest({ method: method2, url, status: 405, duration: Date.now() - start, requestId });
-          return;
-        }
-        try {
-          const request = incomingMessageToWebRequest(req);
-          const response = await handleAgentApproval(
-            request,
-            urlPath,
-            getApprovalRegistry(),
-            csrfMode
-          );
-          await writeWebResponseToServerResponse(response, res);
-        } catch (err) {
-          sendError(
-            res,
-            "INTERNAL",
-            err instanceof Error ? err.message : "Approve handler failed",
-            500,
-            void 0,
-            requestId
-          );
-        }
-        logRequest({ method: method2, url, status: res.statusCode, duration: Date.now() - start, requestId });
+        await serveApprove(req, res, urlPath, csrfMode, { requestId, start });
+        return;
+      }
+      if (isListApprovalsPath(urlPath)) {
+        await serveListApprovals(req, res, next, { requestId, start });
+        return;
+      }
+      const mcpAgentName = isMcpPath(urlPath);
+      if (mcpAgentName) {
+        await serveMcp(req, res, next, mcpAgentName, { projectRoot, loadModule });
         return;
       }
       const agent = scanAgents(projectRoot).find((a) => a.agentPath === urlPath);
@@ -1853,7 +2086,7 @@ async function theoPluginAsync(rootOrOptions) {
     serverDir: resolve7(projectRoot, "server"),
     distDir: resolve7(projectRoot, ".theokit")
   });
-  const { agentsTypedClientPlugin } = await import("./agents-typed-client-UTEQUA63.js");
+  const { agentsTypedClientPlugin } = await import("./agents-typed-client-LQ36PCHL.js");
   const { generateManifest } = await import("./internal-api-J27TYE2I.js");
   const agentsClientPlugin = agentsTypedClientPlugin({
     projectRoot,
@@ -2024,4 +2257,4 @@ export {
   theoPluginAsync,
   theoPlugin
 };
-//# sourceMappingURL=chunk-ZJDKAD3L.js.map
+//# sourceMappingURL=chunk-4FOPDXKT.js.map