@personaai/runtime 0.5.0

package/dist/index.cjs

@@ -0,0 +1,1439 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RUNTIME_VERSION: () => RUNTIME_VERSION,
+  RuntimeHttpError: () => RuntimeHttpError,
+  createRuntime: () => createRuntime
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/routing.ts
+function splitPath(path) {
+  return path.split("/").filter((segment) => segment.length > 0);
+}
+function matchRoute(routes, method, path) {
+  const requested = splitPath(path);
+  let sawPathMatch = false;
+  const allowed = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (route.pattern.length !== requested.length) continue;
+    const params = {};
+    let matched = true;
+    for (let i = 0; i < route.pattern.length; i++) {
+      const patternSegment = route.pattern[i];
+      const requestedSegment = requested[i];
+      if (patternSegment.startsWith(":")) {
+        params[patternSegment.slice(1)] = decodeURIComponent(requestedSegment);
+      } else if (patternSegment !== requestedSegment) {
+        matched = false;
+        break;
+      }
+    }
+    if (!matched) continue;
+    sawPathMatch = true;
+    allowed.add(route.method);
+    if (route.method === method) {
+      return { kind: "matched", route, params };
+    }
+  }
+  if (sawPathMatch) return { kind: "method-not-allowed", allowed: [...allowed] };
+  return { kind: "not-found" };
+}
+function stripMountPath(path, mountPath) {
+  if (!mountPath) return path;
+  const normalizedMount = mountPath.endsWith("/") ? mountPath.slice(0, -1) : mountPath;
+  if (!normalizedMount) return path;
+  if (path === normalizedMount) return "/";
+  if (path.startsWith(`${normalizedMount}/`)) return path.slice(normalizedMount.length);
+  return path;
+}
+
+// src/client-factory.ts
+var import_sdk = require("@personaai/sdk");
+function createClientForRequest(options, userId) {
+  return new import_sdk.PersonaClient({
+    baseUrl: options.baseUrl,
+    credential: options.credential,
+    externalUserId: userId ?? void 0,
+    fetch: options.fetch
+  });
+}
+
+// src/errors.ts
+var import_sdk2 = require("@personaai/sdk");
+var RuntimeHttpError = class _RuntimeHttpError extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.name = "RuntimeHttpError";
+    this.status = status;
+    this.code = code;
+    Object.setPrototypeOf(this, _RuntimeHttpError.prototype);
+  }
+};
+function mapErrorToRuntimeError(err, mode) {
+  const dev = mode === "development";
+  if (err instanceof RuntimeHttpError) {
+    return { status: err.status, code: err.code, message: err.message };
+  }
+  if (err instanceof import_sdk2.PersonaApiError) {
+    return {
+      status: err.statusCode,
+      code: err.code,
+      message: err.message,
+      ...dev ? { detail: err.response } : {}
+    };
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    status: 500,
+    code: "INTERNAL_ERROR",
+    message: dev ? message : "An internal error occurred.",
+    ...dev ? {
+      detail: {
+        name: err instanceof Error ? err.name : typeof err,
+        stack: err instanceof Error ? err.stack : void 0
+      }
+    } : {}
+  };
+}
+function errorToResponse(err, mode) {
+  const mapped = mapErrorToRuntimeError(err, mode);
+  return {
+    kind: "buffered",
+    status: mapped.status,
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      error: {
+        code: mapped.code,
+        message: mapped.message,
+        ...mapped.detail !== void 0 ? { detail: mapped.detail } : {}
+      }
+    })
+  };
+}
+
+// src/runRegistry.ts
+var DEFAULT_RUN_GRACE_MS = 5 * 60 * 1e3;
+var DEFAULT_MAX_TRACKED_RUNS = 1e3;
+function evictStaleRuns(runs, now, graceMs = DEFAULT_RUN_GRACE_MS, maxTracked = DEFAULT_MAX_TRACKED_RUNS) {
+  for (const [id, driver] of runs) {
+    if (driver.isFinished() && driver.finishedAt !== void 0 && now - driver.finishedAt > graceMs) {
+      runs.delete(id);
+    }
+  }
+  const overBy = runs.size - maxTracked;
+  if (overBy <= 0) return;
+  const finished = [...runs.entries()].filter(([, driver]) => driver.isFinished()).sort((a, b) => (a[1].finishedAt ?? 0) - (b[1].finishedAt ?? 0));
+  let remaining = overBy;
+  for (const [id] of finished) {
+    if (remaining <= 0) break;
+    runs.delete(id);
+    remaining -= 1;
+  }
+}
+
+// src/version.ts
+var RUNTIME_VERSION = "0.5.0";
+
+// src/routes/health.ts
+var alwaysOnCapabilities = {
+  chat: true,
+  threads: true,
+  agents: true,
+  files: true,
+  memory: true,
+  mcpOAuth: true
+};
+var healthRoute = async (_request, ctx) => {
+  try {
+    await ctx.client.whoami();
+  } catch (err) {
+    const failed = errorToResponse(err, ctx.mode);
+    return { ...failed, status: 503 };
+  }
+  return {
+    kind: "buffered",
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      status: "ok",
+      version: RUNTIME_VERSION,
+      capabilities: { ...alwaysOnCapabilities, ...ctx.capabilities }
+    })
+  };
+};
+
+// src/runDriver.ts
+var import_sdk3 = require("@personaai/sdk");
+function formatSseFrame(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+function runErrorFrame(err, mode) {
+  const mapped = mapErrorToRuntimeError(err, mode);
+  return formatSseFrame({
+    type: import_sdk3.EventType.RUN_ERROR,
+    code: mapped.code,
+    message: mapped.message
+  });
+}
+function newAccumulator() {
+  return {
+    text: "",
+    interrupted: false,
+    erroredInBand: false,
+    threadCreateFired: false,
+    toolNames: /* @__PURE__ */ new Map()
+  };
+}
+async function processEvent(event, acc, runCtx, hooks) {
+  const e = event;
+  switch (e.type) {
+    case import_sdk3.EventType.RUN_STARTED: {
+      const threadId = typeof e.threadId === "string" ? e.threadId : void 0;
+      if (runCtx.kind === "chat" && runCtx.agentId && !acc.threadCreateFired && !runCtx.threadId && threadId) {
+        acc.threadCreateFired = true;
+        await hooks?.onThreadCreate?.({ userId: runCtx.userId, agentId: runCtx.agentId, threadId });
+      }
+      break;
+    }
+    case import_sdk3.EventType.TEXT_MESSAGE_CHUNK: {
+      const delta = e.delta;
+      if (typeof delta === "string") acc.text += delta;
+      break;
+    }
+    case import_sdk3.EventType.CUSTOM: {
+      if (e.name === "hitl_request" || e.name === "clarification_request") acc.interrupted = true;
+      break;
+    }
+    case import_sdk3.EventType.RUN_ERROR: {
+      acc.erroredInBand = true;
+      break;
+    }
+    case import_sdk3.EventType.TOOL_CALL_START: {
+      const toolCallId = typeof e.toolCallId === "string" ? e.toolCallId : void 0;
+      const toolCallName = typeof e.toolCallName === "string" ? e.toolCallName : "unknown_tool";
+      if (toolCallId) {
+        acc.toolNames.set(toolCallId, toolCallName);
+        await hooks?.beforeToolCall?.({
+          userId: runCtx.userId,
+          agentId: runCtx.agentId,
+          threadId: runCtx.threadId,
+          toolName: toolCallName,
+          toolCallId
+        });
+      }
+      break;
+    }
+    case import_sdk3.EventType.TOOL_CALL_RESULT: {
+      const toolCallId = typeof e.toolCallId === "string" ? e.toolCallId : void 0;
+      if (toolCallId) {
+        await hooks?.afterToolCall?.(
+          {
+            userId: runCtx.userId,
+            agentId: runCtx.agentId,
+            threadId: runCtx.threadId,
+            toolName: acc.toolNames.get(toolCallId) ?? "unknown_tool",
+            toolCallId
+          },
+          e.content
+        );
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+var RunDriver = class {
+  runId;
+  runCtx;
+  createdAt = Date.now();
+  finishedAt;
+  frames = [];
+  listeners = /* @__PURE__ */ new Set();
+  doneListeners = /* @__PURE__ */ new Set();
+  finished = false;
+  firstFrameSettled = false;
+  firstFramePromise;
+  resolveFirstFrame;
+  rejectFirstFrame;
+  constructor(runId, runCtx, source, hooks, mode) {
+    this.runId = runId;
+    this.runCtx = runCtx;
+    this.firstFramePromise = new Promise((resolve, reject) => {
+      this.resolveFirstFrame = resolve;
+      this.rejectFirstFrame = reject;
+    });
+    void this.pump(source, hooks, mode);
+  }
+  push(frame) {
+    const seq = this.frames.length;
+    this.frames.push(frame);
+    for (const listener of this.listeners) listener(seq, frame);
+    if (!this.firstFrameSettled) {
+      this.firstFrameSettled = true;
+      this.resolveFirstFrame();
+    }
+  }
+  finish() {
+    this.finished = true;
+    this.finishedAt = Date.now();
+    for (const listener of this.doneListeners) listener();
+  }
+  async pump(source, hooks, mode) {
+    const acc = newAccumulator();
+    let count = 0;
+    try {
+      for await (const event of source) {
+        await processEvent(event, acc, this.runCtx, hooks);
+        count += 1;
+        this.push(formatSseFrame(event));
+      }
+      if (!this.firstFrameSettled) {
+        this.firstFrameSettled = true;
+        this.resolveFirstFrame();
+      }
+      const result = {
+        text: acc.text,
+        eventCount: count,
+        interrupted: acc.interrupted,
+        erroredInBand: acc.erroredInBand
+      };
+      await hooks?.afterRun?.(this.runCtx, result);
+    } catch (err) {
+      await hooks?.onError?.(
+        {
+          userId: this.runCtx.userId,
+          phase: this.runCtx.kind,
+          agentId: this.runCtx.agentId,
+          threadId: this.runCtx.threadId
+        },
+        err
+      );
+      if (!this.firstFrameSettled) {
+        this.firstFrameSettled = true;
+        this.rejectFirstFrame(err);
+        return;
+      }
+      this.push(runErrorFrame(err, mode));
+    } finally {
+      this.finish();
+    }
+  }
+  /** Resolves once the first frame has been buffered, or rejects if the run failed before producing any frame at all. */
+  waitForFirstFrame() {
+    return this.firstFramePromise;
+  }
+  isFinished() {
+    return this.finished;
+  }
+  /** Total frames buffered so far — also the highest valid `since` a caller can request without missing anything. */
+  get frameCount() {
+    return this.frames.length;
+  }
+  /** Number of currently-live subscriptions (each `subscribe()` iterator that's been started but not yet exhausted/torn down). Exposed for tests verifying subscriptions clean up after themselves. */
+  get subscriberCount() {
+    return this.listeners.size;
+  }
+  /**
+   * An async iterable that replays every buffered frame after `sinceSeq`
+   * (`-1` for "from the start"), then continues yielding new frames live
+   * as the run produces them, until the run finishes. Each call returns an
+   * independent subscription — multiple concurrent subscribers (e.g. the
+   * original connection plus a reconnect that raced it) are supported.
+   */
+  subscribe(sinceSeq) {
+    const buffered = this.frames.slice(Math.max(sinceSeq + 1, 0));
+    const finishedAtSubscribeTime = this.finished;
+    const listeners = this.listeners;
+    const doneListeners = this.doneListeners;
+    return {
+      [Symbol.asyncIterator]() {
+        const queue = [...buffered];
+        let live = !finishedAtSubscribeTime;
+        let wake = null;
+        const onFrame = (_seq, frame) => {
+          queue.push(frame);
+          wake?.();
+        };
+        const onDone = () => {
+          live = false;
+          wake?.();
+        };
+        if (live) {
+          listeners.add(onFrame);
+          doneListeners.add(onDone);
+        }
+        const cleanup = () => {
+          listeners.delete(onFrame);
+          doneListeners.delete(onDone);
+        };
+        return {
+          async next() {
+            for (; ; ) {
+              if (queue.length > 0) return { done: false, value: queue.shift() };
+              if (!live) {
+                cleanup();
+                return { done: true, value: void 0 };
+              }
+              await new Promise((resolve) => wake = resolve);
+            }
+          },
+          async return() {
+            cleanup();
+            return { done: true, value: void 0 };
+          }
+        };
+      }
+    };
+  }
+};
+
+// src/heartbeat.ts
+var HEARTBEAT_FRAME = ": heartbeat\n\n";
+var TIMEOUT = /* @__PURE__ */ Symbol("heartbeat-timeout");
+function heartbeatTimer(ms) {
+  let handle;
+  const promise = new Promise((resolve) => {
+    handle = setTimeout(() => resolve(TIMEOUT), ms);
+  });
+  return { promise, cancel: () => clearTimeout(handle) };
+}
+async function* withHeartbeats(source, intervalMs = 15e3) {
+  const iterator = source[Symbol.asyncIterator]();
+  try {
+    let pending = null;
+    for (; ; ) {
+      pending ??= iterator.next();
+      const timer = heartbeatTimer(intervalMs);
+      const winner = await Promise.race([pending, timer.promise]);
+      timer.cancel();
+      if (winner === TIMEOUT) {
+        yield HEARTBEAT_FRAME;
+        continue;
+      }
+      pending = null;
+      if (winner.done) return;
+      yield winner.value;
+    }
+  } finally {
+    await iterator.return?.();
+  }
+}
+
+// src/routes/chat.ts
+function parseChatBody(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new RuntimeHttpError(400, "INVALID_REQUEST", "Request body must be a JSON object.");
+  }
+  const b = body;
+  if (typeof b.agentId !== "string" || b.agentId.length === 0) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      '"agentId" is required and must be a string.'
+    );
+  }
+  if (!Array.isArray(b.messages)) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      '"messages" is required and must be an array.'
+    );
+  }
+  return {
+    agentId: b.agentId,
+    messages: b.messages,
+    threadId: typeof b.threadId === "string" ? b.threadId : void 0,
+    resume: b.resume ?? void 0,
+    contextOverride: typeof b.contextOverride === "string" ? b.contextOverride : void 0
+  };
+}
+var chatRoute = async (request, ctx) => {
+  const body = parseChatBody(request.body);
+  const userId = request.userId;
+  const runCtx = {
+    userId,
+    kind: "chat",
+    agentId: body.agentId,
+    threadId: body.threadId,
+    messages: body.messages
+  };
+  await ctx.hooks?.beforeRun?.(runCtx);
+  const stream = ctx.client.chat.stream(body.agentId, {
+    messages: body.messages,
+    threadId: body.threadId,
+    resume: body.resume,
+    contextOverride: body.contextOverride
+  });
+  const runId = crypto.randomUUID();
+  const driver = new RunDriver(runId, runCtx, stream, ctx.hooks, ctx.mode);
+  ctx.runs.set(runId, driver);
+  await driver.waitForFirstFrame();
+  return {
+    kind: "stream",
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+      "x-persona-run-id": runId
+    },
+    body: withHeartbeats(driver.subscribe(-1), ctx.heartbeatIntervalMs)
+  };
+};
+
+// src/routes/architect.ts
+function parseArchitectBody(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new RuntimeHttpError(400, "INVALID_REQUEST", "Request body must be a JSON object.");
+  }
+  const b = body;
+  if (!Array.isArray(b.messages)) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      '"messages" is required and must be an array.'
+    );
+  }
+  return {
+    messages: b.messages,
+    resume: b.resume ?? void 0
+  };
+}
+var architectRoute = async (request, ctx) => {
+  const body = parseArchitectBody(request.body);
+  const userId = request.userId;
+  const runCtx = {
+    userId,
+    kind: "architect",
+    messages: body.messages
+  };
+  await ctx.hooks?.beforeRun?.(runCtx);
+  const stream = ctx.client.architect.stream({
+    messages: body.messages,
+    resume: body.resume
+  });
+  const runId = crypto.randomUUID();
+  const driver = new RunDriver(runId, runCtx, stream, ctx.hooks, ctx.mode);
+  ctx.runs.set(runId, driver);
+  await driver.waitForFirstFrame();
+  return {
+    kind: "stream",
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+      "x-persona-run-id": runId
+    },
+    body: withHeartbeats(driver.subscribe(-1), ctx.heartbeatIntervalMs)
+  };
+};
+
+// src/routes/resume.ts
+function createResumeRoute(expectedKind) {
+  return async (request, ctx) => {
+    const runId = ctx.params.runId;
+    if (!runId) {
+      throw new RuntimeHttpError(400, "INVALID_REQUEST", '"runId" path parameter is required.');
+    }
+    const driver = ctx.runs.get(runId);
+    if (!driver || driver.runCtx.userId !== request.userId || driver.runCtx.kind !== expectedKind) {
+      throw new RuntimeHttpError(
+        404,
+        "RUN_NOT_FOUND",
+        `No resumable run found for id "${runId}". It may have finished and been evicted, or never existed.`
+      );
+    }
+    const sinceRaw = request.query.since;
+    const parsed = sinceRaw !== void 0 ? Number.parseInt(sinceRaw, 10) : -1;
+    const sinceSeq = Number.isNaN(parsed) ? -1 : parsed;
+    return {
+      kind: "stream",
+      status: 200,
+      headers: {
+        "content-type": "text/event-stream",
+        "cache-control": "no-cache",
+        connection: "keep-alive",
+        "x-persona-run-id": runId
+      },
+      body: withHeartbeats(driver.subscribe(sinceSeq), ctx.heartbeatIntervalMs)
+    };
+  };
+}
+
+// src/routeHelpers.ts
+function json(status, value) {
+  return {
+    kind: "buffered",
+    status,
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(value)
+  };
+}
+function noContent() {
+  return { kind: "buffered", status: 204, headers: {}, body: "" };
+}
+function requireParam(params, name) {
+  const value = params[name];
+  if (!value) {
+    throw new RuntimeHttpError(400, "INVALID_REQUEST", `"${name}" path parameter is required.`);
+  }
+  return value;
+}
+function requireQueryParam(query, name) {
+  const value = query[name];
+  if (!value) {
+    throw new RuntimeHttpError(400, "INVALID_REQUEST", `"${name}" query parameter is required.`);
+  }
+  return value;
+}
+function toInt(value) {
+  if (value === void 0) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function requireBodyObject(body) {
+  if (typeof body !== "object" || body === null) {
+    throw new RuntimeHttpError(400, "INVALID_REQUEST", "Request body must be a JSON object.");
+  }
+  return body;
+}
+function requireStringField(body, field) {
+  const value = body[field];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      `"${field}" is required and must be a string.`
+    );
+  }
+  return value;
+}
+
+// src/routes/threads.ts
+var listThreads = async (request, ctx) => {
+  const items = await ctx.client.threads.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit)
+  });
+  return json(200, items);
+};
+var createThread = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const agentId = requireStringField(body, "agentId");
+  const thread = await ctx.client.threads.create({ agentId });
+  await ctx.hooks?.onThreadCreate?.({
+    userId: request.userId,
+    agentId,
+    threadId: thread._id
+  });
+  return json(201, thread);
+};
+var getThread = async (_request, ctx) => {
+  const thread = await ctx.client.threads.get(requireParam(ctx.params, "id"));
+  return json(200, thread);
+};
+var updateThread = async (request, ctx) => {
+  const body = request.body ?? {};
+  const thread = await ctx.client.threads.update(requireParam(ctx.params, "id"), body);
+  return json(200, thread);
+};
+var deleteThread = async (_request, ctx) => {
+  await ctx.client.threads.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var bulkDeleteThreads = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const ids = Array.isArray(body.ids) ? body.ids : [];
+  const result = await ctx.client.threads.bulkDelete(ids);
+  return json(200, result);
+};
+var getThreadMessages = async (_request, ctx) => {
+  const messages = await ctx.client.threads.getMessages(requireParam(ctx.params, "id"));
+  return json(200, messages);
+};
+
+// src/routes/agents.ts
+var listAgents = async (request, ctx) => {
+  const items = await ctx.client.agents.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit),
+    search: request.query.search,
+    category: request.query.category,
+    scope: request.query.scope === "mine" ? "mine" : void 0
+  });
+  return json(200, items);
+};
+var createAgent = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const input = {
+    name: requireStringField(body, "name"),
+    systemPrompt: requireStringField(body, "systemPrompt"),
+    providerId: requireStringField(body, "providerId"),
+    description: typeof body.description === "string" ? body.description : void 0,
+    avatar: typeof body.avatar === "string" ? body.avatar : void 0,
+    tags: Array.isArray(body.tags) ? body.tags : void 0,
+    tagline: typeof body.tagline === "string" ? body.tagline : void 0,
+    bio: typeof body.bio === "string" ? body.bio : void 0,
+    socialLinks: body.socialLinks ?? void 0,
+    modelName: typeof body.modelName === "string" ? body.modelName : void 0,
+    webSearchEnabled: typeof body.webSearchEnabled === "boolean" ? body.webSearchEnabled : void 0,
+    visibility: body.visibility,
+    category: body.category,
+    skills: Array.isArray(body.skills) ? body.skills : void 0,
+    mcps: Array.isArray(body.mcps) ? body.mcps : void 0,
+    knowledgeBases: Array.isArray(body.knowledgeBases) ? body.knowledgeBases : void 0,
+    storeMounts: Array.isArray(body.storeMounts) ? body.storeMounts : void 0,
+    interruptOn: body.interruptOn ?? void 0,
+    isActive: typeof body.isActive === "boolean" ? body.isActive : void 0
+  };
+  const agent = await ctx.client.agents.create(input);
+  return json(201, agent);
+};
+var getAgent = async (_request, ctx) => {
+  const agent = await ctx.client.agents.get(requireParam(ctx.params, "id"));
+  return json(200, agent);
+};
+var updateAgent = async (request, ctx) => {
+  const body = request.body ?? {};
+  const agent = await ctx.client.agents.update(requireParam(ctx.params, "id"), body);
+  return json(200, agent);
+};
+var deleteAgent = async (_request, ctx) => {
+  await ctx.client.agents.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var bulkDeleteAgents = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const ids = Array.isArray(body.ids) ? body.ids : [];
+  const result = await ctx.client.agents.bulkDelete(ids);
+  return json(200, result);
+};
+
+// src/routes/files.ts
+var listFiles = async (request, ctx) => {
+  const items = await ctx.client.files.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit)
+  });
+  return json(200, items);
+};
+var uploadFile = async (request, ctx) => {
+  if (!request.file) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      'A "file" part is required on this request.'
+    );
+  }
+  const fields = request.body ?? {};
+  const agentId = typeof fields.agentId === "string" ? fields.agentId : void 0;
+  const threadId = typeof fields.threadId === "string" ? fields.threadId : void 0;
+  const file = await ctx.client.files.upload({
+    filename: request.file.filename,
+    content: request.file.content,
+    contentType: request.file.contentType,
+    agentId,
+    threadId
+  });
+  await ctx.hooks?.onFileUpload?.({
+    userId: request.userId,
+    fileName: request.file.filename,
+    mimeType: request.file.contentType
+  });
+  return json(201, file);
+};
+var downloadFile = async (_request, ctx) => {
+  const response = await ctx.client.files.download(requireParam(ctx.params, "id"));
+  const headers = {};
+  const contentType = response.headers.get("content-type");
+  const contentDisposition = response.headers.get("content-disposition");
+  if (contentType) headers["content-type"] = contentType;
+  if (contentDisposition) headers["content-disposition"] = contentDisposition;
+  if (!response.body) {
+    return { kind: "binary", status: response.status, headers, body: (async function* () {
+    })() };
+  }
+  return {
+    kind: "binary",
+    status: response.status,
+    headers,
+    body: response.body
+  };
+};
+var deleteFile = async (_request, ctx) => {
+  await ctx.client.files.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var bulkDeleteFiles = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const ids = Array.isArray(body.ids) ? body.ids : [];
+  const result = await ctx.client.files.bulkDelete(ids);
+  return json(200, result);
+};
+
+// src/routes/memory.ts
+function requireScope(query) {
+  const scope = query.scope === "agent" ? "agent" : query.scope === "user" ? "user" : void 0;
+  if (scope === "agent" && !query.agentId) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      '"agentId" is required when scope is "agent".'
+    );
+  }
+  return { scope, agentId: query.agentId };
+}
+var listMemory = async (_request, ctx) => {
+  const result = await ctx.client.memory.list();
+  return json(200, result);
+};
+var getMemoryFile = async (request, ctx) => {
+  const path = requireQueryParam(request.query, "path");
+  const { scope, agentId } = requireScope(request.query);
+  const file = await ctx.client.memory.getFile({ path, scope, agentId });
+  return json(200, file);
+};
+var writeMemoryFile = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const path = requireStringField(body, "path");
+  const content = requireStringField(body, "content");
+  const scope = body.scope === "agent" ? "agent" : body.scope === "user" ? "user" : void 0;
+  const agentId = typeof body.agentId === "string" ? body.agentId : void 0;
+  if (scope === "agent" && !agentId) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      '"agentId" is required when scope is "agent".'
+    );
+  }
+  const file = await ctx.client.memory.writeFile({ path, content, scope, agentId });
+  await ctx.hooks?.onMemoryWrite?.({ userId: request.userId, agentId, path });
+  return json(200, file);
+};
+var deleteMemoryFile = async (request, ctx) => {
+  const path = requireQueryParam(request.query, "path");
+  const { scope, agentId } = requireScope(request.query);
+  await ctx.client.memory.deleteFile({ path, scope, agentId });
+  return noContent();
+};
+
+// src/routes/mcpOAuth.ts
+var getOwnerAuthorizeUrl = async (_request, ctx) => {
+  const result = await ctx.client.mcps.oauth.getOwnerAuthorizeUrl(requireParam(ctx.params, "id"));
+  return json(200, result);
+};
+var getUserAuthorizeUrl = async (request, ctx) => {
+  const result = await ctx.client.mcps.oauth.getUserAuthorizeUrl(
+    requireParam(ctx.params, "id"),
+    request.query.returnTo
+  );
+  return json(200, result);
+};
+var getUserConnectionStatus = async (_request, ctx) => {
+  const result = await ctx.client.mcps.oauth.getUserConnectionStatus(
+    requireParam(ctx.params, "id")
+  );
+  return json(200, result);
+};
+var disconnectUserConnection = async (_request, ctx) => {
+  await ctx.client.mcps.oauth.disconnectUserConnection(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var disconnectOwnerConnection = async (_request, ctx) => {
+  await ctx.client.mcps.oauth.disconnectOwnerConnection(requireParam(ctx.params, "id"));
+  return noContent();
+};
+
+// src/routes/mcps.ts
+var listMcps = async (request, ctx) => {
+  const items = await ctx.client.mcps.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit),
+    search: request.query.search,
+    scope: request.query.scope === "mine" ? "mine" : void 0
+  });
+  return json(200, items);
+};
+var createMcp = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const input = {
+    name: requireStringField(body, "name"),
+    transport: requireStringField(body, "transport"),
+    url: requireStringField(body, "url"),
+    description: typeof body.description === "string" ? body.description : void 0,
+    authType: body.authType,
+    authMode: body.authMode,
+    oauth: body.oauth,
+    apiKey: typeof body.apiKey === "string" ? body.apiKey : void 0
+  };
+  const mcp = await ctx.client.mcps.create(input);
+  return json(201, mcp);
+};
+var getMcp = async (_request, ctx) => {
+  const mcp = await ctx.client.mcps.get(requireParam(ctx.params, "id"));
+  return json(200, mcp);
+};
+var updateMcp = async (request, ctx) => {
+  const body = request.body ?? {};
+  const mcp = await ctx.client.mcps.update(requireParam(ctx.params, "id"), body);
+  return json(200, mcp);
+};
+var deleteMcp = async (_request, ctx) => {
+  await ctx.client.mcps.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var bulkDeleteMcps = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const ids = Array.isArray(body.ids) ? body.ids : [];
+  const result = await ctx.client.mcps.bulkDelete(ids);
+  return json(200, result);
+};
+var getMcpUsage = async (_request, ctx) => {
+  const usage = await ctx.client.mcps.getUsage(requireParam(ctx.params, "id"));
+  return json(200, usage);
+};
+var testMcpConnection = async (_request, ctx) => {
+  const result = await ctx.client.mcps.testConnection(requireParam(ctx.params, "id"));
+  return json(200, result);
+};
+var readMcpResource = async (request, ctx) => {
+  const uri = requireQueryParam(request.query, "uri");
+  const result = await ctx.client.mcps.readResource(requireParam(ctx.params, "id"), uri);
+  return json(200, result);
+};
+var callMcpTool = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const name = requireStringField(body, "name");
+  const args = body.arguments ?? void 0;
+  const result = await ctx.client.mcps.callTool(requireParam(ctx.params, "id"), name, args);
+  return json(200, result);
+};
+
+// src/routes/providers.ts
+var listProviders = async (_request, ctx) => {
+  const items = await ctx.client.providers.list();
+  return json(200, items);
+};
+var createProvider = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const input = {
+    label: requireStringField(body, "label"),
+    baseURL: requireStringField(body, "baseURL"),
+    apiKey: requireStringField(body, "apiKey"),
+    defaultModel: requireStringField(body, "defaultModel"),
+    isDefault: typeof body.isDefault === "boolean" ? body.isDefault : void 0
+  };
+  const provider = await ctx.client.providers.create(input);
+  return json(201, provider);
+};
+var getProvider = async (_request, ctx) => {
+  const provider = await ctx.client.providers.get(requireParam(ctx.params, "id"));
+  return json(200, provider);
+};
+var updateProvider = async (request, ctx) => {
+  const body = request.body ?? {};
+  const provider = await ctx.client.providers.update(requireParam(ctx.params, "id"), body);
+  return json(200, provider);
+};
+var deleteProvider = async (_request, ctx) => {
+  await ctx.client.providers.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var bulkDeleteProviders = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const ids = Array.isArray(body.ids) ? body.ids : [];
+  const result = await ctx.client.providers.bulkDelete(ids);
+  return json(200, result);
+};
+var testProviderConnection = async (_request, ctx) => {
+  const result = await ctx.client.providers.testConnection(requireParam(ctx.params, "id"));
+  return json(200, result);
+};
+var getProviderModels = async (_request, ctx) => {
+  const models = await ctx.client.providers.getModels(requireParam(ctx.params, "id"));
+  return json(200, models);
+};
+var getProviderUsage = async (_request, ctx) => {
+  const usage = await ctx.client.providers.getUsage(requireParam(ctx.params, "id"));
+  return json(200, usage);
+};
+
+// src/routes/skills.ts
+var listSkills = async (request, ctx) => {
+  const items = await ctx.client.skills.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit),
+    search: request.query.search,
+    scope: request.query.scope === "mine" ? "mine" : void 0
+  });
+  return json(200, items);
+};
+var createSkill = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const input = {
+    name: requireStringField(body, "name"),
+    description: requireStringField(body, "description"),
+    instructions: requireStringField(body, "instructions"),
+    isPublic: typeof body.isPublic === "boolean" ? body.isPublic : void 0,
+    files: Array.isArray(body.files) ? body.files : void 0
+  };
+  const skill = await ctx.client.skills.create(input);
+  return json(201, skill);
+};
+var getSkill = async (_request, ctx) => {
+  const skill = await ctx.client.skills.get(requireParam(ctx.params, "id"));
+  return json(200, skill);
+};
+var updateSkill = async (request, ctx) => {
+  const body = request.body ?? {};
+  const skill = await ctx.client.skills.update(requireParam(ctx.params, "id"), body);
+  return json(200, skill);
+};
+var deleteSkill = async (_request, ctx) => {
+  await ctx.client.skills.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var bulkDeleteSkills = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const ids = Array.isArray(body.ids) ? body.ids : [];
+  const result = await ctx.client.skills.bulkDelete(ids);
+  return json(200, result);
+};
+var getSkillUsage = async (_request, ctx) => {
+  const usage = await ctx.client.skills.getUsage(requireParam(ctx.params, "id"));
+  return json(200, usage);
+};
+
+// src/routes/knowledge.ts
+var listKnowledgeBases = async (request, ctx) => {
+  const items = await ctx.client.knowledge.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit),
+    search: request.query.search,
+    scope: request.query.scope === "mine" ? "mine" : void 0
+  });
+  return json(200, items);
+};
+var createKnowledgeBase = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const input = {
+    name: requireStringField(body, "name"),
+    providerId: requireStringField(body, "providerId"),
+    description: typeof body.description === "string" ? body.description : void 0,
+    isPublic: typeof body.isPublic === "boolean" ? body.isPublic : void 0,
+    embeddingModel: typeof body.embeddingModel === "string" ? body.embeddingModel : void 0,
+    chunkSize: typeof body.chunkSize === "number" ? body.chunkSize : void 0,
+    chunkOverlap: typeof body.chunkOverlap === "number" ? body.chunkOverlap : void 0,
+    topK: typeof body.topK === "number" ? body.topK : void 0
+  };
+  const kb = await ctx.client.knowledge.create(input);
+  return json(201, kb);
+};
+var getKnowledgeBase = async (_request, ctx) => {
+  const kb = await ctx.client.knowledge.get(requireParam(ctx.params, "id"));
+  return json(200, kb);
+};
+var updateKnowledgeBase = async (request, ctx) => {
+  const body = request.body ?? {};
+  const kb = await ctx.client.knowledge.update(requireParam(ctx.params, "id"), body);
+  return json(200, kb);
+};
+var deleteKnowledgeBase = async (_request, ctx) => {
+  await ctx.client.knowledge.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var bulkDeleteKnowledgeBases = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const ids = Array.isArray(body.ids) ? body.ids : [];
+  const result = await ctx.client.knowledge.bulkDelete(ids);
+  return json(200, result);
+};
+var getKnowledgeBaseUsage = async (_request, ctx) => {
+  const usage = await ctx.client.knowledge.getUsage(requireParam(ctx.params, "id"));
+  return json(200, usage);
+};
+var uploadKnowledgeDocuments = async (request, ctx) => {
+  if (!request.files || request.files.length === 0) {
+    throw new RuntimeHttpError(
+      400,
+      "INVALID_REQUEST",
+      'At least one "files" part is required on this request.'
+    );
+  }
+  const result = await ctx.client.knowledge.uploadDocuments(
+    requireParam(ctx.params, "id"),
+    request.files.map((file) => ({
+      filename: file.filename,
+      content: file.content,
+      contentType: file.contentType
+    }))
+  );
+  return json(201, result);
+};
+var listKnowledgeDocuments = async (_request, ctx) => {
+  const documents = await ctx.client.knowledge.listDocuments(requireParam(ctx.params, "id"));
+  return json(200, documents);
+};
+var deleteKnowledgeDocument = async (_request, ctx) => {
+  const result = await ctx.client.knowledge.deleteDocument(
+    requireParam(ctx.params, "id"),
+    requireParam(ctx.params, "sourceName")
+  );
+  return json(200, result);
+};
+var searchKnowledgeBase = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const query = requireStringField(body, "query");
+  const topK = typeof body.topK === "number" ? body.topK : void 0;
+  const results = await ctx.client.knowledge.search(requireParam(ctx.params, "id"), query, {
+    topK
+  });
+  return json(200, results);
+};
+
+// src/routes/stores.ts
+var listStores = async (request, ctx) => {
+  const items = await ctx.client.stores.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit),
+    search: request.query.search
+  });
+  return json(200, items);
+};
+var createStore = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const input = {
+    name: requireStringField(body, "name"),
+    description: typeof body.description === "string" ? body.description : void 0,
+    scope: requireStringField(body, "scope"),
+    accessMode: body.accessMode
+  };
+  const store = await ctx.client.stores.create(input);
+  return json(201, store);
+};
+var getStore = async (_request, ctx) => {
+  const store = await ctx.client.stores.get(requireParam(ctx.params, "id"));
+  return json(200, store);
+};
+var updateStore = async (request, ctx) => {
+  const body = request.body ?? {};
+  const store = await ctx.client.stores.update(requireParam(ctx.params, "id"), body);
+  return json(200, store);
+};
+var deleteStore = async (_request, ctx) => {
+  await ctx.client.stores.delete(requireParam(ctx.params, "id"));
+  return noContent();
+};
+var listStoreFiles = async (_request, ctx) => {
+  const files = await ctx.client.stores.listFiles(requireParam(ctx.params, "id"));
+  return json(200, files);
+};
+var getStoreFile = async (request, ctx) => {
+  const path = requireQueryParam(request.query, "path");
+  const file = await ctx.client.stores.getFile(requireParam(ctx.params, "id"), { path });
+  return json(200, file);
+};
+var writeStoreFile = async (request, ctx) => {
+  const body = requireBodyObject(request.body);
+  const input = {
+    path: requireStringField(body, "path"),
+    content: requireStringField(body, "content")
+  };
+  const file = await ctx.client.stores.writeFile(requireParam(ctx.params, "id"), input);
+  return json(200, file);
+};
+var deleteStoreFile = async (request, ctx) => {
+  const path = requireQueryParam(request.query, "path");
+  await ctx.client.stores.deleteFile(requireParam(ctx.params, "id"), { path });
+  return noContent();
+};
+
+// src/routes/auditLogs.ts
+var listAuditLogs = async (request, ctx) => {
+  const items = await ctx.client.auditLogs.list({
+    page: toInt(request.query.page),
+    limit: toInt(request.query.limit),
+    eventType: request.query.eventType
+  });
+  return json(200, items);
+};
+
+// src/runtime.ts
+function resolveCapabilities(capabilities) {
+  return {
+    agentsWrite: capabilities?.agentsWrite ?? false,
+    mcps: capabilities?.mcps ?? false,
+    providers: capabilities?.providers ?? false,
+    skills: capabilities?.skills ?? false,
+    knowledge: capabilities?.knowledge ?? false,
+    stores: capabilities?.stores ?? false,
+    auditLogs: capabilities?.auditLogs ?? false,
+    architect: capabilities?.architect ?? false
+  };
+}
+function buildRoutes(capabilities) {
+  const routes = [
+    { method: "GET", pattern: ["health"], handler: healthRoute, requiresAuth: false },
+    // Chat — always on, the core runtime feature.
+    { method: "POST", pattern: ["chat"], handler: chatRoute },
+    { method: "GET", pattern: ["chat", ":runId", "resume"], handler: createResumeRoute("chat") },
+    // Threads — always on, end-user-scoped conversation history.
+    { method: "GET", pattern: ["threads"], handler: listThreads },
+    { method: "POST", pattern: ["threads"], handler: createThread },
+    { method: "POST", pattern: ["threads", "bulk-delete"], handler: bulkDeleteThreads },
+    { method: "GET", pattern: ["threads", ":id"], handler: getThread },
+    { method: "PATCH", pattern: ["threads", ":id"], handler: updateThread },
+    { method: "DELETE", pattern: ["threads", ":id"], handler: deleteThread },
+    { method: "GET", pattern: ["threads", ":id", "messages"], handler: getThreadMessages },
+    // Agents — read-only discovery always on; write ops behind agentsWrite.
+    { method: "GET", pattern: ["agents"], handler: listAgents },
+    // Files — always on, end-user-scoped uploads.
+    { method: "GET", pattern: ["files"], handler: listFiles },
+    { method: "POST", pattern: ["files"], handler: uploadFile },
+    { method: "POST", pattern: ["files", "bulk-delete"], handler: bulkDeleteFiles },
+    { method: "GET", pattern: ["files", ":id"], handler: downloadFile },
+    { method: "DELETE", pattern: ["files", ":id"], handler: deleteFile },
+    // Memory — always on, end-user-scoped.
+    { method: "GET", pattern: ["memory"], handler: listMemory },
+    { method: "GET", pattern: ["memory", "file"], handler: getMemoryFile },
+    { method: "PUT", pattern: ["memory", "file"], handler: writeMemoryFile },
+    { method: "DELETE", pattern: ["memory", "file"], handler: deleteMemoryFile },
+    // MCP OAuth — always on, end-user connects their own account.
+    {
+      method: "GET",
+      pattern: ["mcps", ":id", "oauth", "owner", "authorize"],
+      handler: getOwnerAuthorizeUrl
+    },
+    {
+      method: "GET",
+      pattern: ["mcps", ":id", "oauth", "user", "authorize"],
+      handler: getUserAuthorizeUrl
+    },
+    {
+      method: "GET",
+      pattern: ["mcps", ":id", "oauth", "user", "status"],
+      handler: getUserConnectionStatus
+    },
+    {
+      method: "DELETE",
+      pattern: ["mcps", ":id", "oauth", "user", "connection"],
+      handler: disconnectUserConnection
+    },
+    {
+      method: "DELETE",
+      pattern: ["mcps", ":id", "oauth", "owner", "connection"],
+      handler: disconnectOwnerConnection
+    }
+  ];
+  if (capabilities.agentsWrite) {
+    routes.push(
+      { method: "POST", pattern: ["agents"], handler: createAgent },
+      { method: "POST", pattern: ["agents", "bulk-delete"], handler: bulkDeleteAgents },
+      { method: "GET", pattern: ["agents", ":id"], handler: getAgent },
+      { method: "PATCH", pattern: ["agents", ":id"], handler: updateAgent },
+      { method: "DELETE", pattern: ["agents", ":id"], handler: deleteAgent }
+    );
+  }
+  if (capabilities.mcps) {
+    routes.push(
+      { method: "GET", pattern: ["mcps"], handler: listMcps },
+      { method: "POST", pattern: ["mcps"], handler: createMcp },
+      { method: "POST", pattern: ["mcps", "bulk-delete"], handler: bulkDeleteMcps },
+      { method: "GET", pattern: ["mcps", ":id"], handler: getMcp },
+      { method: "PATCH", pattern: ["mcps", ":id"], handler: updateMcp },
+      { method: "DELETE", pattern: ["mcps", ":id"], handler: deleteMcp },
+      { method: "GET", pattern: ["mcps", ":id", "usage"], handler: getMcpUsage },
+      { method: "POST", pattern: ["mcps", ":id", "test"], handler: testMcpConnection },
+      { method: "GET", pattern: ["mcps", ":id", "resource"], handler: readMcpResource },
+      { method: "POST", pattern: ["mcps", ":id", "call-tool"], handler: callMcpTool }
+    );
+  }
+  if (capabilities.providers) {
+    routes.push(
+      { method: "GET", pattern: ["providers"], handler: listProviders },
+      { method: "POST", pattern: ["providers"], handler: createProvider },
+      { method: "POST", pattern: ["providers", "bulk-delete"], handler: bulkDeleteProviders },
+      { method: "GET", pattern: ["providers", ":id"], handler: getProvider },
+      { method: "PATCH", pattern: ["providers", ":id"], handler: updateProvider },
+      { method: "DELETE", pattern: ["providers", ":id"], handler: deleteProvider },
+      { method: "POST", pattern: ["providers", ":id", "test"], handler: testProviderConnection },
+      { method: "GET", pattern: ["providers", ":id", "models"], handler: getProviderModels },
+      { method: "GET", pattern: ["providers", ":id", "usage"], handler: getProviderUsage }
+    );
+  }
+  if (capabilities.skills) {
+    routes.push(
+      { method: "GET", pattern: ["skills"], handler: listSkills },
+      { method: "POST", pattern: ["skills"], handler: createSkill },
+      { method: "POST", pattern: ["skills", "bulk-delete"], handler: bulkDeleteSkills },
+      { method: "GET", pattern: ["skills", ":id"], handler: getSkill },
+      { method: "PATCH", pattern: ["skills", ":id"], handler: updateSkill },
+      { method: "DELETE", pattern: ["skills", ":id"], handler: deleteSkill },
+      { method: "GET", pattern: ["skills", ":id", "usage"], handler: getSkillUsage }
+    );
+  }
+  if (capabilities.knowledge) {
+    routes.push(
+      { method: "GET", pattern: ["knowledge"], handler: listKnowledgeBases },
+      { method: "POST", pattern: ["knowledge"], handler: createKnowledgeBase },
+      { method: "POST", pattern: ["knowledge", "bulk-delete"], handler: bulkDeleteKnowledgeBases },
+      { method: "GET", pattern: ["knowledge", ":id"], handler: getKnowledgeBase },
+      { method: "PATCH", pattern: ["knowledge", ":id"], handler: updateKnowledgeBase },
+      { method: "DELETE", pattern: ["knowledge", ":id"], handler: deleteKnowledgeBase },
+      { method: "GET", pattern: ["knowledge", ":id", "usage"], handler: getKnowledgeBaseUsage },
+      {
+        method: "POST",
+        pattern: ["knowledge", ":id", "documents"],
+        handler: uploadKnowledgeDocuments
+      },
+      {
+        method: "GET",
+        pattern: ["knowledge", ":id", "documents"],
+        handler: listKnowledgeDocuments
+      },
+      {
+        method: "DELETE",
+        pattern: ["knowledge", ":id", "documents", ":sourceName"],
+        handler: deleteKnowledgeDocument
+      },
+      { method: "POST", pattern: ["knowledge", ":id", "search"], handler: searchKnowledgeBase }
+    );
+  }
+  if (capabilities.stores) {
+    routes.push(
+      { method: "GET", pattern: ["stores"], handler: listStores },
+      { method: "POST", pattern: ["stores"], handler: createStore },
+      { method: "GET", pattern: ["stores", ":id"], handler: getStore },
+      { method: "PATCH", pattern: ["stores", ":id"], handler: updateStore },
+      { method: "DELETE", pattern: ["stores", ":id"], handler: deleteStore },
+      { method: "GET", pattern: ["stores", ":id", "files"], handler: listStoreFiles },
+      { method: "GET", pattern: ["stores", ":id", "file"], handler: getStoreFile },
+      { method: "PUT", pattern: ["stores", ":id", "file"], handler: writeStoreFile },
+      { method: "DELETE", pattern: ["stores", ":id", "file"], handler: deleteStoreFile }
+    );
+  }
+  if (capabilities.auditLogs) {
+    routes.push({ method: "GET", pattern: ["audit-logs"], handler: listAuditLogs });
+  }
+  if (capabilities.architect) {
+    routes.push(
+      { method: "POST", pattern: ["architect"], handler: architectRoute },
+      {
+        method: "GET",
+        pattern: ["architect", ":runId", "resume"],
+        handler: createResumeRoute("architect")
+      }
+    );
+  }
+  return routes;
+}
+function resolveMode(options) {
+  if (options.mode) return options.mode;
+  return process.env.NODE_ENV === "development" ? "development" : "production";
+}
+function createRuntime(options) {
+  if (!options.baseUrl) throw new Error('createRuntime: "baseUrl" is required');
+  if (!options.credential) throw new Error('createRuntime: "credential" is required');
+  if (!options.resolveUser) throw new Error('createRuntime: "resolveUser" is required');
+  const capabilities = resolveCapabilities(options.capabilities);
+  const routes = buildRoutes(capabilities);
+  const mode = resolveMode(options);
+  const heartbeatIntervalMs = options.heartbeatIntervalMs ?? 15e3;
+  const runGraceMs = options.runGraceMs ?? DEFAULT_RUN_GRACE_MS;
+  const maxTrackedRuns = options.maxTrackedRuns ?? DEFAULT_MAX_TRACKED_RUNS;
+  const runs = /* @__PURE__ */ new Map();
+  const evictionTimer = setInterval(
+    () => evictStaleRuns(runs, Date.now(), runGraceMs, maxTrackedRuns),
+    6e4
+  );
+  evictionTimer.unref?.();
+  async function handle(request) {
+    try {
+      const path = stripMountPath(request.path, options.mountPath);
+      const match = matchRoute(routes, request.method, path);
+      if (match.kind === "not-found") {
+        throw new RuntimeHttpError(
+          404,
+          "NOT_FOUND",
+          `No route for ${request.method} ${request.path}`
+        );
+      }
+      if (match.kind === "method-not-allowed") {
+        const err = new RuntimeHttpError(
+          405,
+          "METHOD_NOT_ALLOWED",
+          `${request.method} not allowed on ${request.path}. Allowed: ${match.allowed.join(", ")}.`
+        );
+        const response = errorToResponse(err, mode);
+        return { ...response, headers: { ...response.headers, Allow: match.allowed.join(", ") } };
+      }
+      let userId = null;
+      if (match.route.requiresAuth !== false) {
+        try {
+          userId = await options.resolveUser(request);
+        } catch {
+          userId = null;
+        }
+        if (userId === null) {
+          throw new RuntimeHttpError(
+            401,
+            "UNAUTHORIZED",
+            "Could not resolve an authenticated user for this request."
+          );
+        }
+      }
+      const resolvedRequest = { ...request, userId };
+      const client = createClientForRequest(options, userId);
+      return await match.route.handler(resolvedRequest, {
+        client,
+        hooks: options.hooks,
+        mode,
+        params: match.params,
+        heartbeatIntervalMs,
+        runs,
+        capabilities
+      });
+    } catch (err) {
+      return errorToResponse(err, mode);
+    }
+  }
+  return {
+    handle,
+    close() {
+      clearInterval(evictionTimer);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUNTIME_VERSION,
+  RuntimeHttpError,
+  createRuntime
+});
+//# sourceMappingURL=index.cjs.map