theokit 0.48.13 → 0.50.0

package/dist/{chunk-GRI4XHBJ.js → chunk-JWRCZIA4.js}

@@ -12,21 +12,70 @@ import {
   RUN_ID_HEADER,
   SSE_BASE_HEADERS,
   SSE_DONE_FRAME,
+  admitAgentRequest,
+  agentAccessDenied,
   applySecurityHeaders,
+  closePauseSpan,
+  createServerContext,
   encodeSse,
   formatSseFrame,
-  generateNonce,
   getRunEventCache,
   makeThreadStartRun,
   mintRunId,
-  parseAgentRequestBody
-} from "./chunk-BIVCP6X5.js";
+  parseAgentRequestBody,
+  readAgentPolicy,
+  subjectFromContext
+} from "./chunk-C62IZEJI.js";
 import {
   getApprovalRegistry
-} from "./chunk-6GGWS7J3.js";
+} from "./chunk-5YPXXSYY.js";
 import {
+  sendError,
   validateCsrfRequest
-} from "./chunk-T5C46IIU.js";
+} from "./chunk-HWBRS4DZ.js";
+import {
+  generateNonce
+} from "./chunk-RPET332G.js";
+
+// src/config/resolve-plugin-specifiers.ts
+import { isAbsolute, resolve } from "path";
+import { pathToFileURL } from "url";
+var UnresolvablePluginSpecifierError = class extends Error {
+  constructor(index, specifier, reason) {
+    super(`plugins[${index}] (${specifier}) could not be loaded: ${reason}`);
+    this.name = "UnresolvablePluginSpecifierError";
+  }
+};
+async function resolvePluginSpecifiers(plugins, cwd) {
+  const resolved = [];
+  for (const [index, entry] of plugins.entries()) {
+    resolved.push(typeof entry === "string" ? await importPlugin(entry, index, cwd) : entry);
+  }
+  return resolved;
+}
+async function importPlugin(specifier, index, cwd) {
+  const target = isAbsolute(specifier) ? specifier : resolve(cwd, specifier);
+  let mod;
+  try {
+    mod = await import(
+      /* @vite-ignore */
+      pathToFileURL(target).href
+    );
+  } catch (err) {
+    throw new UnresolvablePluginSpecifierError(index, specifier, messageOf(err));
+  }
+  if (mod.default === void 0) {
+    throw new UnresolvablePluginSpecifierError(
+      index,
+      specifier,
+      "the module has no default export; a plugin module must `export default` its plugin"
+    );
+  }
+  return mod.default;
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
 
 // src/server/transformer.ts
 import superjson from "superjson";
@@ -121,7 +170,7 @@ function hoistHeadTags(template, ssrHtml) {
 
 // src/vite-plugin/ssr-dev-middleware.ts
 import { readFileSync } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 function applyNonceToInlineScripts(html, nonce) {
   return html.replace(
     /<script(?![^>]*\ssrc=)(?![^>]*\snonce=)([^>]*)>/gi,
@@ -142,7 +191,7 @@ function setupSsrDevMiddleware(server, opts) {
         return;
       }
       try {
-        const indexPath = resolve(opts.projectRoot, "index.html");
+        const indexPath = resolve2(opts.projectRoot, "index.html");
         let template = readFileSync(indexPath, "utf-8");
         const nonce = generateNonce();
         template = await server.transformIndexHtml(url, template);
@@ -244,6 +293,11 @@ function handleAgentCard(mod, name, route, baseUrl) {
 
 // src/server/agent/approve-agent.ts
 var APPROVE_SEGMENT = "/approve/";
+var APPROVE_PATH = /^\/api\/agents\/([^/]+)\/approve\/([^/]+)$/;
+function parseApprovalAgentName(urlPath) {
+  const match = APPROVE_PATH.exec(urlPath);
+  return match ? decodeURIComponent(match[1]) : null;
+}
 function parseApprovalId(urlPath) {
   const at = urlPath.indexOf(APPROVE_SEGMENT);
   if (at === -1) return null;
@@ -276,7 +330,17 @@ function parseApprovalBody(body) {
   }
   return decision;
 }
-async function handleAgentApproval(request, urlPath, registry, csrfMode = "strict") {
+async function refuseIfNotOwner(registry, approvalId, resolveSubject, params) {
+  const owner = registry.ownerOf(approvalId);
+  if (owner === void 0) return void 0;
+  const subject = resolveSubject === void 0 ? null : await resolveSubject();
+  if (subject?.id === owner) return void 0;
+  return agentAccessDenied(
+    { allowed: false, reason: "the approval belongs to another subject" },
+    params
+  );
+}
+async function handleAgentApproval(request, urlPath, registry, csrfMode = "strict", access = {}) {
   if (csrfMode !== "off") {
     const csrf = validateCsrfRequest(request);
     if (!csrf.valid && csrfMode === "strict") {
@@ -287,6 +351,15 @@ async function handleAgentApproval(request, urlPath, registry, csrfMode = "stric
   if (approvalId === null) {
     return jsonError(400, "BAD_REQUEST", "Approval path must be /api/agents/<name>/approve/<id>.");
   }
+  const params = {
+    agent: parseApprovalAgentName(urlPath) ?? "unknown",
+    endpoint: "approve",
+    approvalId
+  };
+  const decision = await admitAgentRequest(access.policy, access.resolveSubject, params);
+  if (!decision.allowed) return agentAccessDenied(decision, params);
+  const notOwner = await refuseIfNotOwner(registry, approvalId, access.resolveSubject, params);
+  if (notOwner !== void 0) return notOwner;
   let body = null;
   try {
     body = await request.json();
@@ -300,25 +373,13 @@ async function handleAgentApproval(request, urlPath, registry, csrfMode = "stric
   if (!resolved) {
     return jsonError(404, "NOT_PENDING", `No pending approval for id '${approvalId}'.`);
   }
+  closePauseSpan(approvalId, { resumeObserved: true });
   return new Response(JSON.stringify({ resolved: true }), {
     status: 200,
     headers: { "content-type": "application/json" }
   });
 }
 
-// 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/handle-agent-run-reconnect.ts
 var RUN_STREAM_PATH = /^\/api\/agents\/([^/]+)\/runs\/([^/]+)\/stream$/;
 function isAgentRunStreamPath(urlPath) {
@@ -483,7 +544,7 @@ function jsonError2(status, code, message) {
   });
 }
 async function handleThreadMessage(args) {
-  const { mod, apiKey, sessionId, request, source, csrfMode = "strict" } = args;
+  const { mod, apiKey, sessionId, request, source, agentName, csrfMode = "strict" } = args;
   if (csrfMode === "strict") {
     const csrf = validateCsrfRequest(request);
     if (!csrf.valid) return jsonError2(403, "CSRF_FAILED", `CSRF check failed: ${csrf.reason}`);
@@ -501,7 +562,9 @@ async function handleThreadMessage(args) {
     {
       registry: getThreadRunRegistry(),
       cache: getRunEventCache(),
-      startRun: makeThreadStartRun(mod, apiKey, source)
+      // usetheokit/theokit#381 — the request goes with it, so the run's spans join the trace of
+      // the caller that queued it instead of opening one of their own.
+      startRun: makeThreadStartRun(mod, apiKey, source, agentName, request)
     },
     sessionId,
     input.message
@@ -579,6 +642,19 @@ function waitThenAttachStream(sessionId, request, registry, cache, idleWaitMs) {
   return new Response(stream, { headers: { ...SSE_BASE_HEADERS } });
 }
 
+// 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/serve-aux-routes.ts
 function jsonError3(status, code, message) {
   return new Response(JSON.stringify({ error: { code, message } }), {
@@ -586,71 +662,135 @@ function jsonError3(status, code, message) {
     headers: { "content-type": "application/json; charset=utf-8" }
   });
 }
-async function serveAgentAuxRoute(request, urlPath, deps) {
-  const method = request.method.toUpperCase();
-  const cardName = isAgentCardPath(urlPath);
-  if (cardName !== null) {
-    if (method !== "GET") return null;
-    const agent = deps.agents.find((a) => a.name === cardName);
-    if (!agent) return null;
-    const mod = await deps.loadModule(agent.filePath);
-    return handleAgentCard(mod, agent.name, agent.agentPath, deps.baseUrl);
-  }
-  if (isListApprovalsPath(urlPath)) {
-    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);
+function routeFor(deps, name, build) {
+  if (name === null) return null;
+  const agent = deps.agents.find((a) => a.name === name);
+  return agent === void 0 ? null : build(agent);
+}
+function matchGetAuxRoute(verb, urlPath, deps) {
+  if (verb !== "GET") return null;
+  const card = routeFor(
+    deps,
+    isAgentCardPath(urlPath),
+    (agent) => ({ kind: "card", agent })
+  );
+  if (card !== null) return card;
+  const approvals = routeFor(
+    deps,
+    isListApprovalsPath(urlPath),
+    (agent) => ({ kind: "approvals", agent })
+  );
+  if (approvals !== null) return approvals;
+  const run = isAgentRunStreamPath(urlPath);
+  if (run !== null) {
+    return routeFor(
+      deps,
+      run.name,
+      (agent) => ({ kind: "run-stream", agent, runId: run.runId })
+    );
   }
+  const stream = isThreadStreamPath(urlPath);
+  if (stream === null) return null;
+  return routeFor(
+    deps,
+    stream.name,
+    (agent) => ({ kind: "thread-stream", agent, sessionId: stream.sessionId })
+  );
+}
+async function matchPostAuxRoute(verb, urlPath, deps) {
+  if (verb !== "POST") return null;
   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 jsonError3(
-        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 routeFor(
+      deps,
+      msg.name,
+      (agent2) => ({ kind: "thread-message", agent: agent2, sessionId: msg.sessionId })
+    );
+  }
+  const agent = routeFor(deps, isMcpPath(urlPath), (found) => found);
+  if (agent === null) return null;
+  const mod = await deps.loadModule(agent.filePath);
+  return isMcpExposed(mod) ? { kind: "mcp", agent, mod } : null;
+}
+async function matchAgentAuxRoute(method, urlPath, deps) {
+  const verb = method.toUpperCase();
+  return matchGetAuxRoute(verb, urlPath, deps) ?? await matchPostAuxRoute(verb, urlPath, deps);
+}
+async function admitAux(deps, agent, params, body) {
+  const mod = await deps.loadModule(agent.filePath);
+  const decision = await admitAgentRequest(
+    readAgentPolicy(mod, agent.filePath),
+    deps.resolveSubject,
+    params,
+    body
+  );
+  return decision.allowed ? null : agentAccessDenied(decision, params);
+}
+async function serveMatchedAuxRoute(route, request, deps) {
+  if (route.kind === "card") {
+    const mod = await deps.loadModule(route.agent.filePath);
+    return handleAgentCard(mod, route.agent.name, route.agent.agentPath, deps.baseUrl);
+  }
+  if (route.kind === "approvals") {
+    const refusal = await admitAux(deps, route.agent, {
+      agent: route.agent.name,
+      endpoint: "approvals"
     });
+    return refusal ?? handleListApprovals(getApprovalRegistry());
   }
-  return null;
+  if (route.kind === "run-stream") {
+    return handleAgentRunReconnect(route.runId, request, getRunEventCache());
+  }
+  if (route.kind === "mcp") return serveMcpRoute(route, request, deps);
+  return serveThreadRoute(route, request, deps);
 }
-async function serveMcpRoute(request, method, mcpName, deps) {
-  if (method !== "POST") return null;
-  const agent = deps.agents.find((a) => a.name === mcpName);
-  if (!agent) return null;
+async function serveThreadRoute(route, request, deps) {
+  const { agent, sessionId } = route;
+  if (route.kind === "thread-stream") {
+    const refusal2 = await admitAux(deps, agent, {
+      agent: agent.name,
+      endpoint: "thread-stream",
+      sessionId
+    });
+    return refusal2 ?? handleThreadStream(sessionId, request);
+  }
+  const refusal = await admitAux(deps, agent, {
+    agent: agent.name,
+    endpoint: "thread-message",
+    sessionId
+  });
+  if (refusal !== null) return refusal;
+  if (deps.resolveApiKey === void 0) {
+    return jsonError3(
+      501,
+      "NOT_CONFIGURED",
+      "Thread follow-up requires a provider API key (resolveApiKey was not provided to serveMatchedAuxRoute)."
+    );
+  }
   const mod = await deps.loadModule(agent.filePath);
-  if (!isMcpExposed(mod)) return null;
+  return handleThreadMessage({
+    mod,
+    // Passed unresolved: `makeThreadStartRun` calls it once the module is compiled and the
+    // model is known (theokit#328).
+    apiKey: deps.resolveApiKey,
+    sessionId,
+    request,
+    source: `agent "${agent.name}"`,
+    // usetheokit/theokit#406 — the label above reads well in an `AgentDefinitionError` and is not
+    // a name; the spans get the name, so the same agent is one series whichever route started it.
+    agentName: agent.name,
+    csrfMode: deps.csrfMode ?? "strict"
+  });
+}
+async function serveMcpRoute(route, request, deps) {
+  const { agent, mod } = route;
+  const mcpParams = { agent: agent.name, endpoint: "mcp" };
+  const mcpDecision = await admitAgentRequest(
+    readAgentPolicy(mod, agent.filePath),
+    deps.resolveSubject,
+    mcpParams
+  );
+  if (!mcpDecision.allowed) return agentAccessDenied(mcpDecision, mcpParams);
   const csrfMode = deps.csrfMode ?? "strict";
   if (csrfMode === "strict") {
     const csrf = validateCsrfRequest(request);
@@ -667,46 +807,64 @@ function isMcpExposed(mod) {
   return mod?.mcp === true;
 }
 
-// src/server/http/node-web-adapter.ts
-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();
+// src/server/http/plugin-lifecycle.ts
+function messageOf2(err, fallback) {
+  return err instanceof Error ? err.message : fallback;
+}
+async function serveThroughPluginLifecycle(target, serve) {
+  const { res, requestId, pluginRunner, failureMessage } = target;
+  let request;
+  try {
+    request = target.source.toRequest();
+  } catch (err) {
+    sendError(res, "INTERNAL", messageOf2(err, failureMessage), 500, void 0, requestId);
     return;
   }
-  const reader = response.body.getReader();
+  const pluginCtx = { request, response: res, ctx: {}, requestId };
+  if (pluginRunner) {
+    pluginRunner.applyDecorations(pluginCtx.ctx);
+    const onRequest = await pluginRunner.runOnRequest(pluginCtx);
+    if (onRequest.shortCircuited) return;
+  }
   try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      res.write(value);
-    }
-    res.end();
-  } finally {
-    reader.releaseLock();
+    await serve(request, pluginCtx);
+  } catch (err) {
+    if (pluginRunner) await pluginRunner.runOnError(pluginCtx, err);
+    sendError(res, "INTERNAL", messageOf2(err, failureMessage), 500, void 0, requestId);
   }
+  if (pluginRunner) await pluginRunner.runOnResponse(pluginCtx);
+}
+
+// src/server/http/resolve-agent-subject.ts
+function createAgentSubjectResolver(sources) {
+  let pending;
+  return () => {
+    pending ??= resolve3(sources);
+    return pending;
+  };
+}
+async function resolve3(sources) {
+  const { req, res, loadModule, serverDir, pluginRunner } = sources;
+  const produced = serverDir === void 0 ? {} : await createServerContext(req, res, loadModule, serverDir);
+  const ctx = produced ?? {};
+  pluginRunner?.applyDecorations(ctx);
+  return subjectFromContext(ctx);
 }
 
 export {
+  resolvePluginSpecifiers,
   resolveTransformer,
   isAgentCardPath,
+  parseApprovalAgentName,
   isApprovalPath,
   handleAgentApproval,
-  isListApprovalsPath,
-  serveAgentAuxRoute,
-  writeWebResponseToServerResponse,
+  matchAgentAuxRoute,
+  serveMatchedAuxRoute,
+  serveThroughPluginLifecycle,
+  createAgentSubjectResolver,
   extractHeadTags,
   injectIntoHead,
   applyNonceToInlineScripts,
   setupSsrDevMiddleware
 };
-//# sourceMappingURL=chunk-GRI4XHBJ.js.map
+//# sourceMappingURL=chunk-JWRCZIA4.js.map