theokit 0.48.13 → 0.50.0

package/dist/chunk-WOBSEO75.js

@@ -0,0 +1,790 @@
+import {
+  createObservabilityPlugin,
+  requestTrace,
+  resolveAdapter
+} from "./chunk-MCTC6HSE.js";
+import {
+  createLogger,
+  warnOnce
+} from "./chunk-72DMJBXI.js";
+import {
+  validateCsrfRequest
+} from "./chunk-P6OS7652.js";
+import {
+  processSingleton
+} from "./chunk-3PBAN2YE.js";
+import {
+  newSpanId,
+  newTraceId
+} from "./chunk-UMNXCU3K.js";
+import {
+  evaluateRoutePolicy
+} from "./chunk-YN4W7LCX.js";
+
+// src/server/agent/mount-agent.ts
+import { compileAgentModule as compileAgentModule2, resolveEnabledSkills as resolveEnabledSkills2, streamAgentUIMessages as streamAgentUIMessages2 } from "@theokit/agents";
+
+// src/server/agent/agent-access.ts
+var AgentPolicyTypeError = class extends Error {
+  constructor(source, actual) {
+    super(
+      `Agent "${source}" exports a \`policy\` of type ${actual}. A policy is the string 'public' or a function ({ subject, body, params }) => boolean | AccessDecision. Import \`requireOwner\` from 'theokit/server/define' to write the owner check.`
+    );
+    this.name = "AgentPolicyTypeError";
+  }
+};
+function readAgentPolicy(mod, source) {
+  const declared = typeof mod === "object" && mod !== null ? mod.policy : void 0;
+  if (declared === void 0) return void 0;
+  if (declared !== "public" && typeof declared !== "function") {
+    throw new AgentPolicyTypeError(source, declared === null ? "null" : typeof declared);
+  }
+  return declared;
+}
+var log = createLogger({ context: { scope: "theokit:agent-access" } });
+async function admitAgentRequest(policy, resolveSubject, params, body) {
+  if (policy === void 0 || policy === "public") return { allowed: true };
+  const subject = resolveSubject === void 0 ? null : await resolveSubject();
+  return evaluateRoutePolicy(policy, { subject, query: void 0, body, params });
+}
+function agentAccessDenied(decision, params) {
+  if (!decision.allowed) {
+    log.warn("agent endpoint refused a caller", {
+      agent: params.agent,
+      endpoint: params.endpoint,
+      reason: decision.reason
+    });
+  }
+  return new Response(
+    JSON.stringify({
+      error: {
+        code: "FORBIDDEN",
+        message: `Access denied by the policy exported from agent "${params.agent}". Send the credential your app turns into \`ctx.subject\` in server/context.ts; the server log records which check refused this request.`
+      }
+    }),
+    { status: 403, headers: { "content-type": "application/json; charset=utf-8" } }
+  );
+}
+
+// src/server/agent/build-agent-streamer.ts
+import {
+  compileAgentModule,
+  resolveEnabledSkills,
+  streamAgentUIMessages
+} from "@theokit/agents";
+
+// src/server/agent/approval-registry.ts
+function getApprovalRegistry() {
+  return processSingleton("approval-registry", () => createInProcessApprovalRegistry());
+}
+function createInProcessApprovalRegistry() {
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    register(approvalId, opts) {
+      return new Promise((resolve) => {
+        const settle = (decision) => {
+          const entry = pending.get(approvalId);
+          if (!entry) return;
+          clearTimeout(entry.timer);
+          pending.delete(approvalId);
+          resolve(decision);
+        };
+        const timer = setTimeout(() => {
+          settle({
+            approved: opts.onTimeout === "proceed",
+            settledBy: "timeout",
+            // Every value in this sentence was already here and none of it used to survive the
+            // settle. `onTimeout` is named because all three of its values reach this line and two
+            // of them deny — an operator who wrote `'retry'` and got a denial had nothing to read
+            // that mentioned retry.
+            reason: `no decision within ${String(opts.timeoutMs)} ms; onTimeout: '${opts.onTimeout}' was applied`
+          });
+        }, opts.timeoutMs);
+        const info = {
+          approvalId,
+          toolName: opts.toolName,
+          question: opts.question,
+          expiresAt: Date.now() + opts.timeoutMs,
+          ...opts.payloadSchema !== void 0 ? { payloadSchema: opts.payloadSchema } : {}
+        };
+        pending.set(approvalId, {
+          settle,
+          timer,
+          info,
+          ...opts.owner !== void 0 ? { owner: opts.owner } : {}
+        });
+      });
+    },
+    resolve(approvalId, decision) {
+      const entry = pending.get(approvalId);
+      if (!entry) return false;
+      entry.settle(typeof decision === "boolean" ? { approved: decision } : decision);
+      return true;
+    },
+    list() {
+      return [...pending.values()].map((p) => p.info);
+    },
+    ownerOf(approvalId) {
+      return pending.get(approvalId)?.owner;
+    }
+  };
+}
+
+// src/config/schemas/rate-limit.ts
+import { z } from "zod";
+var baseRateLimitSchema = z.object({
+  windowMs: z.number().min(1),
+  max: z.number().int().min(1)
+});
+var rateLimitSchema = z.union([
+  baseRateLimitSchema,
+  z.object({
+    default: baseRateLimitSchema.optional(),
+    routes: z.record(z.string(), baseRateLimitSchema).optional(),
+    keyBy: z.union([
+      z.enum(["ip", "session", "user"]),
+      z.function({ input: z.tuple([z.unknown()]), output: z.string() })
+    ]).optional(),
+    cookieName: z.string().min(1).optional(),
+    /**
+     * How many reverse proxies sit in front of the app, for `keyBy: 'ip'`. `false` (default)
+     * trusts none; `true` means one; a number names a longer chain.
+     *
+     * Required for correct limiting behind Caddy/nginx/a load balancer — without it every visitor
+     * keys on the proxy address and shares a single bucket. Off by default because
+     * `x-forwarded-for` is client-writable.
+     */
+    trustProxy: z.union([z.boolean(), z.number().int().min(0)]).optional()
+  })
+]);
+
+// src/config/schemas/upload.ts
+import { z as z2 } from "zod";
+var uploadSchema = z2.object({
+  maxFileSize: z2.number().min(1).default(10 * 1024 * 1024),
+  // 10MB
+  maxFiles: z2.number().int().min(1).default(10),
+  maxFieldSize: z2.number().min(1).default(1 * 1024 * 1024)
+  // 1MB
+});
+
+// src/config/schemas/logging.ts
+import { z as z3 } from "zod";
+var loggingSchema = z3.object({
+  level: z3.enum(["debug", "info", "warn", "error", "silent"]).default("info")
+});
+
+// src/config/schemas/cache.ts
+import { z as z4 } from "zod";
+var routeRuleSchema = z4.object({
+  maxAge: z4.number().nonnegative().optional(),
+  swr: z4.number().nonnegative().optional(),
+  tags: z4.array(z4.string()).optional()
+});
+var cacheSchema = z4.object({
+  enabled: z4.boolean().default(true),
+  /** 'memory' uses InMemoryCacheAdapter; otherwise pass a custom adapter instance. */
+  storage: z4.union([z4.literal("memory"), z4.custom()]).default("memory"),
+  maxEntries: z4.number().int().positive().default(1e3),
+  defaults: z4.object({
+    maxAge: z4.number().nonnegative().default(1),
+    swr: z4.number().nonnegative().optional(),
+    cacheErrors: z4.boolean().default(false)
+  }).default({ maxAge: 1, cacheErrors: false }),
+  keyDerivation: z4.object({
+    excludeQuery: z4.array(z4.string()).optional(),
+    sortQuery: z4.boolean().default(true),
+    lowercaseHost: z4.boolean().default(true)
+  }).default({ sortQuery: true, lowercaseHost: true }),
+  routeRules: z4.record(z4.string(), routeRuleSchema).optional()
+});
+
+// src/config/schemas/observability.ts
+import { z as z5 } from "zod";
+var observabilitySchema = z5.object({
+  /** Set `false` to opt out even when the environment would enable an exporter. */
+  enabled: z5.boolean().default(true),
+  /**
+   * An `ObservabilityAdapter` instance. Validated structurally rather than by
+   * shape, for the same reason `storage` and `plugins` are: the config layer
+   * cannot import the adapter contract without inverting the module graph, and
+   * the adapter is a live object rather than data.
+   */
+  provider: z5.custom().optional()
+});
+
+// src/config/schemas/security.ts
+import { z as z7 } from "zod";
+
+// src/config/schemas/header-safe.ts
+import { z as z6 } from "zod";
+var headerSafeString = z6.string().refine((s) => !/[\r\n]/.test(s), { message: "Header value must not contain CR/LF" });
+
+// src/config/schemas/security.ts
+var securityHeadersSchema = z7.object({
+  csp: z7.union([headerSafeString, z7.literal(false)]).optional(),
+  // T6.1 — default flipped from 'report-only' to 'enforce' for 0.3.0.
+  // Users who want the old behaviour set `cspMode: 'report-only'`
+  // explicitly.
+  cspMode: z7.enum(["enforce", "report-only", "off"]).default("enforce"),
+  hsts: z7.union([headerSafeString, z7.literal(false)]).optional(),
+  frameOptions: z7.enum(["DENY", "SAMEORIGIN"]).default("DENY"),
+  contentTypeOptions: z7.literal("nosniff").default("nosniff"),
+  referrerPolicy: headerSafeString.default("strict-origin-when-cross-origin"),
+  /**
+   * T1.1 — Permissions-Policy directive string. EC-3-refined: rejects CR/LF.
+   * Pass `false` to suppress the header.
+   */
+  permissionsPolicy: z7.union([headerSafeString, z7.literal(false)]).optional()
+});
+var disallowedConfigSchema = z7.object({
+  routes: z7.array(z7.union([z7.string(), z7.instanceof(RegExp)])),
+  behavior: z7.enum(["warn", "raise"]).default("raise")
+});
+var corsSchema = z7.object({
+  origins: z7.union([
+    z7.literal("*"),
+    headerSafeString,
+    z7.instanceof(RegExp),
+    z7.array(z7.union([headerSafeString, z7.instanceof(RegExp)])),
+    z7.function({ input: z7.tuple([z7.string()]), output: z7.boolean() })
+  ]),
+  methods: z7.array(z7.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"])).optional(),
+  allowedHeaders: z7.array(headerSafeString).optional(),
+  exposedHeaders: z7.array(headerSafeString).optional(),
+  credentials: z7.boolean().default(false),
+  maxAge: z7.number().int().min(0).max(86400).default(600)
+}).refine((c) => !(c.origins === "*" && c.credentials), {
+  message: 'CORS spec forbids origins:"*" with credentials:true \u2014 browsers ignore the wildcard'
+});
+var securitySchema = z7.object({
+  // T6.1 — default flipped from 'warn' to 'strict' for 0.3.0. Apps that
+  // grep their warn-mode logs from 0.2.x already know which endpoints
+  // break; opt back into 'warn' globally OR use disallowedRoutes for
+  // surgical migration.
+  csrf: z7.enum(["off", "warn", "strict"]).default("strict"),
+  headers: securityHeadersSchema.optional(),
+  /** T5.1 — per-route escalation (Rails disallowed_warnings pattern). */
+  disallowed: disallowedConfigSchema.optional(),
+  /** T1.2 — Cross-Origin Resource Sharing. Single global config; runs first in pipeline. */
+  cors: corsSchema.optional()
+});
+
+// src/config/schemas/storage.ts
+import { z as z8 } from "zod";
+var tlsConfigSchema = z8.object({
+  rejectUnauthorized: z8.boolean().optional(),
+  caCert: z8.string().optional(),
+  clientCert: z8.string().optional(),
+  clientKey: z8.string().optional()
+});
+var serverConfigSchema = z8.object({
+  host: z8.string().min(1),
+  port: z8.number().int().positive().max(65535).optional(),
+  user: z8.string().min(1),
+  /** Password may be the empty string (some providers permit it). */
+  password: z8.string(),
+  tls: tlsConfigSchema.optional()
+});
+var postgresPoolConfigSchema = z8.object({
+  min: z8.number().int().nonnegative().optional(),
+  max: z8.number().int().positive().optional(),
+  connectionTimeoutMillis: z8.number().int().positive().optional(),
+  idleTimeoutMillis: z8.number().int().nonnegative().optional()
+});
+var postgresDatabaseConfigSchema = z8.object({
+  /** References a key in `storage.servers`. Resolved at `usePostgres()` call time. */
+  server: z8.string().min(1),
+  database: z8.string().min(1),
+  pool: postgresPoolConfigSchema.optional()
+});
+var redisServerConfigSchema = serverConfigSchema.extend({
+  db: z8.number().int().nonnegative().optional(),
+  maxRetriesPerRequest: z8.number().int().nonnegative().optional()
+});
+var storageSchema = z8.object({
+  servers: z8.record(z8.string(), serverConfigSchema).optional(),
+  databases: z8.record(z8.string(), postgresDatabaseConfigSchema).optional(),
+  redis: z8.record(z8.string(), redisServerConfigSchema).optional()
+});
+
+// src/server/observability-bootstrap.ts
+var activeAdapter;
+function getObservabilityAdapter() {
+  return activeAdapter;
+}
+function createObservabilityPluginFromConfig(observabilityConfig, env) {
+  const parsed = observabilityConfig === void 0 || observabilityConfig === null ? void 0 : observabilitySchema.parse(observabilityConfig);
+  if (parsed?.enabled === false) return void 0;
+  const cloudConfigured = Boolean(env.THEO_CLOUD_INGEST_URL) && Boolean(env.THEO_CLOUD_API_KEY);
+  if (parsed === void 0 && !cloudConfigured) return void 0;
+  const adapter = resolveAdapter({
+    env,
+    config: { provider: parsed?.provider }
+  });
+  if (adapter.name === "noop") {
+    if (parsed !== void 0) {
+      warnOnce("observability.no_exporter", {
+        event: "observability.no_exporter",
+        message: "observability is configured but no exporter resolved, so no spans will be recorded. Set THEO_CLOUD_INGEST_URL and THEO_CLOUD_API_KEY, or pass observability.provider with your own adapter. In development, NODE_ENV=development resolves the console exporter."
+      });
+    }
+    return void 0;
+  }
+  activeAdapter = adapter;
+  return createObservabilityPlugin(adapter);
+}
+
+// src/server/agent/hitl-pause-spans.ts
+var pauseSpans = /* @__PURE__ */ new Map();
+function registerPauseSpan(approvalId, span) {
+  pauseSpans.set(approvalId, span);
+}
+function closePauseSpan(approvalId, { resumeObserved }) {
+  const span = pauseSpans.get(approvalId);
+  if (span === void 0) return;
+  pauseSpans.delete(approvalId);
+  span.setAttribute("hitl.resume_observed", resumeObserved);
+  if (resumeObserved) span.setStatus("ok");
+  else
+    span.setStatus("error", "HITL pause never observed to resume; duration is not the human wait");
+  span.end();
+}
+
+// src/server/agent/observe-agent-run.ts
+var TOKEN_FIELDS = [
+  ["inputTokens", "tokens.input"],
+  ["outputTokens", "tokens.output"],
+  ["totalTokens", "tokens.total"],
+  ["reasoningTokens", "tokens.reasoning"],
+  ["cacheReadTokens", "tokens.cache_read"],
+  ["cacheWriteTokens", "tokens.cache_write"]
+];
+var STOP_REASONS = /* @__PURE__ */ new Set(["step_limit", "no_progress"]);
+var GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+function recordModel(span, metadata) {
+  if (metadata === null || typeof metadata !== "object") return;
+  const model = metadata.model;
+  if (typeof model === "string" && model.length > 0) span.setAttribute(GEN_AI_REQUEST_MODEL, model);
+}
+function recordStopReason(span, metadata) {
+  if (metadata === null || typeof metadata !== "object") return;
+  const reason = metadata.stopReason;
+  if (typeof reason === "string" && STOP_REASONS.has(reason)) {
+    span.setAttribute("stop.reason", reason);
+  }
+}
+function recordTokenUsage(span, metadata) {
+  if (metadata === null || typeof metadata !== "object") return;
+  const bag = metadata;
+  if (typeof bag.cost === "number") span.setAttribute("cost.usd", bag.cost);
+  const usage = bag.usage;
+  if (usage === null || usage === void 0 || typeof usage !== "object") return;
+  const fields = usage;
+  for (const [field, attribute] of TOKEN_FIELDS) {
+    const value = fields[field];
+    if (typeof value === "number") span.setAttribute(attribute, value);
+  }
+}
+function childOf(state) {
+  return { traceId: state.traceId, parentSpanId: state.runSpanId };
+}
+function openToolSpan(state, adapter, chunk) {
+  const id = chunk.toolCallId;
+  if (id === void 0) return;
+  const tool = chunk.toolName ?? "unknown";
+  state.toolNames.set(id, tool);
+  state.tools.set(
+    id,
+    adapter.startSpan("agent.tool", { agent: state.agent, tool, toolCallId: id }, childOf(state))
+  );
+}
+function openPauseSpan(state, adapter, chunk) {
+  const id = chunk.toolCallId;
+  const approvalId = chunk.approvalId;
+  if (id === void 0 || approvalId === void 0) return;
+  const pauseSpan = adapter.startSpan(
+    "agent.hitl",
+    {
+      agent: state.agent,
+      tool: state.toolNames.get(id) ?? "unknown",
+      approvalId,
+      toolCallId: id
+    },
+    childOf(state)
+  );
+  state.pauses.set(id, approvalId);
+  registerPauseSpan(approvalId, pauseSpan);
+}
+function closeToolSpan(state, chunk) {
+  const id = chunk.toolCallId;
+  if (id === void 0) return;
+  const pausedApprovalId = state.pauses.get(id);
+  if (pausedApprovalId !== void 0) {
+    closePauseSpan(pausedApprovalId, { resumeObserved: true });
+    state.pauses.delete(id);
+  }
+  const span = state.tools.get(id);
+  if (span === void 0) return;
+  if (chunk.type === "tool-output-error") span.setStatus("error", chunk.errorText);
+  else span.setStatus("ok");
+  span.end();
+  state.tools.delete(id);
+}
+async function* observeAgentRun(chunks, adapter, context) {
+  const runAttributes = { agent: context.agent };
+  if (context.sessionId !== void 0) runAttributes.sessionId = context.sessionId;
+  const traceId = context.traceId ?? newTraceId();
+  const runSpanId = newSpanId();
+  const runContext = context.traceId !== void 0 && context.parentSpanId !== void 0 ? { traceId, spanId: runSpanId, parentSpanId: context.parentSpanId } : { traceId, spanId: runSpanId };
+  const state = {
+    run: adapter.startSpan("agent.run", runAttributes, runContext),
+    tools: /* @__PURE__ */ new Map(),
+    pauses: /* @__PURE__ */ new Map(),
+    toolNames: /* @__PURE__ */ new Map(),
+    agent: context.agent,
+    traceId,
+    runSpanId
+  };
+  let settled = false;
+  function closeAll(status, message) {
+    if (settled) return;
+    settled = true;
+    for (const approvalId of state.pauses.values()) {
+      closePauseSpan(approvalId, { resumeObserved: false });
+    }
+    for (const span of state.tools.values()) {
+      span.setStatus(status, message);
+      span.end();
+    }
+    state.pauses.clear();
+    state.tools.clear();
+    state.run.setStatus(status, message);
+    state.run.end();
+  }
+  try {
+    for await (const chunk of chunks) {
+      const observed = chunk;
+      if (observed.type === "tool-input-available") openToolSpan(state, adapter, observed);
+      else if (observed.type === "tool-approval-request") openPauseSpan(state, adapter, observed);
+      else if (observed.type === "tool-output-available" || observed.type === "tool-output-error")
+        closeToolSpan(state, observed);
+      else if (observed.type === "finish") {
+        recordTokenUsage(state.run, observed.messageMetadata);
+        recordStopReason(state.run, observed.messageMetadata);
+        recordModel(state.run, observed.messageMetadata);
+      }
+      yield chunk;
+    }
+    closeAll("ok");
+  } catch (error) {
+    closeAll("error", error instanceof Error ? error.message : "unknown error");
+    throw error;
+  } finally {
+    closeAll("error", "agent run stream abandoned by its consumer");
+  }
+}
+
+// src/server/agent/observe-served-run.ts
+function observeServedRun(stream, options) {
+  const adapter = getObservabilityAdapter();
+  if (adapter === void 0) return stream;
+  const trace = requestTrace(options.request);
+  const context = { agent: options.agentName, traceId: trace.traceId };
+  if (options.sessionId !== void 0) context.sessionId = options.sessionId;
+  const parentSpanId = trace.outermostSpanId ?? trace.parentSpanId;
+  if (parentSpanId !== void 0) context.parentSpanId = parentSpanId;
+  return observeAgentRun(stream, adapter, context);
+}
+
+// src/server/agent/build-agent-streamer.ts
+function buildAgentHitl(compiled, owner) {
+  const gated = compiled.hitl;
+  if (gated === void 0 || gated.size === 0) return void 0;
+  const registry = getApprovalRegistry();
+  return {
+    gated,
+    awaitApproval: (approvalId, opts, toolName) => registry.register(approvalId, {
+      ...owner !== void 0 ? { owner } : {},
+      timeoutMs: opts.timeout ?? 3e5,
+      onTimeout: opts.onTimeout ?? "abort",
+      toolName,
+      question: opts.question,
+      ...opts.payloadSchema !== void 0 ? { payloadSchema: opts.payloadSchema } : {}
+    })
+  };
+}
+function makeThreadStartRun(mod, apiKey, source, agentName, request) {
+  return (sessionId, message) => (async function* () {
+    const compiled = compileAgentModule(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);
+    const resolvedApiKey = typeof apiKey === "function" ? apiKey(compiled.model) : apiKey;
+    const stream = streamAgentUIMessages(compiled, resolvedApiKey, { message, sessionId, hitl });
+    yield* observeServedRun(stream, { agentName, sessionId, request });
+  })();
+}
+
+// src/server/agent/durable-ui-message-stream-response.ts
+var SSE_BASE_HEADERS = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache",
+  "x-accel-buffering": "no",
+  "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;
+  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;
+}
+function memoizeSubject(resolveSubject) {
+  if (resolveSubject === void 0) return void 0;
+  let resolved;
+  return async () => {
+    resolved ??= { subject: await resolveSubject() };
+    return resolved.subject;
+  };
+}
+async function resolveApprovalOwner(declaredPolicy, resolveOnce) {
+  if (declaredPolicy === void 0 || declaredPolicy === "public") return void 0;
+  return (await resolveOnce?.() ?? void 0)?.id;
+}
+async function admitRequest(request, policy, resolveSubject, agentName) {
+  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[].");
+  }
+  const params = { agent: agentName, endpoint: "run", sessionId: input.sessionId };
+  const decision = await admitAgentRequest(policy, resolveSubject, params, input);
+  if (!decision.allowed) return agentAccessDenied(decision, params);
+  return input;
+}
+async function mountAgent(mod, request, apiKey, {
+  source = "agent module",
+  csrfMode = "strict",
+  projectRoot,
+  agentName,
+  policy,
+  resolveSubject
+} = {}) {
+  if (csrfMode !== "off") {
+    const csrf = validateCsrfRequest(request);
+    if (!csrf.valid && csrfMode === "strict") {
+      return jsonError(403, "CSRF_FAILED", `CSRF check failed: ${csrf.reason}`);
+    }
+  }
+  const identity = agentName ?? source;
+  const declaredPolicy = policy ?? readAgentPolicy(mod, source);
+  const resolveOnce = memoizeSubject(resolveSubject);
+  const admitted = await admitRequest(request, declaredPolicy, resolveOnce, identity);
+  if (admitted instanceof Response) return admitted;
+  const input = admitted;
+  const compiled = compileAgentModule2(mod, source);
+  const resolvedApiKey = typeof apiKey === "function" ? apiKey(compiled.model) : apiKey;
+  if (compiled.skillsResolver) {
+    const enabled = await resolveEnabledSkills2(compiled.skillsResolver, compiled.runContext ?? {});
+    if (enabled !== void 0) compiled.skills = { enabled, autoInject: true };
+  }
+  const hitl = buildAgentHitl(compiled, await resolveApprovalOwner(declaredPolicy, resolveOnce));
+  const runId = mintRunId();
+  const stream = streamAgentUIMessages2(compiled, resolvedApiKey, {
+    ...input,
+    hitl,
+    signal: request.signal,
+    cwd: resolveDiscoveryCwd(compiled, projectRoot),
+    baseDir: resolveSessionBaseDir(projectRoot)
+  });
+  return durableUiMessageStreamResponse(
+    observeServedRun(stream, { agentName: identity, request }),
+    { runId, cache: getRunEventCache() }
+  );
+}
+function resolveDiscoveryCwd(compiled, projectRoot) {
+  const optedIn = (compiled.settingSources?.length ?? 0) > 0;
+  return projectRoot !== void 0 && optedIn ? projectRoot : void 0;
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") end -= 1;
+  return value.slice(0, end);
+}
+function resolveSessionBaseDir(projectRoot) {
+  if (projectRoot === void 0) return void 0;
+  return `${trimTrailingSlashes(projectRoot)}/.data/agent-sessions`;
+}
+
+export {
+  rateLimitSchema,
+  uploadSchema,
+  loggingSchema,
+  cacheSchema,
+  observabilitySchema,
+  securitySchema,
+  storageSchema,
+  readAgentPolicy,
+  admitAgentRequest,
+  agentAccessDenied,
+  getApprovalRegistry,
+  createObservabilityPluginFromConfig,
+  closePauseSpan,
+  makeThreadStartRun,
+  SSE_BASE_HEADERS,
+  RUN_ID_HEADER,
+  SSE_DONE_FRAME,
+  formatSseFrame,
+  encodeSse,
+  getRunEventCache,
+  mintRunId,
+  parseAgentRequestBody,
+  mountAgent
+};
+//# sourceMappingURL=chunk-WOBSEO75.js.map