stitchkit 0.43.1 → 0.44.0

package/dist/tools.js

@@ -2,7 +2,7 @@ import {
   inputIsQuery,
   signJwt,
   verifyPkce
-} from "./index-310bfer5.js";
+} from "./index-36f1xkdb.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS
 } from "./index-6jypn22c.js";
@@ -16,6 +16,7 @@ import {
   createToolRunner,
   executeToolMethod,
   fetchGuarded,
+  fetchPinnedDocument,
   flattenToolJsonSchema,
   formatToolError,
   isObjectPresentationSchema,
@@ -25,7 +26,7 @@ import {
   toolErrorFromResult,
   toolResultFromError,
   writeDownload
-} from "./index-h2wdcsby.js";
+} from "./index-mvjyq9h9.js";
 import {
   toJsonSchema
 } from "./index-frfyw9fa.js";
@@ -34,12 +35,15 @@ import {
 } from "./index-x3fcszf8.js";
 import {
   AppError,
+  getRequestContext,
   getTraceId,
   isRecord,
   mergeMeta,
   parseTrailingWildcard,
+  resolvePropagationContext,
+  runWithRequestContext,
   typedEntries
-} from "./index-gex6gxhe.js";
+} from "./index-yh0p5ddn.js";
 
 // src/tools/agent.ts
 import { jsonSchema, tool } from "ai";
@@ -54,7 +58,12 @@ function defineRuntimeTool(definition) {
 function createRuntimeToolFactory(config) {
   function parseContext(context) {
     const parsed = config.context.parse(context);
-    return { ...parsed, params: undefined, input: context.input };
+    return {
+      ...context,
+      ...parsed,
+      params: undefined,
+      input: context.input
+    };
   }
   function define(definition) {
     if (definition.output !== undefined) {
@@ -104,7 +113,8 @@ function runtimeToolIdentity(definition) {
     scope: definition.identity.scope,
     meta: definition.identity.meta,
     annotations: definition.annotations,
-    ui: definition.ui
+    ui: definition.ui,
+    mcp: definition.mcp
   };
 }
 function runtimeToolMountable(definition, assertName = true) {
@@ -334,7 +344,10 @@ function buildToolManifest(config) {
   }));
 }
 // src/tools/mcp.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  createRequestStateCodec,
+  McpServer
+} from "@modelcontextprotocol/server";
 import { z as z2 } from "zod";
 
 // src/tools/mcp-app.ts
@@ -358,12 +371,271 @@ function inlineMcpAppBundle(html) {
   return html.replace(EXT_APPS_BUNDLE_PLACEHOLDER, () => bundle);
 }
 
+// src/tools/mcp-round.ts
+import {
+  acceptedContent,
+  CLIENT_INFO_META_KEY,
+  inputRequired,
+  inputResponse,
+  PROTOCOL_VERSION_META_KEY
+} from "@modelcontextprotocol/server";
+function transportContext(context, toolName, outcome, round) {
+  const protocolVersionValue = isRecord(context.mcpReq.envelope) ? Reflect.get(context.mcpReq.envelope, PROTOCOL_VERSION_META_KEY) : undefined;
+  const protocolVersion = typeof protocolVersionValue === "string" ? protocolVersionValue : undefined;
+  const clientInfoValue = isRecord(context.mcpReq.envelope) ? Reflect.get(context.mcpReq.envelope, CLIENT_INFO_META_KEY) : undefined;
+  const clientInfo = isRecord(clientInfoValue) && typeof clientInfoValue.name === "string" && typeof clientInfoValue.version === "string" ? { name: clientInfoValue.name, version: clientInfoValue.version } : undefined;
+  return {
+    signal: context.mcpReq.signal,
+    mcp: {
+      era: context.mcpReq.envelope ? "modern" : "legacy",
+      method: context.mcpReq.method,
+      toolName,
+      ...protocolVersion !== undefined && { protocolVersion },
+      ...clientInfo !== undefined && { clientInfo },
+      ...outcome !== undefined && { outcome },
+      ...round !== undefined && { round }
+    }
+  };
+}
+function stableValue(value) {
+  if (Array.isArray(value))
+    return value.map(stableValue);
+  if (value === null || typeof value !== "object")
+    return value;
+  const result = {};
+  for (const key of Object.keys(value).sort()) {
+    result[key] = stableValue(Reflect.get(value, key));
+  }
+  return result;
+}
+async function argumentsDigest(args) {
+  const bytes = new TextEncoder().encode(JSON.stringify(stableValue(args)));
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+  let binary = "";
+  for (const byte of digest)
+    binary += String.fromCodePoint(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function operationIdentity(tool2) {
+  return {
+    toolName: tool2.name,
+    serviceName: tool2.method.serviceName,
+    action: tool2.method.key,
+    method: tool2.method.method,
+    ...tool2.method.scope !== undefined && { scope: tool2.method.scope }
+  };
+}
+function sameIdentity(left, right) {
+  return left.toolName === right.toolName && left.serviceName === right.serviceName && left.action === right.action && left.method === right.method && left.scope === right.scope;
+}
+async function runRoundSuccess(tool2, rawArgs, runTool, context) {
+  return runTool({
+    ...tool2,
+    method: {
+      ...tool2.method,
+      outputSchema: undefined,
+      handler: () => {
+        return;
+      }
+    }
+  }, rawArgs, context);
+}
+async function runRoundFailure(tool2, rawArgs, runTool, context, code, message) {
+  return runTool({
+    ...tool2,
+    method: {
+      ...tool2.method,
+      outputSchema: undefined,
+      handler: () => {
+        throw new AppError(code, message, 400);
+      }
+    }
+  }, rawArgs, context);
+}
+function validatePolicy(tool2, policy, maxRounds) {
+  if (!Number.isInteger(maxRounds) || maxRounds < 1) {
+    throw new Error("[stitchkit] multiRound.serving.maxRounds must be a positive integer");
+  }
+  if (policy.inputRequired.length === 0) {
+    throw new Error(`[stitchkit] MCP tool "${tool2.name}" must declare at least one input round`);
+  }
+  if (policy.inputRequired.length > maxRounds) {
+    throw new Error(`[stitchkit] MCP tool "${tool2.name}" declares ${policy.inputRequired.length} input rounds, exceeding maxRounds ${maxRounds}`);
+  }
+  const keys = new Set;
+  for (const request of policy.inputRequired) {
+    if (keys.has(request.key)) {
+      throw new Error(`[stitchkit] MCP tool "${tool2.name}" declares duplicate input key "${request.key}"`);
+    }
+    keys.add(request.key);
+  }
+}
+async function failedResolution(options) {
+  const result = await runRoundFailure(options.tool, options.rawArgs, options.runTool, options.context, options.code, options.message);
+  return { kind: "response", response: options.formatFailure(result) };
+}
+async function resolveMcpRound(options) {
+  const { policy } = options;
+  if (!policy) {
+    return {
+      kind: "continue",
+      context: transportContext(options.context, options.tool.name)
+    };
+  }
+  if (!options.runtime) {
+    throw new Error(`[stitchkit] MCP tool "${options.tool.name}" declares inputRequired but no multiRound.state key is configured`);
+  }
+  validatePolicy(options.tool, policy, options.runtime.maxRounds);
+  const requests = policy.inputRequired;
+  const state = options.context.mcpReq.requestState();
+  const digest = await argumentsDigest(options.rawArgs);
+  if (!state) {
+    if (isRecord(options.context.mcpReq.inputResponses)) {
+      return failedResolution({
+        ...options,
+        context: transportContext(options.context, options.tool.name, "invalid", 0),
+        code: "INVALID_REQUEST_STATE",
+        message: "Input responses require a valid continuation state"
+      });
+    }
+    const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", 0));
+    if (!guarded.ok) {
+      return { kind: "response", response: options.formatFailure(guarded) };
+    }
+    const request2 = requests[0];
+    if (!request2)
+      throw new Error("[stitchkit] validated MRTR policy has no first round");
+    const requestState = await options.runtime.codec.mint({
+      identity: operationIdentity(options.tool),
+      argumentsDigest: digest,
+      round: 0,
+      accepted: {}
+    }, options.context);
+    return {
+      kind: "response",
+      response: inputRequired({
+        inputRequests: {
+          [request2.key]: inputRequired.elicit({
+            message: request2.message,
+            requestedSchema: request2.schema
+          })
+        },
+        requestState
+      })
+    };
+  }
+  const invalidState = !sameIdentity(state.identity, operationIdentity(options.tool)) || state.argumentsDigest !== digest || !Number.isInteger(state.round) || state.round < 0 || state.round >= requests.length || state.round >= options.runtime.maxRounds || !isRecord(state.accepted);
+  if (invalidState) {
+    return failedResolution({
+      ...options,
+      context: transportContext(options.context, options.tool.name, "invalid", state.round),
+      code: "INVALID_REQUEST_STATE",
+      message: "Continuation state does not match this operation, arguments or round"
+    });
+  }
+  const request = requests[state.round];
+  if (!request)
+    throw new Error("[stitchkit] validated MRTR state points outside its policy");
+  const view = inputResponse(options.context.mcpReq.inputResponses, request.key);
+  if (view.kind !== "elicit") {
+    return failedResolution({
+      ...options,
+      context: transportContext(options.context, options.tool.name, "invalid", state.round),
+      code: "INVALID_INPUT_RESPONSE",
+      message: "Expected an elicitation response for the current round"
+    });
+  }
+  if (view.action !== "accept") {
+    const outcome = view.action === "decline" ? "declined" : "cancelled";
+    return failedResolution({
+      ...options,
+      context: transportContext(options.context, options.tool.name, outcome, state.round),
+      code: view.action === "decline" ? "INPUT_DECLINED" : "INPUT_CANCELLED",
+      message: view.action === "decline" ? "Required input was declined" : "Required input was cancelled"
+    });
+  }
+  const content = acceptedContent(options.context.mcpReq.inputResponses, request.key, request.schema);
+  if (!content) {
+    return failedResolution({
+      ...options,
+      context: transportContext(options.context, options.tool.name, "invalid", state.round),
+      code: "INVALID_INPUT_RESPONSE",
+      message: "Accepted input failed its declared schema"
+    });
+  }
+  const accepted = { ...state.accepted, [request.key]: content };
+  const nextRound = state.round + 1;
+  const nextRequest = requests[nextRound];
+  if (nextRequest) {
+    const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", nextRound));
+    if (!guarded.ok) {
+      return { kind: "response", response: options.formatFailure(guarded) };
+    }
+    const requestState = await options.runtime.codec.mint({
+      identity: state.identity,
+      argumentsDigest: state.argumentsDigest,
+      round: nextRound,
+      accepted
+    }, options.context);
+    return {
+      kind: "response",
+      response: inputRequired({
+        inputRequests: {
+          [nextRequest.key]: inputRequired.elicit({
+            message: nextRequest.message,
+            requestedSchema: nextRequest.schema
+          })
+        },
+        requestState
+      })
+    };
+  }
+  return {
+    kind: "continue",
+    context: {
+      ...transportContext(options.context, options.tool.name, "complete", state.round),
+      mcpInput: accepted
+    }
+  };
+}
+
+// src/tools/mcp-trace.ts
+import {
+  BAGGAGE_META_KEY,
+  TRACEPARENT_META_KEY,
+  TRACESTATE_META_KEY
+} from "@modelcontextprotocol/server";
+function runInMcpRequestContext(context, toolName, body) {
+  const ambient = getRequestContext();
+  const metadata = context.mcpReq._meta;
+  const propagation = metadata ? {
+    traceparent: metadata[TRACEPARENT_META_KEY],
+    tracestate: metadata[TRACESTATE_META_KEY],
+    baggage: metadata[BAGGAGE_META_KEY]
+  } : undefined;
+  const request = {
+    ...ambient ?? {
+      source: "mcp",
+      method: "MCP",
+      path: `/mcp/${toolName}`,
+      startedAt: process.hrtime.bigint()
+    },
+    trace: resolvePropagationContext(propagation, ambient?.trace),
+    source: "mcp",
+    method: "MCP",
+    path: `/mcp/${toolName}`,
+    startedAt: process.hrtime.bigint(),
+    dimensions: ambient?.dimensions ? { ...ambient.dimensions } : undefined,
+    error: undefined
+  };
+  return runWithRequestContext(request, body);
+}
+
 // src/tools/native-mcp.ts
-import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  isCallToolResult
+} from "@modelcontextprotocol/server";
 import { z } from "zod";
-function isCallToolResult(value) {
-  return CallToolResultSchema.safeParse(value).success;
-}
 function mountPreparedRuntimeMcp(server, tools, config) {
   for (const { definition, descriptor } of tools) {
     const { mountable } = descriptor;
@@ -381,35 +653,47 @@ function mountPreparedRuntimeMcp(server, tools, config) {
         "ui/resourceUri": definition.ui.resourceUri
       };
     }
-    server.registerTool(definition.name, toolConfig, async (rawArgs) => {
+    server.registerTool(definition.name, toolConfig, async (rawArgs, mcpContext) => runInMcpRequestContext(mcpContext, definition.name, async () => {
       const args = isRecord(rawArgs) ? rawArgs : {};
-      const result = await executeToolMethod(mountable.method, definition.name, args, { ...config.context, source: "mcp" }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(definition.name, paths) : undefined);
-      if (!result.ok || !definition.present?.mcp) {
+      const runTool = (tool2, toolArgs, roundContext) => executeToolMethod(tool2.method, definition.name, toolArgs, { ...config.context, ...roundContext, source: "mcp" }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(definition.name, paths) : undefined);
+      const round = await resolveMcpRound({
+        tool: mountable,
+        rawArgs: args,
+        context: mcpContext,
+        policy: mountable.method.mcp,
+        runtime: config.multiRoundRuntime,
+        runTool,
+        formatFailure: (result) => config.formatResult(result, "none", definition.name)
+      });
+      if (round.kind === "response")
+        return round.response;
+      if (!definition.present?.mcp) {
+        const result = await runTool(mountable, args, round.context);
         return config.formatResult(result, descriptor.outputMode, definition.name);
       }
-      const presented = await definition.present.mcp(result.data);
-      if ("structuredContent" in presented || "isError" in presented) {
-        return config.formatResult({
-          ok: false,
-          code: "INTERNAL_SERVER_ERROR",
-          details: {
-            message: "Runtime MCP presenter cannot set framework-owned structuredContent or isError"
-          }
-        }, "none", definition.name);
-      }
-      const structured = config.formatResult(result, descriptor.outputMode, definition.name).structuredContent;
-      const response = {
-        ...presented,
-        ...structured && { structuredContent: structured }
-      };
-      if (isCallToolResult(response))
+      const presentedResult = await executeToolMethod(mountable.method, definition.name, args, { ...config.context, ...round.context, source: "mcp" }, config.hooks, config.lifecycle, config.coerceJsonArgs ?? true, config.onOutputStrip ? (paths) => config.onOutputStrip?.(definition.name, paths) : undefined, undefined, async (data) => {
+        const presented = await definition.present?.mcp?.(data);
+        if (!presented) {
+          throw new AppError("INTERNAL_SERVER_ERROR", "Runtime MCP presenter did not return a result", 500);
+        }
+        if ("structuredContent" in presented || "isError" in presented) {
+          throw new AppError("INTERNAL_SERVER_ERROR", "Runtime MCP presenter cannot set framework-owned structuredContent or isError", 500);
+        }
+        const structured = config.formatResult({ ok: true, data }, descriptor.outputMode, definition.name).structuredContent;
+        const response = structured === undefined ? presented : { ...presented, structuredContent: structured };
+        if (!isCallToolResult(response)) {
+          throw new AppError("INTERNAL_SERVER_ERROR", "Runtime MCP presenter returned an invalid CallToolResult", 500);
+        }
         return response;
-      return config.formatResult({
-        ok: false,
-        code: "INTERNAL_SERVER_ERROR",
-        details: { message: "Runtime MCP presenter returned an invalid CallToolResult" }
-      }, "none", definition.name);
-    });
+      });
+      if (!presentedResult.ok) {
+        return config.formatResult(presentedResult, "none", definition.name);
+      }
+      if (!isCallToolResult(presentedResult.data)) {
+        throw new Error("[stitchkit] Runtime MCP presenter invariant failed");
+      }
+      return presentedResult.data;
+    }));
   }
 }
 
@@ -576,14 +860,13 @@ function textBlock(text) {
 }
 function formatMcpResult(result, mode, toolName, errorHint) {
   if (result.ok) {
-    const content = textBlock(JSON.stringify(result.data, null, 2));
-    if (mode === "wrapped") {
-      return { content, structuredContent: { result: result.data } };
+    if (mode === "none")
+      return { content: [] };
+    const serialized = JSON.stringify(result.data, null, 2);
+    if (serialized === undefined) {
+      throw new Error(`[stitchkit] MCP tool "${toolName ?? "unknown"}" produced a non-JSON output`);
     }
-    if (mode === "direct" && isRecord(result.data)) {
-      return { content, structuredContent: result.data };
-    }
-    return { content };
+    return { content: textBlock(serialized), structuredContent: result.data };
   }
   return {
     content: textBlock(JSON.stringify(formatToolError(result, toolName, errorHint), null, 2)),
@@ -601,10 +884,7 @@ function probeSchema(schema, io) {
 function resolveOutputSchema(outputSchema) {
   if (!outputSchema)
     return null;
-  if (outputSchema instanceof z2.ZodObject) {
-    return { schema: outputSchema, mode: "direct" };
-  }
-  return { schema: z2.object({ result: outputSchema }), mode: "wrapped" };
+  return { schema: outputSchema, mode: "direct" };
 }
 function reportIncompatible(message, policy, logger, failures) {
   if (policy === "throw") {
@@ -774,15 +1054,26 @@ function mountPreparedMcp(mcpServer, prepared, config = {}) {
         "ui/resourceUri": mountable.method.ui.resourceUri
       };
     }
-    mcpServer.registerTool(mountable.name, toolConfig, async (rawArgs) => {
+    mcpServer.registerTool(mountable.name, toolConfig, async (rawArgs, mcpContext) => runInMcpRequestContext(mcpContext, mountable.name, async () => {
       const args = isRecord(rawArgs) ? rawArgs : {};
       try {
-        const result = await runTool(mountable, args);
+        const round = await resolveMcpRound({
+          tool: mountable,
+          rawArgs: args,
+          context: mcpContext,
+          policy: mountable.method.mcp,
+          runtime: config.multiRoundRuntime,
+          runTool,
+          formatFailure: (result2) => formatMcpResult(result2, "none", mountable.name, config.errorHint)
+        });
+        if (round.kind === "response")
+          return round.response;
+        const result = await runTool(mountable, args, round.context);
         return formatMcpResult(result, descriptor.outputMode, mountable.name, config.errorHint);
       } catch (err) {
         return formatMcpResult(toolResultFromError(err), "none", mountable.name, config.errorHint);
       }
-    });
+    }));
   }
 }
 function buildMcpServer(config, auth) {
@@ -810,7 +1101,29 @@ function buildMcpServer(config, auth) {
   return buildMcpServerFromPrepared(config, auth, prepared);
 }
 function buildMcpServerFromPrepared(config, auth, prepared) {
-  const server = new McpServer(config.serverInfo, config.instructions ? { instructions: config.instructions } : undefined);
+  let roundCodec;
+  if (config.multiRound) {
+    const principal = config.multiRound.state.principal(auth);
+    roundCodec = createRequestStateCodec({
+      key: config.multiRound.state.key,
+      ttlSeconds: config.multiRound.state.ttlSeconds,
+      bind: (mcpContext) => `${mcpContext.mcpReq.method}\x00${principal}`
+    });
+  }
+  const dynamicSurface = !config.surfaces && (typeof config.services === "function" || typeof config.runtimeTools === "function");
+  const serverOptions = {
+    ...config.instructions !== undefined && { instructions: config.instructions },
+    ...!dynamicSurface && config.cache?.operations !== undefined && {
+      cacheHints: config.cache.operations
+    },
+    ...config.multiRound?.serving !== undefined && {
+      inputRequired: config.multiRound.serving
+    },
+    ...roundCodec !== undefined && {
+      requestState: { verify: roundCodec.verify }
+    }
+  };
+  const server = new McpServer(config.serverInfo, serverOptions);
   const context = config.context?.(auth);
   mountPreparedMcp(server, prepared.contractTools, {
     context,
@@ -822,7 +1135,13 @@ function buildMcpServerFromPrepared(config, auth, prepared) {
     coerceJsonArgs: config.coerceJsonArgs,
     flattenUnionInput: config.flattenUnionInput,
     errorHint: config.errorHint,
-    onOutputStrip: config.onOutputStrip
+    onOutputStrip: config.onOutputStrip,
+    ...roundCodec !== undefined && {
+      multiRoundRuntime: {
+        codec: roundCodec,
+        maxRounds: config.multiRound?.serving?.maxRounds ?? 10
+      }
+    }
   });
   mountPreparedRuntimeMcp(server, prepared.runtimeTools, {
     context,
@@ -830,7 +1149,13 @@ function buildMcpServerFromPrepared(config, auth, prepared) {
     lifecycle: config.lifecycle,
     coerceJsonArgs: config.coerceJsonArgs,
     onOutputStrip: config.onOutputStrip,
-    formatResult: (result, mode, toolName) => formatMcpResult(result, mode, toolName, config.errorHint)
+    formatResult: (result, mode, toolName) => formatMcpResult(result, mode, toolName, config.errorHint),
+    ...roundCodec !== undefined && {
+      multiRoundRuntime: {
+        codec: roundCodec,
+        maxRounds: config.multiRound?.serving?.maxRounds ?? 10
+      }
+    }
   });
   config.rawTools?.(server, auth);
   for (const resource of config.resources ?? []) {
@@ -839,7 +1164,10 @@ function buildMcpServerFromPrepared(config, auth, prepared) {
   return server;
 }
 function mountMcpResource(server, resource) {
-  server.registerResource(resource.name, resource.uri, { mimeType: resource.mimeType ?? RESOURCE_MIME_TYPE }, async () => ({
+  server.registerResource(resource.name, resource.uri, {
+    mimeType: resource.mimeType ?? RESOURCE_MIME_TYPE,
+    ...resource.cacheHint !== undefined && { cacheHint: resource.cacheHint }
+  }, async () => ({
     contents: [
       {
         uri: resource.uri,
@@ -851,10 +1179,11 @@ function mountMcpResource(server, resource) {
   }));
 }
 // src/tools/mcp-handler.ts
-import { randomUUID } from "node:crypto";
 import {
-  WebStandardStreamableHTTPServerTransport
-} from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+  createMcpHandler as createSdkMcpHandler,
+  hostHeaderValidationResponse,
+  originValidationResponse
+} from "@modelcontextprotocol/server";
 
 // src/tools/oauth-metadata.ts
 var PROTECTED_RESOURCE_PATH = "/.well-known/oauth-protected-resource";
@@ -897,53 +1226,26 @@ function oauthProtectedResourceRoute(config) {
 }
 
 // src/tools/mcp-handler.ts
-var EVENT_TTL_MS = 10 * 60 * 1000;
-var SESSION_TTL_MS = 30 * 60 * 1000;
-var SWEEP_INTERVAL_MS = 60 * 1000;
-var MAX_EVENTS = 1e4;
-var MAX_SESSIONS = 1000;
-
-class InMemoryEventStore {
-  events = new Map;
-  counter = 0;
-  async storeEvent(streamId, message) {
-    const eventId = String(++this.counter);
-    this.events.set(eventId, { streamId, message, timestamp: Date.now() });
-    if (this.events.size > MAX_EVENTS) {
-      const oldest = this.events.keys().next().value;
-      if (oldest !== undefined)
-        this.events.delete(oldest);
-    }
-    return eventId;
-  }
-  async getStreamIdForEventId(eventId) {
-    return this.events.get(eventId)?.streamId;
-  }
-  async replayEventsAfter(lastEventId, { send }) {
-    const anchor = this.events.get(lastEventId);
-    if (!anchor)
-      return "";
-    const lastIdNum = Number(lastEventId);
-    for (const [eventId, event] of this.events) {
-      if (event.streamId === anchor.streamId && Number(eventId) > lastIdNum) {
-        await send(eventId, event.message);
-      }
-    }
-    return anchor.streamId;
-  }
-  cleanup() {
-    const cutoff = Date.now() - EVENT_TTL_MS;
-    for (const [eventId, event] of this.events) {
-      if (event.timestamp < cutoff)
-        this.events.delete(eventId);
-    }
-  }
-}
 function jsonRpcError(code, message, status, headers) {
   return Response.json({ jsonrpc: "2.0", error: { code, message }, id: null }, { status, headers });
 }
-function createMcpHandler(config) {
-  let buildServer;
+function defaultHostRejection(request) {
+  const host = request.headers.get("host");
+  if (!host || host === new URL(request.url).host)
+    return;
+  return jsonRpcError(-32000, "Invalid Host header", 403);
+}
+function defaultOriginRejection(request) {
+  const origin = request.headers.get("origin");
+  if (!origin)
+    return;
+  try {
+    if (new URL(origin).origin === new URL(request.url).origin)
+      return;
+  } catch {}
+  return jsonRpcError(-32000, "Invalid Origin header", 403);
+}
+function prepareStaticSurface(config) {
   const preparation = {
     logger: config.logger,
     extend: config.extend,
@@ -951,7 +1253,6 @@ function createMcpHandler(config) {
     schemaValidation: config.schemaValidation
   };
   if (config.surfaces && config.selectSurface) {
-    const selectSurface = config.selectSurface;
     const preparedByKey = new Map;
     const preparedBySurface = new WeakMap;
     for (const key in config.surfaces) {
@@ -966,110 +1267,111 @@ function createMcpHandler(config) {
         preparedBySurface.set(surface, prepared);
       preparedByKey.set(key, prepared);
     }
-    buildServer = (auth) => {
-      const key = selectSurface(auth);
+    return (auth) => {
+      const key = config.selectSurface(auth);
       const prepared = preparedByKey.get(key);
       if (!prepared)
         throw new Error(`[stitchkit] Unknown MCP surface "${key}"`);
       return buildMcpServerFromPrepared(config, auth, prepared);
     };
-  } else if (config.services && typeof config.services !== "function" && typeof config.runtimeTools !== "function") {
+  }
+  if (config.services && typeof config.services !== "function" && typeof config.runtimeTools !== "function") {
     const prepared = prepareMcpServerSurface({ services: config.services, runtimeTools: config.runtimeTools }, preparation);
-    buildServer = (auth) => buildMcpServerFromPrepared(config, auth, prepared);
-  } else {
-    buildServer = (auth) => buildMcpServer(config, auth);
+    return (auth) => buildMcpServerFromPrepared(config, auth, prepared);
   }
+  return null;
+}
+function createMcpHandler(config) {
+  const buildPrepared = prepareStaticSurface(config);
+  const authByCarrier = new WeakMap;
+  let closed = false;
+  let resolveClosed;
+  const closedSignal = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
+  const sdkHandler = createSdkMcpHandler(({ authInfo }) => {
+    const resolved = authInfo ? authByCarrier.get(authInfo) : undefined;
+    if (!resolved) {
+      throw new Error("[stitchkit] MCP request reached the SDK without resolved auth");
+    }
+    const auth = resolved.value;
+    return buildPrepared ? buildPrepared(auth) : buildMcpServer(config, auth);
+  }, {
+    legacy: config.legacy === "reject" ? "reject" : "stateless",
+    maxSubscriptions: 0
+  });
   const unauthorized = () => {
     const headers = config.protectedResource ? { "WWW-Authenticate": wwwAuthenticateHeader(config.protectedResource.resource) } : undefined;
     return jsonRpcError(-32001, "Authorization required", 401, headers);
   };
-  if ((config.sessionMode ?? "stateless") === "stateless") {
-    return async (req) => {
-      const auth = await config.auth(req);
-      if (!auth)
-        return unauthorized();
-      const transport = new WebStandardStreamableHTTPServerTransport({
-        sessionIdGenerator: undefined,
-        enableJsonResponse: true
-      });
-      const server = buildServer(auth);
-      await server.connect(transport);
-      return transport.handleRequest(req);
-    };
-  }
-  const eventStore = new InMemoryEventStore;
-  const sessions = new Map;
-  const closeTransport = (transport) => {
-    transport.close().catch((err) => {
-      console.error("[stitchkit] MCP transport close failed:", err);
+  const observeRejection = (request, response) => {
+    if (response.status < 400 || !config.onTransportRejected)
+      return response;
+    Promise.resolve(config.onTransportRejected({ request, response: response.clone() })).catch(() => {
+      return;
     });
+    return response;
   };
-  setInterval(() => {
-    eventStore.cleanup();
-    const cutoff = Date.now() - SESSION_TTL_MS;
-    for (const [id, session] of sessions) {
-      if (session.lastSeen < cutoff) {
-        sessions.delete(id);
-        closeTransport(session.transport);
-      }
-    }
-  }, SWEEP_INTERVAL_MS).unref();
-  return async (req) => {
-    const auth = await config.auth(req);
-    if (!auth)
-      return unauthorized();
-    const sessionId = req.headers.get("mcp-session-id");
-    if (sessionId) {
-      const existing = sessions.get(sessionId);
-      if (!existing) {
-        return jsonRpcError(-32001, "Session not found", 404);
-      }
-      existing.lastSeen = Date.now();
-      if (req.method === "GET") {
-        existing.transport.closeStandaloneSSEStream();
+  return {
+    fetch: async (request) => {
+      if (closed) {
+        return observeRejection(request, jsonRpcError(-32000, "MCP handler is closed", 503));
       }
-      return existing.transport.handleRequest(req);
-    }
-    if (sessions.size >= MAX_SESSIONS) {
-      let oldestId;
-      let oldestSeen = Number.POSITIVE_INFINITY;
-      for (const [id, session] of sessions) {
-        if (session.lastSeen < oldestSeen) {
-          oldestSeen = session.lastSeen;
-          oldestId = id;
-        }
+      const hostRejection = config.security?.allowedHosts ? hostHeaderValidationResponse(request, [...config.security.allowedHosts]) : defaultHostRejection(request);
+      if (hostRejection)
+        return observeRejection(request, hostRejection);
+      const originRejection = config.security?.allowedOrigins ? originValidationResponse(request, [...config.security.allowedOrigins]) : defaultOriginRejection(request);
+      if (originRejection)
+        return observeRejection(request, originRejection);
+      const auth = await Promise.race([
+        Promise.resolve(config.auth(request)),
+        closedSignal.then(() => null)
+      ]);
+      if (closed) {
+        return observeRejection(request, jsonRpcError(-32000, "MCP handler is closed", 503));
       }
-      if (oldestId !== undefined) {
-        const evicted = sessions.get(oldestId);
-        sessions.delete(oldestId);
-        if (evicted)
-          closeTransport(evicted.transport);
+      if (auth === null)
+        return observeRejection(request, unauthorized());
+      const authCarrier = {
+        token: "",
+        clientId: config.multiRound?.state.principal(auth) ?? "stitchkit",
+        scopes: []
+      };
+      authByCarrier.set(authCarrier, { value: auth });
+      try {
+        return observeRejection(request, await sdkHandler.fetch(request, { authInfo: authCarrier }));
+      } finally {
+        authByCarrier.delete(authCarrier);
       }
+    },
+    close: async () => {
+      if (closed)
+        return;
+      closed = true;
+      resolveClosed?.();
+      await sdkHandler.close();
     }
-    const newSessionId = randomUUID();
-    const transport = new WebStandardStreamableHTTPServerTransport({
-      sessionIdGenerator: () => newSessionId,
-      eventStore
-    });
-    const server = buildServer(auth);
-    sessions.set(newSessionId, { transport, server, lastSeen: Date.now() });
-    transport.onclose = () => {
-      sessions.delete(newSessionId);
-    };
-    await server.connect(transport);
-    return transport.handleRequest(req);
+  };
+}
+function createMcpHttpRoute(config) {
+  return {
+    method: "ALL",
+    path: config.path,
+    handler: (request) => config.handler.fetch(request)
   };
 }
 // src/tools/mcp-stdio.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
 async function createStdioMcpServer(config) {
   const auth = await config.auth;
-  const server = buildMcpServer(config, auth);
-  await server.connect(new StdioServerTransport);
-  return server;
+  return serveStdio(() => buildMcpServer(config, auth), {
+    legacy: config.legacy ?? "serve",
+    maxSubscriptions: 0
+  });
 }
 // src/tools/mount-download.ts
 import { basename, extname, join } from "node:path";
+import { z as z3 } from "zod";
 
 // src/tools/native-result.ts
 function textResult(text, isError = false) {
@@ -1111,7 +1413,7 @@ function baseNameFor(url) {
 function mountDownload(server, config) {
   const name = config.name ?? "download";
   assertToolName(name, "<native>", "download");
-  server.registerTool(name, { description: config.description, inputSchema: config.inputSchema }, async (rawArgs) => {
+  server.registerTool(name, { description: config.description, inputSchema: z3.object(config.inputSchema) }, async (rawArgs) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
     try {
       const url = await config.resolveUrl(args);
@@ -1140,13 +1442,13 @@ function mountDownload(server, config) {
   });
 }
 // src/tools/mount-upload.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 function mountUpload(server, config) {
   const name = config.name ?? "upload";
   assertToolName(name, "<native>", "upload");
   server.registerTool(name, {
     description: config.description,
-    inputSchema: { path: z3.string().describe("Path to a local file on this machine") }
+    inputSchema: { path: z4.string().describe("Path to a local file on this machine") }
   }, async (rawArgs) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
     const path = typeof args.path === "string" ? args.path : "";
@@ -1161,10 +1463,11 @@ function mountUpload(server, config) {
   });
 }
 // src/tools/mount-wait.ts
+import { z as z5 } from "zod";
 function mountWait(server, config) {
   const name = config.name ?? "wait";
   assertToolName(name, "<native>", "wait");
-  server.registerTool(name, { description: config.description, inputSchema: config.inputSchema }, async (rawArgs) => {
+  server.registerTool(name, { description: config.description, inputSchema: z5.object(config.inputSchema) }, async (rawArgs) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
     try {
       const { state, timedOut } = await pollUntil({
@@ -1181,7 +1484,35 @@ function mountWait(server, config) {
   });
 }
 // src/tools/oauth-provider.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID } from "node:crypto";
+import { z as z6 } from "zod";
+function isPlainDisplayCharacter(character) {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== undefined && codePoint >= 32 && codePoint !== 127 && character !== "<" && character !== ">";
+}
+var CimdClientMetadataSchema = z6.object({
+  client_id: z6.url(),
+  redirect_uris: z6.array(z6.url()).min(1),
+  client_name: z6.string().trim().min(1).max(200).refine((value) => Array.from(value).every(isPlainDisplayCharacter), {
+    message: "client_name must be plain display text"
+  }),
+  token_endpoint_auth_method: z6.literal("none"),
+  application_type: z6.enum(["native", "web"]).optional()
+});
+function createSecureClientMetadataFetcher(policy = {}) {
+  assertPositiveInteger("cimd.maxBytes", policy.maxBytes ?? DEFAULT_CIMD_MAX_BYTES);
+  assertPositiveNumber("cimd.timeoutMs", policy.timeoutMs ?? DEFAULT_CIMD_TIMEOUT_MS);
+  assertNonNegativeInteger("cimd.maxRedirects", policy.maxRedirects ?? 3);
+  return {
+    fetch: (url, headers) => fetchPinnedDocument(url, {
+      maxBytes: policy.maxBytes ?? DEFAULT_CIMD_MAX_BYTES,
+      timeoutMs: policy.timeoutMs ?? DEFAULT_CIMD_TIMEOUT_MS,
+      maxRedirects: policy.maxRedirects ?? 3,
+      headers,
+      requireHttps: true
+    })
+  };
+}
 var PUBLIC_CORS2 = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
@@ -1189,6 +1520,214 @@ var PUBLIC_CORS2 = {
 };
 var AS_METADATA_PATH = "/.well-known/oauth-authorization-server";
 var AUTH_CODE_TTL_MS = 60000;
+var DEFAULT_CIMD_MAX_BYTES = 64 * 1024;
+var DEFAULT_CIMD_TIMEOUT_MS = 5000;
+function assertPositiveInteger(name, value) {
+  if (!Number.isInteger(value) || value < 1)
+    throw new Error(`${name} must be a positive integer`);
+}
+function assertNonNegativeInteger(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative integer`);
+  }
+}
+function assertPositiveNumber(name, value) {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new Error(`${name} must be positive`);
+}
+function absoluteClientUrl(clientId) {
+  try {
+    return new URL(clientId);
+  } catch {
+    return null;
+  }
+}
+function assertCimdClientId(clientId) {
+  const url = new URL(clientId);
+  if (url.protocol !== "https:")
+    throw new Error("CIMD client_id must use https");
+  if (url.username || url.password)
+    throw new Error("CIMD client_id cannot contain credentials");
+  if (url.hash)
+    throw new Error("CIMD client_id cannot contain a fragment");
+  if (url.search)
+    throw new Error("CIMD client_id cannot contain a query");
+  if (url.toString() !== clientId) {
+    throw new Error("CIMD client_id must be an exact canonical URL");
+  }
+  return url;
+}
+function responseFreshness(headers, policy, now) {
+  const maxTtl = policy.maxTtlMs ?? 3600000;
+  const cacheControl = headers.get("cache-control") ?? "";
+  if (/(?:^|,)\s*no-store\s*(?:,|$)/i.test(cacheControl)) {
+    return { freshnessMs: 0, store: false };
+  }
+  if (/(?:^|,)\s*no-cache\s*(?:,|$)/i.test(cacheControl)) {
+    return { freshnessMs: 0, store: true };
+  }
+  const maxAge = cacheControl.match(/(?:^|,)\s*max-age=(\d+)/i)?.[1];
+  if (maxAge !== undefined) {
+    const age = Number(headers.get("age") ?? 0);
+    return {
+      freshnessMs: Math.max(0, Math.min(maxTtl, (Number(maxAge) - age) * 1000)),
+      store: true
+    };
+  }
+  const expires = headers.get("expires");
+  if (expires) {
+    const expiresAt = Date.parse(expires);
+    if (Number.isFinite(expiresAt)) {
+      const dateAt = Date.parse(headers.get("date") ?? "");
+      const ageMs = Number(headers.get("age") ?? 0) * 1000;
+      const lifetime = Number.isFinite(dateAt) ? expiresAt - dateAt : expiresAt - now;
+      return {
+        freshnessMs: Math.max(0, Math.min(maxTtl, lifetime - ageMs)),
+        store: true
+      };
+    }
+  }
+  return { freshnessMs: Math.min(maxTtl, policy.defaultTtlMs ?? 300000), store: true };
+}
+function safeClientName(value) {
+  if (value === undefined)
+    return;
+  const safe = Array.from(value).filter(isPlainDisplayCharacter).join("").trim().slice(0, 200);
+  return safe || undefined;
+}
+function parseScopes(value) {
+  if (!value)
+    return [];
+  return [...new Set(value.split(/\s+/u).filter(Boolean))];
+}
+function toRegisteredClient(metadata) {
+  return {
+    clientId: metadata.client_id,
+    redirectUris: metadata.redirect_uris,
+    ...metadata.client_name !== undefined && { clientName: metadata.client_name },
+    ...metadata.application_type !== undefined && {
+      applicationType: metadata.application_type
+    }
+  };
+}
+function isJsonContentType(value) {
+  const mediaType = value.split(";", 1)[0]?.trim().toLowerCase();
+  return mediaType === "application/json" || mediaType?.endsWith("+json") === true;
+}
+function createCimdResolver(options) {
+  const policy = options.cache ?? {};
+  const now = options.now ?? Date.now;
+  const cache = new Map;
+  const inflight = new Map;
+  const maxEntries = policy.maxEntries ?? 256;
+  assertPositiveInteger("cimd.cache.maxEntries", maxEntries);
+  assertNonNegativeInteger("cimd.cache.defaultTtlMs", policy.defaultTtlMs ?? 300000);
+  assertNonNegativeInteger("cimd.cache.maxTtlMs", policy.maxTtlMs ?? 3600000);
+  assertNonNegativeInteger("cimd.cache.negativeTtlMs", policy.negativeTtlMs ?? 1e4);
+  const emit = (event) => {
+    try {
+      options.onCacheEvent?.(event);
+    } catch {}
+  };
+  const touch = (key, value) => {
+    cache.delete(key);
+    cache.set(key, value);
+    while (cache.size > maxEntries) {
+      const oldest = cache.keys().next().value;
+      if (oldest === undefined)
+        break;
+      cache.delete(oldest);
+    }
+  };
+  const resolveOne = async (clientId) => {
+    const url = assertCimdClientId(clientId);
+    const cached = cache.get(clientId);
+    if (cached && cached.expiresAt > now()) {
+      touch(clientId, cached);
+      if (cached.ok) {
+        emit({ clientId, status: "hit", freshnessMs: cached.expiresAt - now() });
+        return cached.client;
+      }
+      emit({ clientId, status: "negative", freshnessMs: cached.expiresAt - now() });
+      throw new Error(cached.message);
+    }
+    emit({ clientId, status: "miss" });
+    const conditionalHeaders = {};
+    if (cached?.ok && cached.etag)
+      conditionalHeaders["if-none-match"] = cached.etag;
+    if (cached?.ok && cached.lastModified) {
+      conditionalHeaders["if-modified-since"] = cached.lastModified;
+    }
+    let cacheFailure = true;
+    try {
+      const response = await options.fetcher.fetch(url, conditionalHeaders);
+      const freshness = responseFreshness(response.headers, policy, now());
+      cacheFailure = freshness.store;
+      if (response.status === 304 && cached?.ok) {
+        const refreshed = {
+          ...cached,
+          expiresAt: now() + freshness.freshnessMs
+        };
+        if (freshness.store)
+          touch(clientId, refreshed);
+        else
+          cache.delete(clientId);
+        emit({ clientId, status: "revalidated", freshnessMs: freshness.freshnessMs });
+        return refreshed.client;
+      }
+      if (response.status !== 200) {
+        throw new Error(`CIMD endpoint returned HTTP ${response.status}`);
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      if (!isJsonContentType(contentType)) {
+        throw new Error("CIMD endpoint must return a JSON media type");
+      }
+      const decoded = JSON.parse(new TextDecoder().decode(response.body));
+      const metadata = CimdClientMetadataSchema.parse(decoded);
+      if (metadata.client_id !== clientId) {
+        throw new Error("CIMD client_id does not exactly match the requested URL");
+      }
+      if (!metadata.redirect_uris.every((uri) => isRegistrableRedirectUri(uri, metadata.application_type))) {
+        throw new Error("CIMD redirect_uris contains a URI forbidden for the application type");
+      }
+      const client = toRegisteredClient(metadata);
+      if (freshness.store) {
+        touch(clientId, {
+          ok: true,
+          client,
+          expiresAt: now() + freshness.freshnessMs,
+          ...response.headers.get("etag") !== null && {
+            etag: response.headers.get("etag") ?? undefined
+          },
+          ...response.headers.get("last-modified") !== null && {
+            lastModified: response.headers.get("last-modified") ?? undefined
+          }
+        });
+      } else {
+        cache.delete(clientId);
+      }
+      return client;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "CIMD metadata resolution failed";
+      if (cacheFailure) {
+        touch(clientId, {
+          ok: false,
+          message,
+          expiresAt: now() + (policy.negativeTtlMs ?? 1e4)
+        });
+      }
+      throw error;
+    }
+  };
+  return async (clientId) => {
+    const pending = inflight.get(clientId);
+    if (pending)
+      return pending;
+    const created = resolveOne(clientId).finally(() => inflight.delete(clientId));
+    inflight.set(clientId, created);
+    return created;
+  };
+}
 function json(body, status = 200, extraHeaders) {
   return new Response(JSON.stringify(body), {
     status,
@@ -1201,6 +1740,8 @@ function oauthError(error, description, status = 400) {
 function isRegistrableRedirectUri(value, applicationType) {
   try {
     const url = new URL(value);
+    if (url.username || url.password || url.hash)
+      return false;
     if (url.protocol === "https:")
       return true;
     if (url.protocol !== "http:")
@@ -1213,6 +1754,17 @@ function isRegistrableRedirectUri(value, applicationType) {
     return false;
   }
 }
+function isLoopbackRedirectUri(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:")
+      return false;
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    return host === "127.0.0.1" || host === "::1" || host === "localhost";
+  } catch {
+    return false;
+  }
+}
 function redirectWith(uri, params) {
   const url = new URL(uri);
   for (const [key, value] of Object.entries(params))
@@ -1240,6 +1792,33 @@ function mountOAuthProvider(config) {
   const registerPath = `${base}/register`;
   const authorizePath = `${base}/authorize`;
   const tokenPath = `${base}/token`;
+  const clientRegistration = config.clientRegistration ?? {};
+  const dcrRegistry = clientRegistration.dcr || undefined;
+  const dcrEnabled = dcrRegistry !== undefined;
+  const cimdConfig = clientRegistration.cimd === false ? undefined : clientRegistration.cimd ?? {};
+  const cimdEnabled = cimdConfig !== undefined;
+  const resolveCimd = cimdEnabled ? createCimdResolver({
+    cache: cimdConfig.cache,
+    fetcher: cimdConfig.fetcher ?? createSecureClientMetadataFetcher(),
+    onCacheEvent: cimdConfig.onCacheEvent
+  }) : undefined;
+  const resolveClient = async (clientId) => {
+    const preRegistered = await clientRegistration.preRegistered?.get(clientId);
+    if (preRegistered)
+      return preRegistered.clientId === clientId ? preRegistered : null;
+    const clientUrl = absoluteClientUrl(clientId);
+    if (clientUrl) {
+      if (!resolveCimd || clientUrl.protocol !== "https:")
+        return null;
+      try {
+        return await resolveCimd(clientId);
+      } catch {
+        return null;
+      }
+    }
+    const dcrClient = await dcrRegistry?.get(clientId);
+    return dcrClient?.clientId === clientId ? dcrClient : null;
+  };
   const redirectToClient = (uri, params) => redirectWith(uri, { ...params, iss: config.issuer });
   const metadataRoute = {
     method: "ALL",
@@ -1251,11 +1830,12 @@ function mountOAuthProvider(config) {
         issuer: config.issuer,
         authorization_endpoint: `${config.issuer}${authorizePath}`,
         token_endpoint: `${config.issuer}${tokenPath}`,
-        registration_endpoint: `${config.issuer}${registerPath}`,
+        ...dcrEnabled && { registration_endpoint: `${config.issuer}${registerPath}` },
         response_types_supported: ["code"],
         grant_types_supported: config.refreshTokens ? ["authorization_code", "refresh_token"] : ["authorization_code"],
         code_challenge_methods_supported: ["S256"],
         token_endpoint_auth_methods_supported: ["none"],
+        ...cimdEnabled && { client_id_metadata_document_supported: true },
         authorization_response_iss_parameter_supported: true,
         ...config.scopesSupported && { scopes_supported: config.scopesSupported }
       });
@@ -1279,13 +1859,19 @@ function mountOAuthProvider(config) {
       }
       const applicationType = rawAppType;
       const redirectUris = meta.redirect_uris;
+      const tokenEndpointAuthMethod = meta.token_endpoint_auth_method ?? "none";
+      if (tokenEndpointAuthMethod !== "none") {
+        return oauthError("invalid_client_metadata", 'Only public clients with token_endpoint_auth_method "none" are supported');
+      }
       if (!Array.isArray(redirectUris) || redirectUris.length === 0 || !redirectUris.every((u) => typeof u === "string" && isRegistrableRedirectUri(u, applicationType))) {
         return oauthError("invalid_redirect_uri", applicationType === "web" ? "redirect_uris must be a non-empty array of absolute https URLs (a web client cannot register an http loopback URI)" : "redirect_uris must be a non-empty array of absolute https URLs (http is allowed only on a loopback host)");
       }
-      const client = await config.clients.register({
+      if (!dcrRegistry)
+        throw new Error("DCR route mounted without a DCR registry");
+      const client = await dcrRegistry.register({
         redirectUris,
         clientName: typeof meta.client_name === "string" ? meta.client_name : undefined,
-        tokenEndpointAuthMethod: typeof meta.token_endpoint_auth_method === "string" ? meta.token_endpoint_auth_method : undefined,
+        tokenEndpointAuthMethod,
         ...applicationType && { applicationType }
       });
       return json({
@@ -1318,7 +1904,7 @@ function mountOAuthProvider(config) {
       if (!clientId || !redirectUri) {
         return oauthError("invalid_request", "client_id and redirect_uri are required");
       }
-      const client = await config.clients.get(clientId);
+      const client = await resolveClient(clientId);
       if (!client)
         return oauthError("invalid_client", "Unknown client_id", 401);
       if (!client.redirectUris.includes(redirectUri)) {
@@ -1351,18 +1937,49 @@ function mountOAuthProvider(config) {
           ...state && { state }
         });
       }
-      const authRequest = { clientId, redirectUri, scope, resource, state };
+      const requestedScopes = parseScopes(scope);
+      const supportedScopes = new Set(config.scopesSupported ?? []);
+      if (config.scopesSupported && requestedScopes.some((requestedScope2) => !supportedScopes.has(requestedScope2))) {
+        return redirectToClient(redirectUri, {
+          error: "invalid_scope",
+          error_description: "One or more requested scopes are not supported",
+          ...state && { state }
+        });
+      }
+      const requestedScope = requestedScopes.length > 0 ? requestedScopes.join(" ") : undefined;
+      const authRequest = {
+        clientId,
+        redirectUri,
+        scope: requestedScope,
+        resource,
+        state,
+        isLoopbackRedirect: isLoopbackRedirectUri(redirectUri),
+        ...safeClientName(client.clientName) !== undefined && {
+          clientName: safeClientName(client.clientName)
+        },
+        ...client.applicationType !== undefined && {
+          applicationType: client.applicationType
+        },
+        ...absoluteClientUrl(clientId)?.protocol === "https:" && {
+          clientOrigin: new URL(clientId).origin
+        }
+      };
       const result = await config.authorizeUser(req, authRequest);
       if (result instanceof Response)
         return result;
-      const code = randomUUID2();
+      const approvedScopes = [...new Set(result.approvedScopes)];
+      if (approvedScopes.some((approvedScope2) => !requestedScopes.includes(approvedScope2) || config.scopesSupported !== undefined && !supportedScopes.has(approvedScope2))) {
+        throw new Error("authorizeUser approvedScopes must be a subset of requested scopes");
+      }
+      const approvedScope = approvedScopes.length > 0 ? approvedScopes.join(" ") : undefined;
+      const code = randomUUID();
       await config.codes.save(code, {
         clientId,
         redirectUri,
         codeChallenge,
         codeChallengeMethod: "S256",
         resource,
-        scope,
+        scope: approvedScope,
         userId: result.userId,
         expiresAt: Date.now() + AUTH_CODE_TTL_MS
       });
@@ -1408,7 +2025,7 @@ function mountOAuthProvider(config) {
         const accessToken = await issueAccessToken(data.userId, data.resource, data.clientId, data.scope);
         let refreshToken;
         if (config.refreshTokens) {
-          refreshToken = randomUUID2();
+          refreshToken = randomUUID();
           await config.refreshTokens.save(refreshToken, {
             clientId: data.clientId,
             resource: data.resource,
@@ -1438,7 +2055,7 @@ function mountOAuthProvider(config) {
         if (data.clientId !== clientId)
           return oauthError("invalid_grant", "client_id mismatch");
         const accessToken = await issueAccessToken(data.userId, data.resource, data.clientId, data.scope);
-        const newRefresh = randomUUID2();
+        const newRefresh = randomUUID();
         await config.refreshTokens.save(newRefresh, data);
         return json({
           access_token: accessToken,
@@ -1451,7 +2068,7 @@ function mountOAuthProvider(config) {
       return oauthError("unsupported_grant_type", `Unsupported grant_type: ${grantType ?? "none"}`);
     }
   };
-  return [metadataRoute, registerRoute, authorizeRoute, tokenRoute];
+  return dcrEnabled ? [metadataRoute, registerRoute, authorizeRoute, tokenRoute] : [metadataRoute, authorizeRoute, tokenRoute];
 }
 // src/browser/client-multipart.ts
 function isFileDescriptor(value) {
@@ -1936,7 +2553,7 @@ function summarizeTransports(surface) {
 // src/tools/view-file.ts
 import { readFile, realpath, stat } from "node:fs/promises";
 import { extname as extname2, resolve } from "node:path";
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 var MAX_INLINE_BYTES = 20 * 1024 * 1024;
 var EXT_MIME = {
   ".png": "image/png",
@@ -2036,7 +2653,7 @@ function mountViewFile(server, options = {}) {
   server.registerTool("view_file", {
     description: "View media (image, audio, video) by URL or local path — returns it as content you can SEE / HEAR. Pass several paths to view multiple files at once. Use it on a generation `output` url to inspect the result.",
     inputSchema: {
-      paths: z4.union([z4.string(), z4.array(z4.string())]).describe("Media URL(s) or file path(s) to view")
+      paths: z7.union([z7.string(), z7.array(z7.string())]).describe("Media URL(s) or file path(s) to view")
     },
     annotations: { title: "View Media", readOnlyHint: true, idempotentHint: true }
   }, async (args) => {
@@ -2081,7 +2698,9 @@ export {
   createToolLogger,
   createToolInvoker,
   createStdioMcpServer,
+  createSecureClientMetadataFetcher,
   createRuntimeToolFactory,
+  createMcpHttpRoute,
   createMcpHandler,
   createCli,
   collectTools,