stitchkit 0.93.0 → 0.94.0

package/dist/{tools.js → entrypoints/tools.js}

@@ -1,11 +1,11 @@
 import {
   ManagedFileError
-} from "./index-actkayzn.js";
+} from "../index-70yj2ebz.js";
 import {
   signJwt,
   verifyPkce
-} from "./index-sr93cwf9.js";
-import"./index-hr4tzbwq.js";
+} from "../index-e2z3ahw9.js";
+import"../index-hr4tzbwq.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS,
   DEFAULT_PROCESS_SIGNALS,
@@ -14,20 +14,31 @@ import {
   guardSignalCallback,
   mediaTypeEssence,
   reportSignalError
-} from "./index-cxqhvq21.js";
+} from "../index-xnj9bgxe.js";
+import"../index-kvj7f4hq.js";
 import {
   redact
-} from "./index-6kyksz9y.js";
+} from "../index-yw4fzmdz.js";
 import {
   buildToolManifest,
   describeToolCatalog,
   mountAgent
-} from "./index-e42wzzz5.js";
+} from "../index-dcpdvjsc.js";
 import {
   AgentToolError,
   createLocalStepDurability,
   isAgentToolError
-} from "./index-kw9t5ayn.js";
+} from "../index-cq4qfycf.js";
+import"../index-rxfy4cq7.js";
+import {
+  ALL_TRANSPORTS,
+  TOOL_TRANSPORTS,
+  defineContract
+} from "../index-gyr48nzg.js";
+import {
+  ManagedFilePathSchema,
+  ManagedFileRefSchema
+} from "../index-6k1937bx.js";
 import {
   AsyncOperationCancelResultSchema,
   McpAnnotationsSchema,
@@ -36,69 +47,52 @@ import {
   ViewFileInputSchema,
   ViewFileOutputSchema,
   createAsyncOperationSnapshotSchema
-} from "./index-4fpa9dy2.js";
+} from "../index-m9zn6cpq.js";
 import {
   createToolInvoker
-} from "./index-bx75zwt7.js";
+} from "../index-rewkc2hj.js";
 import {
   WaitTimeoutError,
   createCli,
-  defineCliCommand,
   fetchGuarded,
   fetchPinnedDocument,
   readCapped,
   runWaitOperation
-} from "./index-3bmnp41g.js";
-import {
-  compareCodepoints,
-  serializeCanonicalJson
-} from "./index-0j3vcp5m.js";
-import"./index-sbdmyz75.js";
+} from "../index-n6hxg8as.js";
+import"../index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-2c2bjw3s.js";
+} from "../index-vcvkq30w.js";
 import {
   argumentsDigest
-} from "./index-a916km3r.js";
+} from "../index-0b1ess5e.js";
 import {
   collectTools,
   createToolRunner,
   formatToolError
-} from "./index-mzvgxp0n.js";
+} from "../index-2cr1cqhn.js";
 import {
   ToolExecutionControlError,
-  executeToolMethod,
   isToolExecutionControlError,
   parseToolCallArguments,
   toolResultFromError
-} from "./index-yn8remb1.js";
+} from "../index-j05z5gn4.js";
 import {
   getRequestContext,
   getTraceId,
   runWithRequestContext
-} from "./index-tmwcrptx.js";
-import"./index-f9mb610r.js";
-import {
-  normalizeError
-} from "./index-e0znv5gn.js";
-import {
-  defineContract
-} from "./index-0a349c33.js";
-import"./index-rxfy4cq7.js";
-import {
-  ManagedFilePathSchema,
-  ManagedFileRefSchema
-} from "./index-6k1937bx.js";
+} from "../index-zfrhfn82.js";
+import"../index-35mh5bhj.js";
 import {
   resolvePropagationContext
-} from "./index-zcgf3gqf.js";
+} from "../index-zcgf3gqf.js";
 import {
   coerceJsonArgs
-} from "./index-7zbps32p.js";
+} from "../index-1zbbzgfh.js";
 import {
   createRuntimeToolFactory,
   defineRuntimeTool
-} from "./index-vjpvjqpn.js";
+} from "../index-v38qyerb.js";
 import {
   PORTABLE_JSON_SCHEMA_FORMATS,
   assertToolName,
@@ -109,778 +103,714 @@ import {
   prepareProjectedMcpTools,
   presentationMetadata,
   staticInputRounds,
+  toolSurfaceOutputSchema,
   validateMcpRoundPolicy,
   validateResolvedInputRounds
-} from "./index-h9etkkyk.js";
+} from "../index-dydjcp8z.js";
 import {
   toJsonSchema
-} from "./index-cby4ar3v.js";
+} from "../index-eqqvgdb3.js";
+import {
+  normalizeError
+} from "../index-znfs20ss.js";
+import"../index-p5r7qpdd.js";
 import {
   AppError,
   STITCH_ERROR_STATUS
-} from "./index-2vtcmrj9.js";
-import"./index-kzfs85xp.js";
+} from "../index-2vtcmrj9.js";
+import {
+  compareCodeUnits,
+  serializeCanonicalJson
+} from "../index-k5hsfc3j.js";
+import"../index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-77fekveh.js";
-// src/tools/async-operation.ts
-import { z } from "zod";
-// src/tools/native-definition.ts
-function managedNativeIdentity(identity, method) {
-  return { ...identity, method };
-}
-
-// src/tools/define-wait-tool.ts
-function defineWaitTool(config) {
-  const renderedMcp = config.render ? {
-    mcp: (state) => {
-      const rendered = config.render?.(state, false);
-      return {
-        content: [
-          {
-            type: "text",
-            text: rendered?.text ?? JSON.stringify(state, null, 2)
-          }
-        ]
-      };
-    }
-  } : undefined;
-  const present = renderedMcp || config.present ? { ...renderedMcp, ...config.present } : undefined;
-  return defineRuntimeTool({
-    name: config.name ?? "wait",
-    description: config.description,
-    identity: managedNativeIdentity(config.identity, "GET"),
-    input: config.input,
-    output: config.state,
-    transports: config.transports,
-    annotations: config.annotations,
-    present,
-    handler: async (context) => {
-      let result;
-      try {
-        result = await runWaitOperation({
-          input: context.input,
-          poll: async (input, signal) => config.state.parse(await config.poll(input, { ...context, signal })),
-          done: config.done,
-          backoff: config.backoff,
-          timeoutSec: config.timeoutFromInput?.(context.input) ?? config.defaultTimeout,
-          signal: context.signal
-        });
-      } catch (error) {
-        if (error instanceof WaitTimeoutError) {
-          throw new AppError("WAIT_TIMEOUT", "Wait timed out before the first snapshot", 408);
-        }
-        throw error;
-      }
-      const rendered = config.render?.(result.state, result.timedOut);
-      if (result.timedOut) {
-        throw new AppError("WAIT_TIMEOUT", rendered?.text ?? "Wait timed out before the operation completed", 408);
-      }
-      if (rendered?.isError) {
-        throw new AppError("WAIT_FAILED", rendered.text, 409);
-      }
-      return result.state;
-    }
-  });
+} from "../index-hffjpmq9.js";
+// src/server/oauth/metadata.ts
+var PROTECTED_RESOURCE_PATH = "/.well-known/oauth-protected-resource";
+function metadataPath(resource) {
+  const { pathname } = new URL(resource);
+  return pathname === "/" ? PROTECTED_RESOURCE_PATH : `${PROTECTED_RESOURCE_PATH}${pathname}`;
 }
-
-// src/tools/async-operation.ts
-function terminal(snapshot) {
-  if (typeof snapshot !== "object" || snapshot === null || !("phase" in snapshot)) {
-    return false;
-  }
-  return snapshot.phase === "succeeded" || snapshot.phase === "failed" || snapshot.phase === "cancelled";
+function protectedResourceMetadataUrl(resource) {
+  return `${new URL(resource).origin}${metadataPath(resource)}`;
 }
-function succeeded(snapshot) {
-  return typeof snapshot === "object" && snapshot !== null && "phase" in snapshot && snapshot.phase === "succeeded";
+function wwwAuthenticateHeader(resource) {
+  return `Bearer resource_metadata="${protectedResourceMetadataUrl(resource)}"`;
 }
-function defineAsyncOperation(config) {
-  const capabilityName = (capability) => config.names?.[capability] ?? `${config.name}_${capability}`;
-  const description = (capability) => config.descriptions?.[capability] ?? `${config.description}: ${capability}`;
-  const identity = (capability, method) => ({
-    serviceName: config.identity.serviceName,
-    action: `${config.identity.action}.${capability}`,
-    scope: config.scopes?.[capability] ?? config.identity.scope,
-    meta: config.identity.meta,
-    method
-  });
-  const common = (capability) => ({
-    name: capabilityName(capability),
-    description: description(capability),
-    transports: config.transports?.[capability],
-    annotations: config.annotations?.[capability] ?? (capability === "start" || capability === "cancel" ? { destructiveHint: true } : undefined)
-  });
-  const inspect = async (capability, context) => {
-    await config.authorize(context.input, capability, context);
-    const state = config.state.parse(await config.inspect(context.input, context));
-    const snapshot = config.snapshot.parse(await config.classify(state, context));
-    return { state, snapshot };
-  };
-  const start = defineRuntimeTool({
-    ...common("start"),
-    identity: identity("start", "POST"),
-    input: config.startInput,
-    output: config.id,
-    handler: (context) => config.start(context.input, context)
-  });
-  const status = defineRuntimeTool({
-    ...common("status"),
-    identity: identity("status", "GET"),
-    input: config.id,
-    output: config.snapshot,
-    handler: async (context) => (await inspect("status", context)).snapshot
-  });
-  const wait = defineWaitTool({
-    ...common("wait"),
-    identity: identity("wait", "GET"),
-    input: config.id,
-    state: config.snapshot,
-    poll: async (_id, context) => (await inspect("wait", context)).snapshot,
-    done: terminal,
-    backoff: config.backoff,
-    defaultTimeout: config.defaultTimeout,
-    timeoutFromInput: config.timeoutFromId
+var PUBLIC_CORS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS
+};
+function oauthProtectedResourceRoute(config) {
+  const body = JSON.stringify({
+    resource: config.resource,
+    authorization_servers: config.authorizationServers,
+    ...config.scopesSupported && { scopes_supported: config.scopesSupported },
+    bearer_methods_supported: ["header"]
   });
-  const definitions = { start, status, wait };
-  const names = new Set;
-  if (config.cancel) {
-    const capability = config.cancel;
-    definitions.cancel = defineRuntimeTool({
-      ...common("cancel"),
-      identity: identity("cancel", "DELETE"),
-      input: config.id,
-      output: AsyncOperationCancelResultSchema,
-      handler: async (context) => {
-        const inspected = await inspect("cancel", context);
-        return capability.handler(inspected.state, context);
-      }
-    });
-  }
-  if (config.result) {
-    const capability = config.result;
-    definitions.result = defineRuntimeTool({
-      ...common("result"),
-      identity: identity("result", "GET"),
-      input: config.id,
-      output: capability.output,
-      handler: async (context) => {
-        const inspected = await inspect("result", context);
-        if (!succeeded(inspected.snapshot)) {
-          throw new AppError("OPERATION_NOT_SUCCEEDED", "Operation result is not available", 409);
-        }
-        return capability.handler(inspected.state, context);
-      }
-    });
-  }
-  if (config.artifacts) {
-    const capability = config.artifacts;
-    definitions.artifacts = defineRuntimeTool({
-      ...common("artifacts"),
-      identity: identity("artifacts", "GET"),
-      input: config.id,
-      output: capability.output,
-      handler: async (context) => {
-        const inspected = await inspect("artifacts", context);
-        if (!succeeded(inspected.snapshot)) {
-          throw new AppError("OPERATION_NOT_SUCCEEDED", "Operation artifacts are not available", 409);
-        }
-        return capability.handler(inspected.state, context);
-      }
-    });
-  }
-  for (const definition of Object.values(definitions)) {
-    assertUniqueToolName(definition.name, names.has(definition.name), "in-process tool name");
-    names.add(definition.name);
-  }
   return {
-    ...definitions,
-    runtimeTools: Object.values(definitions),
-    schemas: {
-      id: config.id,
-      snapshot: config.snapshot,
-      cancelResult: AsyncOperationCancelResultSchema
+    method: "ALL",
+    path: metadataPath(config.resource),
+    handler: (req) => {
+      if (req.method === "OPTIONS")
+        return new Response(null, { status: 204, headers: PUBLIC_CORS });
+      if (req.method !== "GET")
+        return new Response("Method Not Allowed", { status: 405 });
+      return new Response(body, {
+        status: 200,
+        headers: { "Content-Type": "application/json", ...PUBLIC_CORS }
+      });
     }
   };
 }
-function adapterResult(capability, target, schema, value) {
-  const parsed = schema.safeParse(value);
-  if (!parsed.success) {
-    throw new Error(`Async operation adapter for capability "${capability}" returned invalid ${target}`, { cause: parsed.error });
-  }
-  return parsed.data;
+// src/server/oauth/provider.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+function isPlainDisplayCharacter(character) {
+  const codePoint = character.codePointAt(0);
+  return codePoint !== undefined && codePoint >= 32 && codePoint !== 127 && character !== "<" && character !== ">";
 }
-var NON_WIRE_STABLE_ZOD_TYPES = new Set([
-  "catch",
-  "default",
-  "lazy",
-  "pipe",
-  "prefault",
-  "readonly",
-  "success",
-  "transform"
-]);
-function hasOverwriteCheck(value) {
-  return isRecord(value) && isRecord(value._zod) && isRecord(value._zod.def) && value._zod.def.check === "overwrite";
+var CimdClientMetadataSchema = z.object({
+  client_id: z.url(),
+  redirect_uris: z.array(z.url()).min(1),
+  client_name: z.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: z.literal("none"),
+  application_type: z.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
+    })
+  };
 }
-function assertWireStableIdSchema(schema, boundary) {
-  const visited = new Set;
-  const pending = [schema];
-  while (pending.length > 0) {
-    const value = pending.pop();
-    if (typeof value !== "object" || value === null || visited.has(value))
-      continue;
-    visited.add(value);
-    if (value instanceof z.ZodType) {
-      const definition = value._zod.def;
-      if (NON_WIRE_STABLE_ZOD_TYPES.has(definition.type) || "coerce" in definition && definition.coerce === true || "checks" in definition && Array.isArray(definition.checks) && definition.checks.some(hasOverwriteCheck)) {
-        throw new Error(`${boundary} must use a wire-stable ID schema without transforms, coercion, defaults or overwrites; use binding: "adapted" with explicit ID adapters`);
-      }
-      pending.push(...Object.values(definition));
-      continue;
-    }
-    if (Array.isArray(value)) {
-      pending.push(...value);
-      continue;
-    }
-    if (isRecord(value))
-      pending.push(...Object.values(value));
+var PUBLIC_CORS2 = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS
+};
+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 defineAsyncOperationContract(config) {
-  assertWireStableIdSchema(config.id, "Async operation contract");
-  const hasStartOutput = config.startOutput !== undefined;
-  const hasIdFromStart = config.idFromStart !== undefined;
-  if (hasStartOutput !== hasIdFromStart) {
-    throw new Error("Async operation contract startOutput and idFromStart must be configured together");
+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;
   }
-  const description = (capability) => config.descriptions?.[capability] ?? `${config.description}: ${capability}`;
-  const endpoint = (capability, method, path, input, output) => {
-    const scope = config.scopes?.[capability];
-    const expose = config.expose?.[capability];
-    return {
-      method,
-      path,
-      desc: description(capability),
-      input,
-      output,
-      ...scope !== undefined && { scope },
-      ...expose !== undefined && { expose }
-    };
-  };
-  const startOutput = config.startOutput ?? config.id;
-  const endpoints = {
-    start: endpoint("start", "POST", "/", config.startInput, startOutput),
-    status: endpoint("status", "POST", "/status", config.id, config.snapshot),
-    wait: endpoint("wait", "POST", "/wait", config.id, config.snapshot)
-  };
-  const capabilities = {
-    start: "start",
-    status: "status",
-    wait: "wait"
-  };
-  const schemas = {
-    startInput: config.startInput,
-    startOutput,
-    id: config.id,
-    snapshot: config.snapshot,
-    cancelResult: AsyncOperationCancelResultSchema
-  };
-  const inputFor = {
-    status: (id) => adapterResult("status", "input", config.id, id),
-    wait: (id) => adapterResult("wait", "input", config.id, id)
-  };
-  if (config.cancel) {
-    endpoints.cancel = endpoint("cancel", "POST", "/cancel", config.id, AsyncOperationCancelResultSchema);
-    capabilities.cancel = "cancel";
-    schemas.cancel = AsyncOperationCancelResultSchema;
-    inputFor.cancel = (id) => adapterResult("cancel", "input", config.id, id);
-  }
-  if (config.result) {
-    endpoints.result = endpoint("result", "POST", "/result", config.id, config.result);
-    capabilities.result = "result";
-    schemas.result = config.result;
-    inputFor.result = (id) => adapterResult("result", "input", config.id, id);
-  }
-  if (config.artifacts) {
-    endpoints.artifacts = endpoint("artifacts", "POST", "/artifacts", config.id, config.artifacts);
-    capabilities.artifacts = "artifacts";
-    schemas.artifacts = config.artifacts;
-    inputFor.artifacts = (id) => adapterResult("artifacts", "input", config.id, id);
+}
+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");
   }
-  const contract = config.scope ? defineContract({ prefix: config.prefix, scope: config.scope }, endpoints) : defineContract({ prefix: config.prefix }, endpoints);
-  const applicationStartOutput = config.startOutput;
-  const applicationIdFromStart = config.idFromStart;
-  const idFromStart = applicationStartOutput && applicationIdFromStart ? (output) => adapterResult("start", "id", config.id, applicationIdFromStart(output)) : (output) => adapterResult("start", "id", config.id, output);
-  return {
-    contract,
-    capabilities,
-    schemas,
-    adapters: { idFromStart, inputFor }
-  };
+  return url;
 }
-function bindContractAsyncOperation(config) {
-  const endpoint = (key) => {
-    const found = config.contract.endpoints[key];
-    if (!found)
-      throw new Error(`Contract async operation method "${key}" not found`);
-    return found;
-  };
-  const start = endpoint(config.capabilities.start);
-  const status = endpoint(config.capabilities.status);
-  const wait = endpoint(config.capabilities.wait);
-  if (!start.output || !status.output || !wait.output) {
-    throw new Error("Contract async operation requires outputs for start, status and wait");
+function parseAgeSeconds(headers) {
+  const raw = headers.get("age");
+  if (raw === null)
+    return 0;
+  const first = raw.split(",")[0]?.trim() ?? "";
+  return /^\d+$/.test(first) ? Number(first) : 0;
+}
+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 };
   }
-  const startOutput = start.output;
-  const statusOutput = status.output;
-  if (wait.output !== statusOutput) {
-    throw new Error('Contract async operation capability "wait" output must reuse the same schema instance as the status output');
+  if (/(?:^|,)\s*no-cache\s*(?:,|$)/i.test(cacheControl)) {
+    return { freshnessMs: 0, store: true };
   }
-  const optionalCapabilities = [
-    "cancel",
-    "result",
-    "artifacts"
-  ];
-  if (config.binding !== "adapted") {
-    assertWireStableIdSchema(startOutput, "Direct contract async operation");
-    if (status.input !== startOutput || wait.input !== startOutput) {
-      const capability = status.input !== startOutput ? "status" : "wait";
-      throw new Error(`Contract async operation capability "${capability}" input must reuse the same schema instance as the start output`);
-    }
-    const inputFor2 = {
-      status: (id) => adapterResult("status", "input", startOutput, id),
-      wait: (id) => adapterResult("wait", "input", startOutput, id)
+  const maxAge = cacheControl.match(/(?:^|,)\s*max-age=([^,\s]*)/i)?.[1];
+  if (maxAge !== undefined) {
+    if (!/^\d+$/.test(maxAge))
+      return { freshnessMs: 0, store: true };
+    const age = parseAgeSeconds(headers);
+    return {
+      freshnessMs: Math.max(0, Math.min(maxTtl, (Number(maxAge) - age) * 1000)),
+      store: true
     };
-    for (const capability of optionalCapabilities) {
-      const key = config.capabilities[capability];
-      if (!key)
-        continue;
-      if (endpoint(key).input !== startOutput) {
-        throw new Error(`Contract async operation capability "${capability}" input must reuse the same schema instance as the start output`);
-      }
-      inputFor2[capability] = (id) => adapterResult(capability, "input", startOutput, id);
-    }
+  }
+  const expires = headers.get("expires");
+  if (expires !== null) {
+    const expiresAt = Date.parse(expires);
+    if (!Number.isFinite(expiresAt))
+      return { freshnessMs: 0, store: true };
+    const dateAt = Date.parse(headers.get("date") ?? "");
+    const ageMs = parseAgeSeconds(headers) * 1000;
+    const lifetime = Number.isFinite(dateAt) ? expiresAt - dateAt : expiresAt - now;
     return {
-      contract: config.contract,
-      handlers: config.handlers,
-      capabilities: config.capabilities,
-      schemas: { id: startOutput, snapshot: statusOutput },
-      adapters: {
-        idFromStart: (output) => adapterResult("start", "id", startOutput, output),
-        inputFor: inputFor2
-      }
+      freshnessMs: Math.max(0, Math.min(maxTtl, lifetime - ageMs)),
+      store: true
     };
   }
-  const adapters = config.adapters;
-  const idSchema = config.id;
-  const adaptedInput = (capability, key, builder) => {
-    const input = endpoint(key).input;
-    if (!input) {
-      throw new Error(`Contract async operation capability "${capability}" requires an input schema`);
+  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
     }
-    return (id) => adapterResult(capability, "input", input, builder(id));
   };
-  const inputFor = {
-    status: adaptedInput("status", config.capabilities.status, adapters.inputFor.status),
-    wait: adaptedInput("wait", config.capabilities.wait, adapters.inputFor.wait)
+}
+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 positives = new Map;
+  const negatives = new Map;
+  const inflight = new Map;
+  const maxEntries = policy.maxEntries ?? 256;
+  const maxResolutions = policy.maxResolutions ?? 120;
+  const maxResolutionsPerClient = policy.maxResolutionsPerClient ?? 10;
+  const resolutionWindowMs = policy.resolutionWindowMs ?? 60000;
+  let resolutionWindowStartedAt = now();
+  let resolutionsInWindow = 0;
+  const clientWindows = new Map;
+  const CLIENT_WINDOW_CAP = 4096;
+  assertPositiveInteger("cimd.cache.maxEntries", maxEntries);
+  assertPositiveInteger("cimd.cache.maxResolutions", maxResolutions);
+  assertPositiveInteger("cimd.cache.maxResolutionsPerClient", maxResolutionsPerClient);
+  assertPositiveInteger("cimd.cache.resolutionWindowMs", resolutionWindowMs);
+  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 optionalInput = (capability, key, builder) => {
-    if (!key)
-      return;
-    if (!builder) {
-      throw new Error(`Contract async operation capability "${capability}" requires an input adapter`);
+  const readCache = (key) => positives.get(key) ?? negatives.get(key);
+  const trimOldest = (pool) => {
+    while (pool.size > maxEntries) {
+      const oldest = pool.keys().next().value;
+      if (oldest === undefined)
+        break;
+      pool.delete(oldest);
     }
-    inputFor[capability] = adaptedInput(capability, key, builder);
   };
-  optionalInput("cancel", config.capabilities.cancel, "cancel" in adapters.inputFor ? adapters.inputFor.cancel : undefined);
-  optionalInput("result", config.capabilities.result, "result" in adapters.inputFor ? adapters.inputFor.result : undefined);
-  optionalInput("artifacts", config.capabilities.artifacts, "artifacts" in adapters.inputFor ? adapters.inputFor.artifacts : undefined);
-  if (!idSchema) {
-    throw new Error("Contract adapted async operation requires an id schema");
-  }
-  return {
-    contract: config.contract,
-    handlers: config.handlers,
-    capabilities: config.capabilities,
-    schemas: { id: idSchema, snapshot: statusOutput },
-    adapters: {
-      idFromStart: (output) => adapterResult("start", "id", idSchema, adapters.idFromStart(output)),
-      inputFor
+  const touch = (key, value) => {
+    if (value.ok) {
+      negatives.delete(key);
+      positives.delete(key);
+      positives.set(key, value);
+      trimOldest(positives);
+    } else {
+      positives.delete(key);
+      negatives.delete(key);
+      negatives.set(key, value);
+      trimOldest(negatives);
     }
   };
+  const dropCache = (key) => {
+    positives.delete(key);
+    negatives.delete(key);
+  };
+  const resolveOne = async (clientId) => {
+    const url = assertCimdClientId(clientId);
+    const cached = readCache(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 currentTime = now();
+    if (currentTime - resolutionWindowStartedAt >= resolutionWindowMs) {
+      resolutionWindowStartedAt = currentTime;
+      resolutionsInWindow = 0;
+    }
+    let clientWindow = clientWindows.get(clientId);
+    if (!clientWindow || currentTime - clientWindow.startedAt >= resolutionWindowMs) {
+      clientWindow = { startedAt: currentTime, count: 0 };
+      clientWindows.delete(clientId);
+      clientWindows.set(clientId, clientWindow);
+      while (clientWindows.size > CLIENT_WINDOW_CAP) {
+        const oldest = clientWindows.keys().next().value;
+        if (oldest === undefined)
+          break;
+        clientWindows.delete(oldest);
+      }
+    }
+    if (clientWindow.count >= maxResolutionsPerClient) {
+      throw new Error("CIMD metadata resolution rate limit exceeded for this client_id");
+    }
+    if (resolutionsInWindow >= maxResolutions) {
+      throw new Error("CIMD metadata resolution rate limit exceeded");
+    }
+    clientWindow.count += 1;
+    resolutionsInWindow += 1;
+    const conditionalHeaders = {};
+    if (cached?.ok && cached.etag)
+      conditionalHeaders["if-none-match"] = cached.etag;
+    if (cached?.ok && cached.lastModified) {
+      conditionalHeaders["if-modified-since"] = cached.lastModified;
+    }
+    try {
+      const response = await options.fetcher.fetch(url, conditionalHeaders);
+      const freshness = responseFreshness(response.headers, policy, now());
+      if (response.status === 304 && cached?.ok) {
+        const refreshed = {
+          ...cached,
+          expiresAt: now() + freshness.freshnessMs
+        };
+        if (freshness.store)
+          touch(clientId, refreshed);
+        else
+          dropCache(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 && Number.isFinite(freshness.freshnessMs)) {
+        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 {
+        dropCache(clientId);
+      }
+      return client;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "CIMD metadata resolution failed";
+      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;
+  };
 }
-// src/tools/download-core.ts
-import { basename, extname } from "node:path";
-var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
-var MIME_EXT = {
-  "image/png": ".png",
-  "image/jpeg": ".jpg",
-  "image/webp": ".webp",
-  "image/gif": ".gif",
-  "video/mp4": ".mp4",
-  "video/webm": ".webm",
-  "audio/mpeg": ".mp3",
-  "audio/wav": ".wav",
-  "audio/ogg": ".ogg"
-};
-
-class DownloadOperationError extends Error {
-  code;
-  status;
-  constructor(code, message, status) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.name = "DownloadOperationError";
-  }
-}
-function extensionFor(url, mime) {
-  if (MIME_EXT[mime])
-    return MIME_EXT[mime];
-  try {
-    const ext = extname(new URL(url).pathname).toLowerCase();
-    if (ext)
-      return ext;
-  } catch {}
-  return ".bin";
-}
-function baseNameFor(url) {
+function json(body, status = 200, extraHeaders) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json", ...PUBLIC_CORS2, ...extraHeaders }
+  });
+}
+function oauthError(error, description, status = 400) {
+  return json({ error, error_description: description }, status);
+}
+function isRegistrableRedirectUri(value, applicationType) {
   try {
-    const path = new URL(url).pathname;
-    return (basename(path, extname(path)) || "download").slice(0, 60);
+    const url = new URL(value);
+    if (url.username || url.password || url.hash)
+      return false;
+    if (url.protocol === "https:")
+      return true;
+    if (url.protocol !== "http:")
+      return false;
+    if (applicationType === "web")
+      return false;
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    return host === "127.0.0.1" || host === "::1" || host === "localhost";
   } catch {
-    return "download";
-  }
-}
-async function runDownloadOperation(config) {
-  const res = await fetchGuarded(new URL(config.url), config.allowPrivateHosts ?? false, {
-    timeoutMs: config.timeoutMs,
-    signal: config.signal
-  });
-  if (!res.ok) {
-    throw new DownloadOperationError("DOWNLOAD_HTTP_ERROR", `HTTP ${res.status}`, 502);
-  }
-  const mimeType = mediaTypeEssence(res.headers.get("content-type")) || "application/octet-stream";
-  const max = config.maxBytes ?? DEFAULT_MAX_BYTES;
-  const declared = Number(res.headers.get("content-length") ?? 0);
-  if (declared > max) {
-    await res.body?.cancel();
-    throw new DownloadOperationError("DOWNLOAD_TOO_LARGE", `file exceeds the ${max}-byte cap`, 413);
+    return false;
   }
-  const path = config.path ?? `${baseNameFor(config.url)}${extensionFor(config.url, mimeType)}`;
-  return config.files.write(path, res.body ?? new Uint8Array, {
-    maxBytes: max,
-    mediaType: mimeType,
-    signal: config.signal
-  });
 }
-
-// src/tools/managed-file-error.ts
-var SAFE_MANAGED_FILE_MESSAGES = {
-  FILE_INVALID_PATH: "Invalid managed-file path",
-  FILE_OUTSIDE_ROOT: "Managed-file path escapes its boundary",
-  FILE_NOT_FOUND: "Managed file not found",
-  FILE_NOT_REGULAR: "Managed path is not a regular file",
-  FILE_INSPECTION_REJECTED: "Managed file rejected by inspection",
-  FILE_TOO_LARGE: "Managed file exceeds the configured size limit",
-  FILE_EXISTS: "Managed file already exists"
-};
-function managedFileAppError(error) {
-  if (!(error instanceof ManagedFileError))
-    return null;
-  switch (error.code) {
-    case "FILE_INVALID_PATH":
-    case "FILE_OUTSIDE_ROOT":
-    case "FILE_NOT_FOUND":
-    case "FILE_NOT_REGULAR":
-    case "FILE_INSPECTION_REJECTED":
-    case "FILE_TOO_LARGE":
-    case "FILE_EXISTS":
-      return new AppError(error.code, SAFE_MANAGED_FILE_MESSAGES[error.code], STITCH_ERROR_STATUS[error.code]);
-    case "FILE_IO_ERROR":
-      return null;
+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 normalizeFileToolError(error) {
-  return managedFileAppError(error) ?? normalizeError(error);
+function redirectWith(uri, params) {
+  const url = new URL(uri);
+  for (const [key, value] of Object.entries(params))
+    url.searchParams.set(key, value);
+  return new Response(null, { status: 302, headers: { Location: url.toString() } });
 }
-
-// src/tools/define-download-tool.ts
-function defineDownloadTool(config) {
-  return defineRuntimeTool({
-    name: config.name ?? "download",
-    description: config.description,
-    identity: managedNativeIdentity(config.identity, "POST"),
-    input: config.input,
-    output: ManagedFileRefSchema,
-    transports: config.transports,
-    annotations: config.annotations,
-    present: config.present,
-    handler: async (context) => {
-      const url = await config.resolveUrl(context.input, context);
-      if (!url) {
-        throw new AppError("DOWNLOAD_NOT_FOUND", "Nothing to download", 404);
-      }
-      try {
-        return await runDownloadOperation({
-          url,
-          files: config.files,
-          path: config.pathFromInput?.(context.input),
-          allowPrivateHosts: config.allowPrivateHosts,
-          maxBytes: config.maxBytes,
-          timeoutMs: config.timeoutMs,
-          signal: context.signal
-        });
-      } catch (error) {
-        if (error instanceof DownloadOperationError) {
-          throw new AppError(error.code, `Download failed: ${error.message}`, error.status);
-        }
-        const managedError = managedFileAppError(error);
-        if (managedError)
-          throw managedError;
-        throw error;
+async function readForm(req) {
+  const contentType = req.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const body = await req.json().catch(() => null);
+    const params = new URLSearchParams;
+    if (isRecord(body)) {
+      for (const [key, value] of Object.entries(body)) {
+        if (typeof value === "string")
+          params.set(key, value);
       }
     }
-  });
+    return params;
+  }
+  return new URLSearchParams(await req.text());
 }
-// src/tools/define-upload-tool.ts
-import { z as z2 } from "zod";
-
-// src/tools/upload-core.ts
-function runUploadOperation(files, path, upload, signal) {
-  signal?.throwIfAborted();
-  return files.read(path, { signal }).then((source) => upload(source, signal));
-}
-
-// src/tools/define-upload-tool.ts
-var UploadToolInputSchema = z2.object({
-  path: ManagedFilePathSchema.describe("Path relative to the configured file boundary")
-});
-function defineUploadTool(config) {
-  return defineRuntimeTool({
-    name: config.name ?? "upload",
-    description: config.description,
-    identity: managedNativeIdentity(config.identity, "POST"),
-    input: UploadToolInputSchema,
-    output: config.output,
-    transports: config.transports,
-    annotations: config.annotations,
-    present: config.present,
-    handler: async (context) => {
+function mountOAuthProvider(config) {
+  const base = config.basePath ?? "/oauth";
+  const ttl = config.accessTokenTtlSec ?? 3600;
+  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 runUploadOperation(config.files, context.input.path, (source) => config.upload(source, context), context.signal);
-      } catch (error) {
-        const managedError = managedFileAppError(error);
-        if (managedError)
-          throw managedError;
-        throw error;
+        return await resolveCimd(clientId);
+      } catch {
+        return null;
       }
     }
-  });
-}
-// src/tools/view-file.ts
-import { extname as extname2 } from "node:path";
-var MAX_INLINE_BYTES = 20 * 1024 * 1024;
-var EXT_MIME = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg",
-  ".m4a": "audio/mp4",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime"
-};
-async function fetchSource(pathOrUrl, options, maxBytes) {
-  const extMime = EXT_MIME[extname2(pathOrUrl).toLowerCase()];
-  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
-    const url = new URL(pathOrUrl);
-    const res = await fetchGuarded(url, options.allowPrivateHosts ?? false, {
-      timeoutMs: options.timeoutMs,
-      signal: options.signal
-    });
-    if (!res.ok)
-      throw new AppError("VIEW_HTTP_ERROR", `HTTP ${res.status}`, 502);
-    const headerMime = mediaTypeEssence(res.headers.get("content-type"));
-    const mimeType = headerMime || extMime || "application/octet-stream";
-    if (mimeType.startsWith("video/")) {
-      await res.body?.cancel();
-      return { video: true, mimeType, bytesRead: 0 };
-    }
-    const declared = Number(res.headers.get("content-length") ?? 0);
-    if (declared > maxBytes) {
-      await res.body?.cancel();
-      return { tooLarge: true, mimeType, bytesRead: 0 };
+    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",
+    path: AS_METADATA_PATH,
+    handler: (req) => {
+      if (req.method === "OPTIONS")
+        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+      return json({
+        issuer: config.issuer,
+        authorization_endpoint: `${config.issuer}${authorizePath}`,
+        token_endpoint: `${config.issuer}${tokenPath}`,
+        ...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 }
+      });
     }
-    const buffer = await readCapped(res, maxBytes);
-    return buffer ? { buffer, mimeType, bytesRead: buffer.length } : { tooLarge: true, mimeType, bytesRead: maxBytes };
-  }
-  if (!options.files) {
-    throw new AppError("FILE_INVALID_PATH", "local file paths are disabled — set files to allow them", 400);
-  }
-  options.signal?.throwIfAborted();
-  if (!extMime) {
-    throw new AppError("FILE_INSPECTION_REJECTED", "refusing to read a non-media file", 422);
-  }
-  try {
-    const source = await options.files.read(pathOrUrl, {
-      maxBytes,
-      signal: options.signal
-    });
-    const buffer = Buffer.from(source.bytes);
-    return {
-      buffer,
-      mimeType: source.ref.mediaType ?? extMime,
-      bytesRead: buffer.length
-    };
-  } catch (error) {
-    if (error instanceof ManagedFileError && error.code === "FILE_TOO_LARGE") {
-      return { tooLarge: true, mimeType: extMime, bytesRead: maxBytes };
+  };
+  const registerRoute = {
+    method: "ALL",
+    path: registerPath,
+    handler: async (req) => {
+      if (req.method === "OPTIONS")
+        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+      if (req.method !== "POST")
+        return oauthError("invalid_request", "POST required", 405);
+      const meta = await req.json().catch(() => null);
+      if (!isRecord(meta)) {
+        return oauthError("invalid_client_metadata", "Body must be a JSON object");
+      }
+      const rawAppType = meta.application_type;
+      if (rawAppType !== undefined && rawAppType !== "native" && rawAppType !== "web") {
+        return oauthError("invalid_client_metadata", "application_type must be 'native' or 'web'");
+      }
+      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)");
+      }
+      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,
+        ...applicationType && { applicationType }
+      });
+      return json({
+        client_id: client.clientId,
+        redirect_uris: client.redirectUris,
+        token_endpoint_auth_method: "none",
+        grant_types: config.refreshTokens ? ["authorization_code", "refresh_token"] : ["authorization_code"],
+        response_types: ["code"],
+        ...client.clientName && { client_name: client.clientName },
+        ...client.applicationType && { application_type: client.applicationType }
+      }, 201);
     }
-    throw error;
-  }
-}
-async function resolveMediaWithinBudget(pathOrUrl, options, maxBytes) {
-  if (maxBytes <= 0) {
-    return {
-      content: [
-        { type: "text", text: `[media] total inline budget exhausted — ${pathOrUrl}` }
-      ],
-      bytes: 0
-    };
-  }
-  const extMime = EXT_MIME[extname2(pathOrUrl).toLowerCase()];
-  if (extMime?.startsWith("video/")) {
-    return {
-      content: [{ type: "text", text: `[video] ${extMime} — ${pathOrUrl}` }],
-      bytes: 0
-    };
-  }
-  const result = await fetchSource(pathOrUrl, options, maxBytes);
-  if ("video" in result) {
-    return {
-      content: [{ type: "text", text: `[video] ${result.mimeType} — ${pathOrUrl}` }],
-      bytes: result.bytesRead
-    };
-  }
-  if ("tooLarge" in result) {
-    return {
-      content: [
-        { type: "text", text: `[${result.mimeType}] too large to inline — ${pathOrUrl}` }
-      ],
-      bytes: result.bytesRead
-    };
-  }
-  const { buffer, mimeType } = result;
-  const sizeKb = (buffer.length / 1024).toFixed(0);
-  if (mimeType.startsWith("image/")) {
-    return {
-      content: [
-        {
-          type: "image",
-          data: buffer.toString("base64"),
-          mimeType,
-          annotations: { audience: ["user", "assistant"], priority: 0.9 }
+  };
+  const authorizeRoute = {
+    method: "ALL",
+    path: authorizePath,
+    handler: async (req) => {
+      if (req.method === "OPTIONS")
+        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+      const url = new URL(req.url);
+      const p = url.searchParams;
+      const clientId = p.get("client_id");
+      const redirectUri = p.get("redirect_uri");
+      const responseType = p.get("response_type");
+      const codeChallenge = p.get("code_challenge");
+      const codeChallengeMethod = p.get("code_challenge_method") ?? "S256";
+      const resource = p.get("resource");
+      const scope = p.get("scope") ?? undefined;
+      const state = p.get("state") ?? undefined;
+      if (!clientId || !redirectUri) {
+        return oauthError("invalid_request", "client_id and redirect_uri are required");
+      }
+      const client = await resolveClient(clientId);
+      if (!client)
+        return oauthError("invalid_client", "Unknown client_id", 401);
+      if (!client.redirectUris.includes(redirectUri)) {
+        return oauthError("invalid_request", "redirect_uri does not match a registered URI");
+      }
+      if (responseType !== "code") {
+        return redirectToClient(redirectUri, {
+          error: "unsupported_response_type",
+          ...state && { state }
+        });
+      }
+      if (!codeChallenge || codeChallengeMethod !== "S256") {
+        return redirectToClient(redirectUri, {
+          error: "invalid_request",
+          error_description: "PKCE S256 code_challenge is required",
+          ...state && { state }
+        });
+      }
+      if (!resource) {
+        return redirectToClient(redirectUri, {
+          error: "invalid_target",
+          error_description: "resource parameter is required",
+          ...state && { state }
+        });
+      }
+      if (resource !== config.resource) {
+        return redirectToClient(redirectUri, {
+          error: "invalid_target",
+          error_description: "resource is not served by this authorization server",
+          ...state && { 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)
         },
-        { type: "text", text: `[image] ${mimeType}, ${sizeKb}KB` }
-      ],
-      bytes: buffer.length
-    };
-  }
-  if (mimeType.startsWith("audio/")) {
-    return {
-      content: [
-        {
-          type: "audio",
-          data: buffer.toString("base64"),
-          mimeType,
-          annotations: { audience: ["user", "assistant"], priority: 0.9 }
+        ...client.applicationType !== undefined && {
+          applicationType: client.applicationType
         },
-        { type: "text", text: `[audio] ${mimeType}, ${sizeKb}KB` }
-      ],
-      bytes: buffer.length
-    };
-  }
-  return {
-    content: [{ type: "text", text: `[${mimeType}] ${sizeKb}KB — ${pathOrUrl}` }],
-    bytes: buffer.length
-  };
-}
-async function resolveMedia(pathOrUrl, options = {}) {
-  return (await resolveMediaWithinBudget(pathOrUrl, options, MAX_INLINE_BYTES)).content;
-}
-async function runViewFileOperation(paths, options = {}, signal) {
-  const list = Array.isArray(paths) ? paths : [paths];
-  const content = [];
-  const errors = [];
-  let remainingBytes = MAX_INLINE_BYTES;
-  for (const pathOrUrl of list) {
-    signal?.throwIfAborted();
-    try {
-      const resolved = await resolveMediaWithinBudget(pathOrUrl, { ...options, signal }, remainingBytes);
-      remainingBytes -= resolved.bytes;
-      content.push(...resolved.content);
-    } catch (error) {
-      if (signal?.aborted)
-        throw signal.reason ?? error;
-      const message = normalizeFileToolError(error).message;
-      errors.push({ path: pathOrUrl, message });
-      content.push({ type: "text", text: `[${pathOrUrl}] Error: ${message}` });
+        ...absoluteClientUrl(clientId)?.protocol === "https:" && {
+          clientOrigin: new URL(clientId).origin
+        }
+      };
+      const result = await config.authorizeUser(req, authRequest);
+      if (result instanceof Response)
+        return result;
+      if (!Array.isArray(result.approvedScopes) || !result.approvedScopes.every((scope2) => typeof scope2 === "string")) {
+        throw new Error("authorizeUser must return approvedScopes as an array of strings");
+      }
+      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: approvedScope,
+        userId: result.userId,
+        expiresAt: Date.now() + AUTH_CODE_TTL_MS
+      });
+      return redirectToClient(redirectUri, { code, ...state && { state } });
     }
-  }
-  return ViewFileOutputSchema.parse({ content, errors });
-}
-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: ViewFileInputSchema.shape,
-    annotations: { title: "View Media", readOnlyHint: true, idempotentHint: true }
-  }, async (args) => {
-    const result = await runViewFileOperation(args.paths, options);
-    return { content: result.content };
-  });
-}
-
-// src/tools/define-view-file-tool.ts
-function defineViewFileTool(config) {
-  const defaults = {
-    mcp: (output) => ({ content: output.content }),
-    agent: (output) => ({
-      type: "content",
-      value: output.content.map((part) => {
-        if (part.type === "text")
-          return part;
-        return {
-          type: "file",
-          data: { type: "data", data: part.data },
-          mediaType: part.mimeType
-        };
-      })
-    })
   };
-  return defineRuntimeTool({
-    name: config.name ?? "view_file",
-    description: config.description,
-    identity: managedNativeIdentity(config.identity, "GET"),
-    input: ViewFileInputSchema,
-    output: ViewFileOutputSchema,
-    transports: config.transports,
-    annotations: config.annotations ?? {
-      title: "View Media",
-      readOnlyHint: true,
-      idempotentHint: true
-    },
-    present: { ...defaults, ...config.present },
-    handler: (context) => runViewFileOperation(context.input.paths, {
-      files: config.files,
-      allowPrivateHosts: config.allowPrivateHosts,
-      timeoutMs: config.timeoutMs
-    }, context.signal)
+  const issueAccessToken = (userId, audience, clientId, scope) => signJwt({ scope, client_id: clientId }, config.signingSecret, {
+    issuer: config.issuer,
+    audience,
+    subject: userId,
+    expiresInSec: ttl
   });
+  const tokenRoute = {
+    method: "ALL",
+    path: tokenPath,
+    handler: async (req) => {
+      if (req.method === "OPTIONS")
+        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+      if (req.method !== "POST")
+        return oauthError("invalid_request", "POST required", 405);
+      const form = await readForm(req);
+      const grantType = form.get("grant_type");
+      if (grantType === "authorization_code") {
+        const code = form.get("code");
+        const verifier = form.get("code_verifier");
+        const redirectUri = form.get("redirect_uri");
+        const clientId = form.get("client_id");
+        if (!code || !verifier || !redirectUri || !clientId) {
+          return oauthError("invalid_request", "code, code_verifier, redirect_uri, client_id required");
+        }
+        const data = await config.codes.take(code);
+        if (!data)
+          return oauthError("invalid_grant", "Unknown or used authorization code");
+        if (data.expiresAt < Date.now())
+          return oauthError("invalid_grant", "Authorization code expired");
+        if (data.clientId !== clientId)
+          return oauthError("invalid_grant", "client_id mismatch");
+        if (data.redirectUri !== redirectUri)
+          return oauthError("invalid_grant", "redirect_uri mismatch");
+        if (!await verifyPkce(verifier, data.codeChallenge)) {
+          return oauthError("invalid_grant", "PKCE verification failed");
+        }
+        const accessToken = await issueAccessToken(data.userId, data.resource, data.clientId, data.scope);
+        let refreshToken;
+        if (config.refreshTokens) {
+          refreshToken = randomUUID();
+          await config.refreshTokens.save(refreshToken, {
+            clientId: data.clientId,
+            resource: data.resource,
+            scope: data.scope,
+            userId: data.userId
+          });
+        }
+        return json({
+          access_token: accessToken,
+          token_type: "Bearer",
+          expires_in: ttl,
+          ...data.scope && { scope: data.scope },
+          ...refreshToken && { refresh_token: refreshToken }
+        });
+      }
+      if (grantType === "refresh_token") {
+        if (!config.refreshTokens) {
+          return oauthError("unsupported_grant_type", "refresh_token grant is not enabled");
+        }
+        const token = form.get("refresh_token");
+        const clientId = form.get("client_id");
+        if (!token || !clientId)
+          return oauthError("invalid_request", "refresh_token and client_id required");
+        const data = await config.refreshTokens.take(token);
+        if (!data)
+          return oauthError("invalid_grant", "Unknown or used refresh token");
+        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 = randomUUID();
+        await config.refreshTokens.save(newRefresh, data);
+        return json({
+          access_token: accessToken,
+          token_type: "Bearer",
+          expires_in: ttl,
+          ...data.scope && { scope: data.scope },
+          refresh_token: newRefresh
+        });
+      }
+      return oauthError("unsupported_grant_type", `Unsupported grant_type: ${grantType ?? "none"}`);
+    }
+  };
+  return dcrEnabled ? [metadataRoute, registerRoute, authorizeRoute, tokenRoute] : [metadataRoute, authorizeRoute, tokenRoute];
 }
 // src/tools/lifecycle.ts
 function composeToolLifecycle(...hooks) {
@@ -901,7 +831,6 @@ function composeToolLifecycle(...hooks) {
   };
 }
 // src/tools/list-names.ts
-var TOOL_TRANSPORTS = ["MCP", "AGENT", "CLI"];
 function listToolNames(surface) {
   const entries = new Map;
   for (const transport of TOOL_TRANSPORTS) {
@@ -931,14 +860,7 @@ function listToolNames(surface) {
 function listContractToolNames(contracts) {
   return listToolNames({ services: contracts.map(contractOnlyService) });
 }
-// src/tools/mcp.ts
-import {
-  createRequestStateCodec,
-  McpServer
-} from "@modelcontextprotocol/server";
-import { z as z5 } from "zod";
-
-// src/tools/mcp-app.ts
+// src/tools/mcp/app.ts
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 var RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
@@ -958,8 +880,7 @@ function inlineMcpAppBundle(html) {
   }).join(",")}};`);
   return html.replace(EXT_APPS_BUNDLE_PLACEHOLDER, () => bundle);
 }
-
-// src/tools/mcp-catalog.ts
+// src/tools/mcp/catalog.ts
 import { createHash } from "node:crypto";
 var MCP_CATALOG_META_KEY = "stitchkit/catalog";
 var stampCache = new WeakMap;
@@ -980,7 +901,7 @@ function mcpCatalogStamp(surface) {
   const descriptors = [
     ...surface.contractTools,
     ...surface.runtimeTools.map((entry) => entry.descriptor)
-  ].sort((left, right) => compareCodepoints(left.mountable.name, right.mountable.name));
+  ].sort((left, right) => compareCodeUnits(left.mountable.name, right.mountable.name));
   const bytes = serializeCanonicalJson(descriptors.map(toolFingerprint));
   const stamp = {
     digest: createHash("sha256").update(bytes).digest("hex").slice(0, 16),
@@ -1015,8 +936,22 @@ function stampToolResult(result, stamp) {
     return result;
   return { ...result, _meta: { ...result._meta, ...mcpCatalogMeta(stamp) } };
 }
+// src/tools/mcp/handler.ts
+import {
+  createMcpHandler as createSdkMcpHandler,
+  hostHeaderValidationResponse,
+  localhostAllowedHostnames,
+  localhostAllowedOrigins,
+  originValidationResponse
+} from "@modelcontextprotocol/server";
+
+// src/tools/mcp/mount.ts
+import {
+  createRequestStateCodec,
+  McpServer
+} from "@modelcontextprotocol/server";
 
-// src/tools/mcp-prepare.ts
+// src/tools/mcp/prepare.ts
 function textBlock(text) {
   return [{ type: "text", text }];
 }
@@ -1047,21 +982,25 @@ function prepareMcpSurface(services, config = {}) {
   return prepareMcpTools(tools, config);
 }
 function prepareMcpTools(tools, config = {}) {
-  const prepared = prepareProjectedMcpTools(tools.map((mountable) => ({
-    tool: mountable,
-    name: mountable.name,
-    ...mountable.method.paramsSchema !== undefined && {
-      paramsSchema: mountable.method.paramsSchema
-    },
-    ...mountable.method.inputSchema !== undefined && {
-      inputSchema: mountable.method.inputSchema
-    },
-    ...mountable.method.outputSchema !== undefined && {
-      outputSchema: mountable.method.outputSchema
-    },
-    shouldExtend: mountable.shouldExtend,
-    ...mountable.method.mcp !== undefined && { mcp: mountable.method.mcp }
-  })), config).map((entry) => {
+  const prepared = prepareProjectedMcpTools(tools.map((mountable) => {
+    const outputSchema = toolSurfaceOutputSchema(mountable.method);
+    return {
+      tool: mountable,
+      name: mountable.name,
+      ...mountable.method.paramsSchema !== undefined && {
+        paramsSchema: mountable.method.paramsSchema
+      },
+      ...mountable.method.inputSchema !== undefined && {
+        inputSchema: mountable.method.inputSchema
+      },
+      ...mountable.method.toolView?.defaults !== undefined && {
+        inputDefaults: mountable.method.toolView.defaults
+      },
+      ...outputSchema !== undefined && { outputSchema },
+      shouldExtend: mountable.shouldExtend,
+      ...mountable.method.mcp !== undefined && { mcp: mountable.method.mcp }
+    };
+  }), config).map((entry) => {
     Object.freeze(entry.tool);
     return Object.freeze({
       mountable: entry.tool,
@@ -1105,7 +1044,13 @@ function prepareMcpServerSurface(surface, config = {}) {
   return Object.freeze({ contractTools, runtimeTools: Object.freeze(runtimeTools) });
 }
 
-// src/tools/mcp-round.ts
+// src/tools/mcp/register.ts
+import {
+  isCallToolResult
+} from "@modelcontextprotocol/server";
+import { z as z3 } from "zod";
+
+// src/tools/mcp/round.ts
 import {
   acceptedContent,
   CLIENT_INFO_META_KEY,
@@ -1113,9 +1058,9 @@ import {
   inputResponse,
   PROTOCOL_VERSION_META_KEY
 } from "@modelcontextprotocol/server";
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
-// src/tools/mcp-progress.ts
+// src/tools/mcp/progress.ts
 function mcpProgressToken(context) {
   const token = context.mcpReq._meta?.progressToken;
   return typeof token === "string" || typeof token === "number" ? token : undefined;
@@ -1146,7 +1091,7 @@ function createMcpProgressReporter(context) {
   };
 }
 
-// src/tools/mcp-round.ts
+// src/tools/mcp/round.ts
 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;
@@ -1213,7 +1158,7 @@ function roundPlanDigest(requests) {
     plan: requests.map((request) => ({
       key: request.key,
       message: request.message,
-      schema: z3.toJSONSchema(request.schema, { io: "input", unrepresentable: "any" })
+      schema: z2.toJSONSchema(request.schema, { io: "input", unrepresentable: "any" })
     }))
   });
 }
@@ -1221,7 +1166,10 @@ async function resolveRequests(options, policy) {
   const declared = staticInputRounds(policy);
   if (declared)
     return { requests: declared, guarded: false };
-  const parsed = parseToolCallArguments(options.tool.method, options.rawArgs, options.coerceJsonArgs ?? true);
+  const parsed = parseToolCallArguments(options.tool.method, options.rawArgs, {
+    coerceJson: options.coerceJsonArgs ?? true,
+    toolSurface: true
+  });
   if (!parsed.ok) {
     return { requests: [], guarded: false };
   }
@@ -1391,7 +1339,7 @@ async function resolveMcpRound(options) {
   };
 }
 
-// src/tools/mcp-trace.ts
+// src/tools/mcp/trace.ts
 import {
   BAGGAGE_META_KEY,
   TRACEPARENT_META_KEY,
@@ -1423,73 +1371,102 @@ function runInMcpRequestContext(context, toolName, body) {
   return runWithRequestContext(request, body);
 }
 
-// src/tools/native-mcp.ts
-import {
-  isCallToolResult
-} from "@modelcontextprotocol/server";
-import { z as z4 } from "zod";
-function mountPreparedRuntimeMcp(server, tools, config) {
-  for (const { definition, descriptor } of tools) {
-    const { mountable } = descriptor;
-    const toolConfig = {
-      description: definition.description,
-      inputSchema: z4.looseObject({}).meta(presentationMetadata(descriptor.inputSchema))
+// src/tools/mcp/register.ts
+function registerMcpTool(server, presentation, descriptor, config) {
+  const { mountable } = descriptor;
+  const toolConfig = {
+    description: presentation.description,
+    inputSchema: z3.looseObject({}).meta(presentationMetadata(descriptor.inputSchema))
+  };
+  if (descriptor.outputSchema)
+    toolConfig.outputSchema = descriptor.outputSchema;
+  if (presentation.annotations)
+    toolConfig.annotations = presentation.annotations;
+  if (presentation.ui) {
+    toolConfig._meta = {
+      ui: presentation.ui,
+      "ui/resourceUri": presentation.ui.resourceUri
     };
-    if (descriptor.outputSchema)
-      toolConfig.outputSchema = descriptor.outputSchema;
-    if (definition.annotations)
-      toolConfig.annotations = definition.annotations;
-    if (definition.ui) {
-      toolConfig._meta = {
-        ui: definition.ui,
-        "ui/resourceUri": definition.ui.resourceUri
-      };
-    }
-    server.registerTool(definition.name, stampToolRegistration(toolConfig, config.catalog), async (rawArgs, mcpContext) => stampToolResult(await runInMcpRequestContext(mcpContext, definition.name, async () => {
-      const args = isRecord(rawArgs) ? rawArgs : {};
-      const runTool = (tool, toolArgs, roundContext) => executeToolMethod(tool.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 { name } = presentation;
+  const format = config.formatResult;
+  server.registerTool(name, stampToolRegistration(toolConfig, config.catalog), async (rawArgs, mcpContext) => stampToolResult(await runInMcpRequestContext(mcpContext, name, async () => {
+    const args = isRecord(rawArgs) ? rawArgs : {};
+    try {
       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)
+        runTool: config.runTool,
+        formatFailure: (result2) => format(result2, "none", 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 { present } = presentation;
+      if (!present) {
+        const result2 = await config.runTool(mountable, args, round.context);
+        return format(result2, descriptor.outputMode, name);
       }
-      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);
+      const result = await config.runTool(mountable, args, round.context, {
+        finalizeOutput: async (data) => {
+          const presented = await present(data);
+          if (!isRecord(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 = format({ ok: true, data }, descriptor.outputMode, 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 response;
       });
-      if (!presentedResult.ok) {
-        return config.formatResult(presentedResult, "none", definition.name);
-      }
-      if (!isCallToolResult(presentedResult.data)) {
+      if (!result.ok)
+        return format(result, "none", name);
+      if (!isCallToolResult(result.data)) {
         throw new Error("[stitchkit] Runtime MCP presenter invariant failed");
       }
-      return presentedResult.data;
-    }), config.catalog));
+      return result.data;
+    } catch (err) {
+      return format(toolResultFromError(err), "none", name);
+    }
+  }), config.catalog));
+}
+
+// src/tools/mcp/runtime-tools.ts
+function mountPreparedRuntimeMcp(server, tools, config) {
+  const runTool = createToolRunner({
+    source: "mcp",
+    toolSurface: true,
+    context: config.context,
+    hooks: config.hooks,
+    lifecycle: config.lifecycle,
+    coerceJsonArgs: config.coerceJsonArgs,
+    onOutputStrip: config.onOutputStrip
+  });
+  for (const { definition, descriptor } of tools) {
+    const present = definition.present?.mcp;
+    registerMcpTool(server, {
+      name: definition.name,
+      description: definition.description,
+      annotations: definition.annotations,
+      ui: definition.ui,
+      ...present && { present: (data) => present(data) }
+    }, descriptor, {
+      runTool,
+      formatResult: config.formatResult,
+      catalog: config.catalog,
+      multiRoundRuntime: config.multiRoundRuntime
+    });
   }
 }
 
-// src/tools/mcp.ts
+// src/tools/mcp/mount.ts
 function validateMcpSchemas(config) {
   prepareMcpSurface(config.services, {
     extend: config.extend,
@@ -1513,51 +1490,27 @@ function mountMcp(mcpServer, services, config = {}) {
 function mountPreparedMcp(mcpServer, prepared, config = {}) {
   const runTool = createToolRunner({
     source: "mcp",
+    toolSurface: true,
     extend: config.extend,
     context: config.context,
     hooks: config.hooks,
     lifecycle: config.lifecycle,
-    errorHint: config.errorHint,
     coerceJsonArgs: config.coerceJsonArgs,
     onOutputStrip: config.onOutputStrip
   });
   for (const descriptor of prepared) {
-    const { mountable } = descriptor;
-    const toolConfig = {
-      description: mountable.method.desc,
-      inputSchema: z5.looseObject({}).meta(presentationMetadata(descriptor.inputSchema))
-    };
-    if (descriptor.outputSchema)
-      toolConfig.outputSchema = descriptor.outputSchema;
-    if (mountable.method.annotations) {
-      toolConfig.annotations = mountable.method.annotations;
-    }
-    if (mountable.method.ui) {
-      toolConfig._meta = {
-        ui: mountable.method.ui,
-        "ui/resourceUri": mountable.method.ui.resourceUri
-      };
-    }
-    mcpServer.registerTool(mountable.name, stampToolRegistration(toolConfig, config.catalog), async (rawArgs, mcpContext) => stampToolResult(await runInMcpRequestContext(mcpContext, mountable.name, async () => {
-      const args = isRecord(rawArgs) ? rawArgs : {};
-      try {
-        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);
-      }
-    }), config.catalog));
+    const { method, name } = descriptor.mountable;
+    registerMcpTool(mcpServer, {
+      name,
+      description: method.desc,
+      annotations: method.annotations,
+      ui: method.ui
+    }, descriptor, {
+      runTool,
+      formatResult: (result, mode, toolName) => formatMcpResult(result, mode, toolName, config.errorHint),
+      catalog: config.catalog,
+      multiRoundRuntime: config.multiRoundRuntime
+    });
   }
 }
 function buildMcpServer(config, auth) {
@@ -1675,56 +1628,8 @@ function mountMcpResource(server, resource) {
     ]
   }));
 }
-// src/tools/mcp-handler.ts
-import {
-  createMcpHandler as createSdkMcpHandler,
-  hostHeaderValidationResponse,
-  localhostAllowedHostnames,
-  localhostAllowedOrigins,
-  originValidationResponse
-} from "@modelcontextprotocol/server";
-
-// src/tools/oauth-metadata.ts
-var PROTECTED_RESOURCE_PATH = "/.well-known/oauth-protected-resource";
-function metadataPath(resource) {
-  const { pathname } = new URL(resource);
-  return pathname === "/" ? PROTECTED_RESOURCE_PATH : `${PROTECTED_RESOURCE_PATH}${pathname}`;
-}
-function protectedResourceMetadataUrl(resource) {
-  return `${new URL(resource).origin}${metadataPath(resource)}`;
-}
-function wwwAuthenticateHeader(resource) {
-  return `Bearer resource_metadata="${protectedResourceMetadataUrl(resource)}"`;
-}
-var PUBLIC_CORS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, OPTIONS",
-  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS
-};
-function oauthProtectedResourceRoute(config) {
-  const body = JSON.stringify({
-    resource: config.resource,
-    authorization_servers: config.authorizationServers,
-    ...config.scopesSupported && { scopes_supported: config.scopesSupported },
-    bearer_methods_supported: ["header"]
-  });
-  return {
-    method: "ALL",
-    path: metadataPath(config.resource),
-    handler: (req) => {
-      if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS });
-      if (req.method !== "GET")
-        return new Response("Method Not Allowed", { status: 405 });
-      return new Response(body, {
-        status: 200,
-        headers: { "Content-Type": "application/json", ...PUBLIC_CORS }
-      });
-    }
-  };
-}
 
-// src/tools/mcp-handler.ts
+// src/tools/mcp/handler.ts
 function jsonRpcError(code, message, status, headers) {
   return Response.json({ jsonrpc: "2.0", error: { code, message }, id: null }, { status, headers });
 }
@@ -1858,7 +1763,7 @@ function createMcpHttpRoute(config) {
     handler: (request) => config.handler.fetch(request)
   };
 }
-// src/tools/mcp-stdio.ts
+// src/tools/mcp/stdio.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 async function createStdioMcpServer(config) {
   const auth = await config.auth;
@@ -1867,7 +1772,7 @@ async function createStdioMcpServer(config) {
     maxSubscriptions: 0
   });
 }
-// src/tools/mcp-stdio-signals.ts
+// src/tools/mcp/stdio-signals.ts
 var bound = new WeakSet;
 function bindStdioProcessSignals(handle, options = {}) {
   if (bound.has(handle)) {
@@ -1902,900 +1807,1033 @@ function bindStdioProcessSignals(handle, options = {}) {
     if (!started)
       bound.delete(handle);
   };
-  const close = () => {
-    const hadStarted = started;
-    removeListeners();
-    if (!hadStarted)
-      resolveChain();
+  const close = () => {
+    const hadStarted = started;
+    removeListeners();
+    if (!hadStarted)
+      resolveChain();
+  };
+  const run = async (signal) => {
+    try {
+      await options.onClose?.(signal);
+    } catch (error) {
+      reportSignalError("prepare", error, options.onError);
+    }
+    try {
+      await handle.close();
+    } catch (error) {
+      rejectChain(error);
+      reportSignalError("close", error, options.onError);
+      removeListeners();
+      return;
+    }
+    resolveChain();
+    try {
+      await options.onComplete?.();
+    } catch (error) {
+      reportSignalError("complete", error, options.onError);
+    } finally {
+      removeListeners();
+    }
+  };
+  const onSignal = (signal) => {
+    if (!started) {
+      started = true;
+      sameTurnAsStart = true;
+      queueMicrotask(() => {
+        sameTurnAsStart = false;
+      });
+      run(signal).catch((error) => reportSignalError("close", error, options.onError));
+      return;
+    }
+    if (sameTurnAsStart)
+      return;
+    removeListeners();
+    guardSignalCallback(() => options.onRepeatedSignal?.(signal), "close", options.onError);
+    let restored = false;
+    try {
+      restored = source.raiseDefault(signal);
+    } catch (error) {
+      reportSignalError("close", error, options.onError);
+    }
+    if (!restored) {
+      guardSignalCallback(() => options.onEscalationBlocked?.(signal), "close", options.onError);
+    }
+  };
+  for (const signal of signals) {
+    const handler = () => onSignal(signal);
+    handlers.push([signal, handler]);
+    source.on(signal, handler);
+  }
+  return { promise, close };
+}
+// src/tools/operations/async-operation-id.ts
+import { z as z4 } from "zod";
+function adapterResult(capability, target, schema, value) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    throw new Error(`Async operation adapter for capability "${capability}" returned invalid ${target}`, { cause: parsed.error });
+  }
+  return parsed.data;
+}
+var NON_WIRE_STABLE_ZOD_TYPES = new Set([
+  "catch",
+  "default",
+  "lazy",
+  "pipe",
+  "prefault",
+  "readonly",
+  "success",
+  "transform"
+]);
+function hasOverwriteCheck(value) {
+  return isRecord(value) && isRecord(value._zod) && isRecord(value._zod.def) && value._zod.def.check === "overwrite";
+}
+function assertWireStableIdSchema(schema, boundary) {
+  const visited = new Set;
+  const pending = [schema];
+  while (pending.length > 0) {
+    const value = pending.pop();
+    if (typeof value !== "object" || value === null || visited.has(value))
+      continue;
+    visited.add(value);
+    if (value instanceof z4.ZodType) {
+      const definition = value._zod.def;
+      if (NON_WIRE_STABLE_ZOD_TYPES.has(definition.type) || "coerce" in definition && definition.coerce === true || "checks" in definition && Array.isArray(definition.checks) && definition.checks.some(hasOverwriteCheck)) {
+        throw new Error(`${boundary} must use a wire-stable ID schema without transforms, coercion, defaults or overwrites; use binding: "adapted" with explicit ID adapters`);
+      }
+      pending.push(...Object.values(definition));
+      continue;
+    }
+    if (Array.isArray(value)) {
+      pending.push(...value);
+      continue;
+    }
+    if (isRecord(value))
+      pending.push(...Object.values(value));
+  }
+}
+
+// src/tools/operations/async-operation-binding.ts
+function bindContractAsyncOperation(config) {
+  const endpoint = (key) => {
+    const found = config.contract.endpoints[key];
+    if (!found)
+      throw new Error(`Contract async operation method "${key}" not found`);
+    return found;
+  };
+  const start = endpoint(config.capabilities.start);
+  const status = endpoint(config.capabilities.status);
+  const wait = endpoint(config.capabilities.wait);
+  if (!start.output || !status.output || !wait.output) {
+    throw new Error("Contract async operation requires outputs for start, status and wait");
+  }
+  const startOutput = start.output;
+  const statusOutput = status.output;
+  if (wait.output !== statusOutput) {
+    throw new Error('Contract async operation capability "wait" output must reuse the same schema instance as the status output');
+  }
+  const resolved = {
+    endpoint,
+    status,
+    wait,
+    startOutput,
+    statusOutput
+  };
+  if (config.binding !== "adapted")
+    return bindDirect(config, resolved);
+  return bindAdapted(config, resolved);
+}
+var OPTIONAL_CAPABILITIES = [
+  "cancel",
+  "result",
+  "artifacts"
+];
+function bindDirect(config, { endpoint, status, wait, startOutput, statusOutput }) {
+  assertWireStableIdSchema(startOutput, "Direct contract async operation");
+  if (status.input !== startOutput || wait.input !== startOutput) {
+    const capability = status.input !== startOutput ? "status" : "wait";
+    throw new Error(`Contract async operation capability "${capability}" input must reuse the same schema instance as the start output`);
+  }
+  const inputFor = {
+    status: (id) => adapterResult("status", "input", startOutput, id),
+    wait: (id) => adapterResult("wait", "input", startOutput, id)
   };
-  const run = async (signal) => {
-    try {
-      await options.onClose?.(signal);
-    } catch (error) {
-      reportSignalError("prepare", error, options.onError);
-    }
-    try {
-      await handle.close();
-    } catch (error) {
-      rejectChain(error);
-      reportSignalError("close", error, options.onError);
-      removeListeners();
-      return;
+  for (const capability of OPTIONAL_CAPABILITIES) {
+    const key = config.capabilities[capability];
+    if (!key)
+      continue;
+    if (endpoint(key).input !== startOutput) {
+      throw new Error(`Contract async operation capability "${capability}" input must reuse the same schema instance as the start output`);
     }
-    resolveChain();
-    try {
-      await options.onComplete?.();
-    } catch (error) {
-      reportSignalError("complete", error, options.onError);
-    } finally {
-      removeListeners();
+    inputFor[capability] = (id) => adapterResult(capability, "input", startOutput, id);
+  }
+  return {
+    contract: config.contract,
+    handlers: config.handlers,
+    capabilities: config.capabilities,
+    schemas: { id: startOutput, snapshot: statusOutput },
+    adapters: {
+      idFromStart: (output) => adapterResult("start", "id", startOutput, output),
+      inputFor
     }
   };
-  const onSignal = (signal) => {
-    if (!started) {
-      started = true;
-      sameTurnAsStart = true;
-      queueMicrotask(() => {
-        sameTurnAsStart = false;
-      });
-      run(signal).catch((error) => reportSignalError("close", error, options.onError));
-      return;
+}
+function bindAdapted(config, { endpoint, statusOutput }) {
+  const adapters = config.adapters;
+  const idSchema = config.id;
+  const adaptedInput = (capability, key, builder) => {
+    const input = endpoint(key).input;
+    if (!input) {
+      throw new Error(`Contract async operation capability "${capability}" requires an input schema`);
     }
-    if (sameTurnAsStart)
+    return (id) => adapterResult(capability, "input", input, builder(id));
+  };
+  const inputFor = {
+    status: adaptedInput("status", config.capabilities.status, adapters.inputFor.status),
+    wait: adaptedInput("wait", config.capabilities.wait, adapters.inputFor.wait)
+  };
+  const optionalInput = (capability, key, builder) => {
+    if (!key)
       return;
-    removeListeners();
-    guardSignalCallback(() => options.onRepeatedSignal?.(signal), "close", options.onError);
-    let restored = false;
-    try {
-      restored = source.raiseDefault(signal);
-    } catch (error) {
-      reportSignalError("close", error, options.onError);
-    }
-    if (!restored) {
-      guardSignalCallback(() => options.onEscalationBlocked?.(signal), "close", options.onError);
+    if (!builder) {
+      throw new Error(`Contract async operation capability "${capability}" requires an input adapter`);
     }
+    inputFor[capability] = adaptedInput(capability, key, builder);
   };
-  for (const signal of signals) {
-    const handler = () => onSignal(signal);
-    handlers.push([signal, handler]);
-    source.on(signal, handler);
+  optionalInput("cancel", config.capabilities.cancel, "cancel" in adapters.inputFor ? adapters.inputFor.cancel : undefined);
+  optionalInput("result", config.capabilities.result, "result" in adapters.inputFor ? adapters.inputFor.result : undefined);
+  optionalInput("artifacts", config.capabilities.artifacts, "artifacts" in adapters.inputFor ? adapters.inputFor.artifacts : undefined);
+  if (!idSchema) {
+    throw new Error("Contract adapted async operation requires an id schema");
   }
-  return { promise, close };
-}
-// src/tools/mount-download.ts
-import { z as z6 } from "zod";
-
-// src/tools/native-result.ts
-function textResult(text, isError = false) {
-  const content = [{ type: "text", text }];
-  return isError ? { content, isError: true } : { content };
-}
-
-// src/tools/mount-download.ts
-function mountDownload(server, config) {
-  const name = config.name ?? "download";
-  assertToolName(name, "<native>", "download");
-  server.registerTool(name, { description: config.description, inputSchema: z6.object(config.inputSchema) }, async (rawArgs) => {
-    const args = isRecord(rawArgs) ? rawArgs : {};
-    try {
-      const url = await config.resolveUrl(args);
-      if (!url)
-        return textResult("Nothing to download.", true);
-      const result = await runDownloadOperation({
-        url,
-        files: config.files,
-        path: config.pathFromArgs?.(args),
-        allowPrivateHosts: config.allowPrivateHosts,
-        maxBytes: config.maxBytes,
-        timeoutMs: config.timeoutMs
-      });
-      return textResult(JSON.stringify(result, null, 2));
-    } catch (error) {
-      if (error instanceof DownloadOperationError) {
-        return textResult(`Download failed [${error.code}]: ${error.message}`, true);
-      }
-      const normalized = normalizeFileToolError(error);
-      return textResult(`Download failed [${normalized.code}]: ${normalized.message}`, true);
-    }
-  });
-}
-// src/tools/mount-upload.ts
-function mountUpload(server, config) {
-  const name = config.name ?? "upload";
-  assertToolName(name, "<native>", "upload");
-  server.registerTool(name, {
-    description: config.description,
-    inputSchema: {
-      path: ManagedFilePathSchema.describe("Path relative to the configured file boundary")
-    }
-  }, async (rawArgs) => {
-    const args = isRecord(rawArgs) ? rawArgs : {};
-    const path = typeof args.path === "string" ? args.path : "";
-    if (!path)
-      return textResult("Provide `path`.", true);
-    try {
-      const uploaded = await runUploadOperation(config.files, path, config.upload);
-      return textResult(JSON.stringify(uploaded ?? null, null, 2));
-    } catch (error) {
-      const normalized = normalizeFileToolError(error);
-      return textResult(`Upload failed [${normalized.code}]: ${normalized.message}`, true);
-    }
-  });
-}
-// src/tools/mount-wait.ts
-import { z as z7 } from "zod";
-function mountWait(server, config) {
-  const name = config.name ?? "wait";
-  assertToolName(name, "<native>", "wait");
-  server.registerTool(name, { description: config.description, inputSchema: z7.object(config.inputSchema) }, async (rawArgs, mcpContext) => {
-    const args = isRecord(rawArgs) ? rawArgs : {};
-    const report = createMcpProgressReporter(mcpContext);
-    let last;
-    try {
-      const { state, timedOut } = await runWaitOperation({
-        input: args,
-        poll: async (input) => {
-          last = await config.poll(input);
-          return last;
-        },
-        done: config.done,
-        backoff: config.backoff,
-        timeoutSec: config.timeoutFromArgs?.(args) ?? config.defaultTimeout,
-        onTick: (attempt, elapsedSec) => {
-          const snapshot = isRecord(last) ? last : undefined;
-          const phase = typeof snapshot?.phase === "string" ? snapshot.phase : undefined;
-          const measured = typeof snapshot?.progress === "number" && Number.isFinite(snapshot.progress) ? snapshot.progress : undefined;
-          report({
-            progress: measured ?? attempt,
-            message: phase ? `${phase} — poll ${attempt}, ${Math.round(elapsedSec)}s elapsed` : `poll ${attempt}, ${Math.round(elapsedSec)}s elapsed`
-          });
-        }
-      });
-      const rendered = config.render ? config.render(state, timedOut) : { text: JSON.stringify(state, null, 2), isError: timedOut };
-      return textResult(rendered.text, rendered.isError);
-    } catch (err) {
-      return textResult(`Wait failed: ${err instanceof Error ? err.message : String(err)}`, true);
-    }
-  });
-}
-// src/tools/oauth-provider.ts
-import { randomUUID } from "node:crypto";
-import { z as z8 } from "zod";
-function isPlainDisplayCharacter(character) {
-  const codePoint = character.codePointAt(0);
-  return codePoint !== undefined && codePoint >= 32 && codePoint !== 127 && character !== "<" && character !== ">";
-}
-var CimdClientMetadataSchema = z8.object({
-  client_id: z8.url(),
-  redirect_uris: z8.array(z8.url()).min(1),
-  client_name: z8.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: z8.literal("none"),
-  application_type: z8.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
-    })
+    contract: config.contract,
+    handlers: config.handlers,
+    capabilities: config.capabilities,
+    schemas: { id: idSchema, snapshot: statusOutput },
+    adapters: {
+      idFromStart: (output) => adapterResult("start", "id", idSchema, adapters.idFromStart(output)),
+      inputFor
+    }
   };
 }
-var PUBLIC_CORS2 = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS
-};
-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`);
+// src/tools/operations/async-operation-canonical.ts
+function buildCanonicalEndpointTable(config, startOutput) {
+  const description = (capability) => config.descriptions?.[capability] ?? `${config.description}: ${capability}`;
+  const endpoint = (capability, method, path, input, output) => {
+    const scope = config.scopes?.[capability];
+    const expose = config.expose?.[capability];
+    return {
+      method,
+      path,
+      desc: description(capability),
+      input,
+      output,
+      ...scope !== undefined && { scope },
+      ...expose !== undefined && { expose }
+    };
+  };
+  const endpoints = {
+    start: endpoint("start", "POST", "/", config.startInput, startOutput),
+    status: endpoint("status", "POST", "/status", config.id, config.snapshot),
+    wait: endpoint("wait", "POST", "/wait", config.id, config.snapshot)
+  };
+  const capabilities = {
+    start: "start",
+    status: "status",
+    wait: "wait"
+  };
+  const schemas = {
+    startInput: config.startInput,
+    startOutput,
+    id: config.id,
+    snapshot: config.snapshot,
+    cancelResult: AsyncOperationCancelResultSchema
+  };
+  const inputFor = {
+    status: (id) => adapterResult("status", "input", config.id, id),
+    wait: (id) => adapterResult("wait", "input", config.id, id)
+  };
+  if (config.cancel) {
+    endpoints.cancel = endpoint("cancel", "POST", "/cancel", config.id, AsyncOperationCancelResultSchema);
+    capabilities.cancel = "cancel";
+    schemas.cancel = AsyncOperationCancelResultSchema;
+    inputFor.cancel = (id) => adapterResult("cancel", "input", config.id, id);
   }
-}
-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;
+  if (config.result) {
+    endpoints.result = endpoint("result", "POST", "/result", config.id, config.result);
+    capabilities.result = "result";
+    schemas.result = config.result;
+    inputFor.result = (id) => adapterResult("result", "input", config.id, id);
+  }
+  if (config.artifacts) {
+    endpoints.artifacts = endpoint("artifacts", "POST", "/artifacts", config.id, config.artifacts);
+    capabilities.artifacts = "artifacts";
+    schemas.artifacts = config.artifacts;
+    inputFor.artifacts = (id) => adapterResult("artifacts", "input", config.id, id);
   }
+  return { endpoints, capabilities, schemas, inputFor };
 }
-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");
+function defineAsyncOperationContract(config) {
+  assertWireStableIdSchema(config.id, "Async operation contract");
+  const hasStartOutput = config.startOutput !== undefined;
+  const hasIdFromStart = config.idFromStart !== undefined;
+  if (hasStartOutput !== hasIdFromStart) {
+    throw new Error("Async operation contract startOutput and idFromStart must be configured together");
   }
-  return url;
+  const startOutput = config.startOutput ?? config.id;
+  const { endpoints, capabilities, schemas, inputFor } = buildCanonicalEndpointTable(config, startOutput);
+  const contract = config.scope ? defineContract({ prefix: config.prefix, scope: config.scope }, endpoints) : defineContract({ prefix: config.prefix }, endpoints);
+  const applicationStartOutput = config.startOutput;
+  const applicationIdFromStart = config.idFromStart;
+  const idFromStart = applicationStartOutput && applicationIdFromStart ? (output) => adapterResult("start", "id", config.id, applicationIdFromStart(output)) : (output) => adapterResult("start", "id", config.id, output);
+  return {
+    contract,
+    capabilities,
+    schemas,
+    adapters: { idFromStart, inputFor }
+  };
 }
-function parseAgeSeconds(headers) {
-  const raw = headers.get("age");
-  if (raw === null)
-    return 0;
-  const first = raw.split(",")[0]?.trim() ?? "";
-  return /^\d+$/.test(first) ? Number(first) : 0;
+// src/tools/native-definition.ts
+function managedNativeIdentity(identity, method) {
+  return { ...identity, method };
 }
-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=([^,\s]*)/i)?.[1];
-  if (maxAge !== undefined) {
-    if (!/^\d+$/.test(maxAge))
-      return { freshnessMs: 0, store: true };
-    const age = parseAgeSeconds(headers);
-    return {
-      freshnessMs: Math.max(0, Math.min(maxTtl, (Number(maxAge) - age) * 1000)),
-      store: true
-    };
-  }
-  const expires = headers.get("expires");
-  if (expires !== null) {
-    const expiresAt = Date.parse(expires);
-    if (!Number.isFinite(expiresAt))
-      return { freshnessMs: 0, store: true };
-    const dateAt = Date.parse(headers.get("date") ?? "");
-    const ageMs = parseAgeSeconds(headers) * 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 };
+
+// src/tools/operations/define-wait-tool.ts
+function defineWaitTool(config) {
+  const renderedMcp = config.render ? {
+    mcp: (state) => {
+      const rendered = config.render?.(state, false);
+      return {
+        content: [
+          {
+            type: "text",
+            text: rendered?.text ?? JSON.stringify(state, null, 2)
+          }
+        ]
+      };
+    }
+  } : undefined;
+  const present = renderedMcp || config.present ? { ...renderedMcp, ...config.present } : undefined;
+  return defineRuntimeTool({
+    name: config.name ?? "wait",
+    description: config.description,
+    identity: managedNativeIdentity(config.identity, "GET"),
+    input: config.input,
+    output: config.state,
+    transports: config.transports,
+    annotations: config.annotations,
+    present,
+    handler: async (context) => {
+      let result;
+      try {
+        result = await runWaitOperation({
+          input: context.input,
+          poll: async (input, signal) => config.state.parse(await config.poll(input, { ...context, signal })),
+          done: config.done,
+          backoff: config.backoff,
+          timeoutSec: config.timeoutFromInput?.(context.input) ?? config.defaultTimeout,
+          signal: context.signal
+        });
+      } catch (error) {
+        if (error instanceof WaitTimeoutError) {
+          throw new AppError("WAIT_TIMEOUT", "Wait timed out before the first snapshot", 408);
+        }
+        throw error;
+      }
+      const rendered = config.render?.(result.state, result.timedOut);
+      if (result.timedOut) {
+        throw new AppError("WAIT_TIMEOUT", rendered?.text ?? "Wait timed out before the operation completed", 408);
+      }
+      if (rendered?.isError) {
+        throw new AppError("WAIT_FAILED", rendered.text, 409);
+      }
+      return result.state;
+    }
+  });
 }
-function safeClientName(value) {
-  if (value === undefined)
-    return;
-  const safe = Array.from(value).filter(isPlainDisplayCharacter).join("").trim().slice(0, 200);
-  return safe || undefined;
+
+// src/tools/operations/async-operation-runtime-tools.ts
+function terminal(snapshot) {
+  if (typeof snapshot !== "object" || snapshot === null || !("phase" in snapshot)) {
+    return false;
+  }
+  return snapshot.phase === "succeeded" || snapshot.phase === "failed" || snapshot.phase === "cancelled";
 }
-function parseScopes(value) {
-  if (!value)
-    return [];
-  return [...new Set(value.split(/\s+/u).filter(Boolean))];
+function succeeded(snapshot) {
+  return typeof snapshot === "object" && snapshot !== null && "phase" in snapshot && snapshot.phase === "succeeded";
 }
-function toRegisteredClient(metadata) {
+function createRuntimeOperationSurface(config) {
+  const capabilityName = (capability) => config.names?.[capability] ?? `${config.name}_${capability}`;
+  const description = (capability) => config.descriptions?.[capability] ?? `${config.description}: ${capability}`;
   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
+    config,
+    identity: (capability, method) => ({
+      serviceName: config.identity.serviceName,
+      action: `${config.identity.action}.${capability}`,
+      scope: config.scopes?.[capability] ?? config.identity.scope,
+      meta: config.identity.meta,
+      method
+    }),
+    common: (capability) => ({
+      name: capabilityName(capability),
+      description: description(capability),
+      transports: config.transports?.[capability],
+      annotations: config.annotations?.[capability] ?? (capability === "start" || capability === "cancel" ? { destructiveHint: true } : undefined)
+    }),
+    inspect: async (capability, context) => {
+      await config.authorize(context.input, capability, context);
+      const state = config.state.parse(await config.inspect(context.input, context));
+      const snapshot = config.snapshot.parse(await config.classify(state, context));
+      return { state, snapshot };
     }
   };
 }
-function isJsonContentType(value) {
-  const mediaType = value.split(";", 1)[0]?.trim().toLowerCase();
-  return mediaType === "application/json" || mediaType?.endsWith("+json") === true;
+function defineObservationTools(surface) {
+  const { config } = surface;
+  const status = defineRuntimeTool({
+    ...surface.common("status"),
+    identity: surface.identity("status", "GET"),
+    input: config.id,
+    output: config.snapshot,
+    handler: async (context) => (await surface.inspect("status", context)).snapshot
+  });
+  const wait = defineWaitTool({
+    ...surface.common("wait"),
+    identity: surface.identity("wait", "GET"),
+    input: config.id,
+    state: config.snapshot,
+    poll: async (_id, context) => (await surface.inspect("wait", context)).snapshot,
+    done: terminal,
+    backoff: config.backoff,
+    defaultTimeout: config.defaultTimeout,
+    timeoutFromInput: config.timeoutFromId
+  });
+  return { status, wait };
 }
-function createCimdResolver(options) {
-  const policy = options.cache ?? {};
-  const now = options.now ?? Date.now;
-  const positives = new Map;
-  const negatives = new Map;
-  const inflight = new Map;
-  const maxEntries = policy.maxEntries ?? 256;
-  const maxResolutions = policy.maxResolutions ?? 120;
-  const maxResolutionsPerClient = policy.maxResolutionsPerClient ?? 10;
-  const resolutionWindowMs = policy.resolutionWindowMs ?? 60000;
-  let resolutionWindowStartedAt = now();
-  let resolutionsInWindow = 0;
-  const clientWindows = new Map;
-  const CLIENT_WINDOW_CAP = 4096;
-  assertPositiveInteger("cimd.cache.maxEntries", maxEntries);
-  assertPositiveInteger("cimd.cache.maxResolutions", maxResolutions);
-  assertPositiveInteger("cimd.cache.maxResolutionsPerClient", maxResolutionsPerClient);
-  assertPositiveInteger("cimd.cache.resolutionWindowMs", resolutionWindowMs);
-  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 readCache = (key) => positives.get(key) ?? negatives.get(key);
-  const trimOldest = (pool) => {
-    while (pool.size > maxEntries) {
-      const oldest = pool.keys().next().value;
-      if (oldest === undefined)
-        break;
-      pool.delete(oldest);
-    }
-  };
-  const touch = (key, value) => {
-    if (value.ok) {
-      negatives.delete(key);
-      positives.delete(key);
-      positives.set(key, value);
-      trimOldest(positives);
-    } else {
-      positives.delete(key);
-      negatives.delete(key);
-      negatives.set(key, value);
-      trimOldest(negatives);
-    }
-  };
-  const dropCache = (key) => {
-    positives.delete(key);
-    negatives.delete(key);
-  };
-  const resolveOne = async (clientId) => {
-    const url = assertCimdClientId(clientId);
-    const cached = readCache(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 currentTime = now();
-    if (currentTime - resolutionWindowStartedAt >= resolutionWindowMs) {
-      resolutionWindowStartedAt = currentTime;
-      resolutionsInWindow = 0;
+function defineCancelTool(surface, capability) {
+  return defineRuntimeTool({
+    ...surface.common("cancel"),
+    identity: surface.identity("cancel", "DELETE"),
+    input: surface.config.id,
+    output: AsyncOperationCancelResultSchema,
+    handler: async (context) => {
+      const inspected = await surface.inspect("cancel", context);
+      return capability.handler(inspected.state, context);
     }
-    let clientWindow = clientWindows.get(clientId);
-    if (!clientWindow || currentTime - clientWindow.startedAt >= resolutionWindowMs) {
-      clientWindow = { startedAt: currentTime, count: 0 };
-      clientWindows.delete(clientId);
-      clientWindows.set(clientId, clientWindow);
-      while (clientWindows.size > CLIENT_WINDOW_CAP) {
-        const oldest = clientWindows.keys().next().value;
-        if (oldest === undefined)
-          break;
-        clientWindows.delete(oldest);
+  });
+}
+function defineSucceededOutputTool(surface, kind, capability, unavailableMessage) {
+  return defineRuntimeTool({
+    ...surface.common(kind),
+    identity: surface.identity(kind, "GET"),
+    input: surface.config.id,
+    output: capability.output,
+    handler: async (context) => {
+      const inspected = await surface.inspect(kind, context);
+      if (!succeeded(inspected.snapshot)) {
+        throw new AppError("OPERATION_NOT_SUCCEEDED", unavailableMessage, 409);
       }
+      return capability.handler(inspected.state, context);
     }
-    if (clientWindow.count >= maxResolutionsPerClient) {
-      throw new Error("CIMD metadata resolution rate limit exceeded for this client_id");
+  });
+}
+
+// src/tools/operations/async-operation-runtime.ts
+function defineAsyncOperation(config) {
+  const surface = createRuntimeOperationSurface(config);
+  const start = defineRuntimeTool({
+    ...surface.common("start"),
+    identity: surface.identity("start", "POST"),
+    input: config.startInput,
+    output: config.id,
+    handler: (context) => config.start(context.input, context)
+  });
+  const { status, wait } = defineObservationTools(surface);
+  const definitions = { start, status, wait };
+  const names = new Set;
+  if (config.cancel) {
+    definitions.cancel = defineCancelTool(surface, config.cancel);
+  }
+  if (config.result) {
+    definitions.result = defineSucceededOutputTool(surface, "result", config.result, "Operation result is not available");
+  }
+  if (config.artifacts) {
+    definitions.artifacts = defineSucceededOutputTool(surface, "artifacts", config.artifacts, "Operation artifacts are not available");
+  }
+  for (const definition of Object.values(definitions)) {
+    assertUniqueToolName(definition.name, names.has(definition.name), "in-process tool name");
+    names.add(definition.name);
+  }
+  return {
+    ...definitions,
+    runtimeTools: Object.values(definitions),
+    schemas: {
+      id: config.id,
+      snapshot: config.snapshot,
+      cancelResult: AsyncOperationCancelResultSchema
     }
-    if (resolutionsInWindow >= maxResolutions) {
-      throw new Error("CIMD metadata resolution rate limit exceeded");
+  };
+}
+// src/tools/operations/mount-wait.ts
+import { z as z5 } from "zod";
+
+// src/tools/transfer/native-result.ts
+function textResult(text, isError = false) {
+  const content = [{ type: "text", text }];
+  return isError ? { content, isError: true } : { content };
+}
+
+// src/tools/operations/mount-wait.ts
+function mountWait(server, config) {
+  const name = config.name ?? "wait";
+  assertToolName(name, "<native>", "wait");
+  server.registerTool(name, { description: config.description, inputSchema: z5.object(config.inputSchema) }, async (rawArgs, mcpContext) => {
+    const args = isRecord(rawArgs) ? rawArgs : {};
+    const report = createMcpProgressReporter(mcpContext);
+    let last;
+    try {
+      const { state, timedOut } = await runWaitOperation({
+        input: args,
+        poll: async (input) => {
+          last = await config.poll(input);
+          return last;
+        },
+        done: config.done,
+        backoff: config.backoff,
+        timeoutSec: config.timeoutFromArgs?.(args) ?? config.defaultTimeout,
+        onTick: (attempt, elapsedSec) => {
+          const snapshot = isRecord(last) ? last : undefined;
+          const phase = typeof snapshot?.phase === "string" ? snapshot.phase : undefined;
+          const measured = typeof snapshot?.progress === "number" && Number.isFinite(snapshot.progress) ? snapshot.progress : undefined;
+          report({
+            progress: measured ?? attempt,
+            message: phase ? `${phase} — poll ${attempt}, ${Math.round(elapsedSec)}s elapsed` : `poll ${attempt}, ${Math.round(elapsedSec)}s elapsed`
+          });
+        }
+      });
+      const rendered = config.render ? config.render(state, timedOut) : { text: JSON.stringify(state, null, 2), isError: timedOut };
+      return textResult(rendered.text, rendered.isError);
+    } catch (err) {
+      return textResult(`Wait failed: ${err instanceof Error ? err.message : String(err)}`, true);
     }
-    clientWindow.count += 1;
-    resolutionsInWindow += 1;
-    const conditionalHeaders = {};
-    if (cached?.ok && cached.etag)
-      conditionalHeaders["if-none-match"] = cached.etag;
-    if (cached?.ok && cached.lastModified) {
-      conditionalHeaders["if-modified-since"] = cached.lastModified;
+  });
+}
+// src/tools/registry.ts
+function defineToolRegistry(input) {
+  const defaults = [...input.defaults];
+  const slots = new Set;
+  for (const tool of defaults) {
+    if (!tool.name)
+      throw new Error("A default tool must carry a non-empty name");
+    if (slots.has(tool.name))
+      throw new Error(`Duplicate default tool name: ${tool.name}`);
+    slots.add(tool.name);
+  }
+  const disabled = new Set;
+  const replacements = new Map;
+  const assertKnown = (name, verb) => {
+    if (!slots.has(name)) {
+      throw new Error(`Tool registry ${verb}("${name}") names no default; declared: ${[...slots].sort().join(", ") || "(none)"}`);
     }
-    try {
-      const response = await options.fetcher.fetch(url, conditionalHeaders);
-      const freshness = responseFreshness(response.headers, policy, now());
-      if (response.status === 304 && cached?.ok) {
-        const refreshed = {
-          ...cached,
-          expiresAt: now() + freshness.freshnessMs
-        };
-        if (freshness.store)
-          touch(clientId, refreshed);
-        else
-          dropCache(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 builder = {
+    replace(name, tool) {
+      assertKnown(name, "replace");
+      if (disabled.has(name)) {
+        throw new Error(`Tool registry cannot replace "${name}": it is disabled`);
       }
-      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 (replacements.has(name)) {
+        throw new Error(`Tool registry already replaced "${name}"`);
       }
-      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");
+      if (tool.name !== name) {
+        throw new Error(`A replacement for "${name}" must carry that name, not "${tool.name}"`);
       }
-      const client = toRegisteredClient(metadata);
-      if (freshness.store && Number.isFinite(freshness.freshnessMs)) {
-        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 {
-        dropCache(clientId);
+      replacements.set(name, tool);
+      return builder;
+    },
+    disable(name) {
+      assertKnown(name, "disable");
+      disabled.add(name);
+      return builder;
+    },
+    build() {
+      const tools = [];
+      const seen = new Set;
+      for (const tool of defaults) {
+        if (disabled.has(tool.name))
+          continue;
+        const effective = replacements.get(tool.name) ?? tool;
+        if (seen.has(effective.name)) {
+          throw new Error(`Duplicate composed tool name: ${effective.name}`);
+        }
+        seen.add(effective.name);
+        tools.push(effective);
       }
-      return client;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "CIMD metadata resolution failed";
-      touch(clientId, {
-        ok: false,
-        message,
-        expiresAt: now() + (policy.negativeTtlMs ?? 1e4)
-      });
-      throw error;
+      return { tools, names: tools.map((tool) => tool.name) };
     }
   };
-  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;
+  return builder;
+}
+// src/tools/tool-logger.ts
+function createToolLogger(config = {}) {
+  const log = config.log ?? ((line) => console.error(line));
+  return {
+    afterToolCall: ({ toolName, result, durationMs, context, endpoint }) => {
+      const record = {
+        tool: toolName,
+        service: endpoint.serviceName,
+        action: endpoint.key,
+        ok: result.ok,
+        code: result.ok ? undefined : result.code,
+        durationMs: Math.round(durationMs),
+        source: String(context.source),
+        traceId: getTraceId()
+      };
+      const codePart = result.ok ? "" : ` ${result.code}`;
+      log(`[tool] ${result.ok ? "ok" : "warn"} ${toolName} (${endpoint.serviceName}.${endpoint.key})${codePart} ${record.durationMs}ms`);
+      config.onRecord?.(record);
+    }
   };
 }
-function json(body, status = 200, extraHeaders) {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json", ...PUBLIC_CORS2, ...extraHeaders }
-  });
+// src/tools/toolkit.ts
+function createToolkit() {
+  return {
+    mountMcp: (server, services, config) => mountMcp(server, services, config),
+    mountAgent: (services, config) => mountAgent(services, config),
+    buildMcpServer: (config, auth) => buildMcpServer(config, auth),
+    createMcpHandler: (config) => createMcpHandler(config),
+    createStdioMcpServer: (config) => createStdioMcpServer(config),
+    createCli: (config) => createCli(config)
+  };
 }
-function oauthError(error, description, status = 400) {
-  return json({ error, error_description: description }, status);
+// src/tools/transfer/download-core.ts
+import { basename, extname } from "node:path";
+var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
+var MIME_EXT = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav",
+  "audio/ogg": ".ogg"
+};
+
+class DownloadOperationError extends Error {
+  code;
+  status;
+  constructor(code, message, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "DownloadOperationError";
+  }
 }
-function isRegistrableRedirectUri(value, applicationType) {
+function extensionFor(url, mime) {
+  if (MIME_EXT[mime])
+    return MIME_EXT[mime];
   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:")
-      return false;
-    if (applicationType === "web")
-      return false;
-    const host = url.hostname.replace(/^\[|\]$/g, "");
-    return host === "127.0.0.1" || host === "::1" || host === "localhost";
-  } catch {
-    return false;
-  }
+    const ext = extname(new URL(url).pathname).toLowerCase();
+    if (ext)
+      return ext;
+  } catch {}
+  return ".bin";
 }
-function isLoopbackRedirectUri(value) {
+function baseNameFor(url) {
   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";
+    const path = new URL(url).pathname;
+    return (basename(path, extname(path)) || "download").slice(0, 60);
   } catch {
-    return false;
+    return "download";
   }
 }
-function redirectWith(uri, params) {
-  const url = new URL(uri);
-  for (const [key, value] of Object.entries(params))
-    url.searchParams.set(key, value);
-  return new Response(null, { status: 302, headers: { Location: url.toString() } });
+async function runDownloadOperation(config) {
+  const res = await fetchGuarded(new URL(config.url), config.allowPrivateHosts ?? false, {
+    timeoutMs: config.timeoutMs,
+    signal: config.signal
+  });
+  if (!res.ok) {
+    throw new DownloadOperationError("DOWNLOAD_HTTP_ERROR", `HTTP ${res.status}`, 502);
+  }
+  const mimeType = mediaTypeEssence(res.headers.get("content-type")) || "application/octet-stream";
+  const max = config.maxBytes ?? DEFAULT_MAX_BYTES;
+  const declared = Number(res.headers.get("content-length") ?? 0);
+  if (declared > max) {
+    await res.body?.cancel();
+    throw new DownloadOperationError("DOWNLOAD_TOO_LARGE", `file exceeds the ${max}-byte cap`, 413);
+  }
+  const path = config.path ?? `${baseNameFor(config.url)}${extensionFor(config.url, mimeType)}`;
+  return config.files.write(path, res.body ?? new Uint8Array, {
+    maxBytes: max,
+    mediaType: mimeType,
+    signal: config.signal
+  });
 }
-async function readForm(req) {
-  const contentType = req.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    const body = await req.json().catch(() => null);
-    const params = new URLSearchParams;
-    if (isRecord(body)) {
-      for (const [key, value] of Object.entries(body)) {
-        if (typeof value === "string")
-          params.set(key, value);
-      }
-    }
-    return params;
+
+// src/tools/transfer/managed-file-error.ts
+var SAFE_MANAGED_FILE_MESSAGES = {
+  FILE_INVALID_PATH: "Invalid managed-file path",
+  FILE_OUTSIDE_ROOT: "Managed-file path escapes its boundary",
+  FILE_NOT_FOUND: "Managed file not found",
+  FILE_NOT_REGULAR: "Managed path is not a regular file",
+  FILE_INSPECTION_REJECTED: "Managed file rejected by inspection",
+  FILE_TOO_LARGE: "Managed file exceeds the configured size limit",
+  FILE_EXISTS: "Managed file already exists"
+};
+function managedFileAppError(error) {
+  if (!(error instanceof ManagedFileError))
+    return null;
+  switch (error.code) {
+    case "FILE_INVALID_PATH":
+    case "FILE_OUTSIDE_ROOT":
+    case "FILE_NOT_FOUND":
+    case "FILE_NOT_REGULAR":
+    case "FILE_INSPECTION_REJECTED":
+    case "FILE_TOO_LARGE":
+    case "FILE_EXISTS":
+      return new AppError(error.code, SAFE_MANAGED_FILE_MESSAGES[error.code], STITCH_ERROR_STATUS[error.code]);
+    case "FILE_IO_ERROR":
+      return null;
   }
-  return new URLSearchParams(await req.text());
 }
-function mountOAuthProvider(config) {
-  const base = config.basePath ?? "/oauth";
-  const ttl = config.accessTokenTtlSec ?? 3600;
-  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",
-    path: AS_METADATA_PATH,
-    handler: (req) => {
-      if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
-      return json({
-        issuer: config.issuer,
-        authorization_endpoint: `${config.issuer}${authorizePath}`,
-        token_endpoint: `${config.issuer}${tokenPath}`,
-        ...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 }
-      });
-    }
-  };
-  const registerRoute = {
-    method: "ALL",
-    path: registerPath,
-    handler: async (req) => {
-      if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
-      if (req.method !== "POST")
-        return oauthError("invalid_request", "POST required", 405);
-      const meta = await req.json().catch(() => null);
-      if (!isRecord(meta)) {
-        return oauthError("invalid_client_metadata", "Body must be a JSON object");
-      }
-      const rawAppType = meta.application_type;
-      if (rawAppType !== undefined && rawAppType !== "native" && rawAppType !== "web") {
-        return oauthError("invalid_client_metadata", "application_type must be 'native' or 'web'");
-      }
-      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)");
-      }
-      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,
-        ...applicationType && { applicationType }
-      });
-      return json({
-        client_id: client.clientId,
-        redirect_uris: client.redirectUris,
-        token_endpoint_auth_method: "none",
-        grant_types: config.refreshTokens ? ["authorization_code", "refresh_token"] : ["authorization_code"],
-        response_types: ["code"],
-        ...client.clientName && { client_name: client.clientName },
-        ...client.applicationType && { application_type: client.applicationType }
-      }, 201);
-    }
-  };
-  const authorizeRoute = {
-    method: "ALL",
-    path: authorizePath,
-    handler: async (req) => {
-      if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
-      const url = new URL(req.url);
-      const p = url.searchParams;
-      const clientId = p.get("client_id");
-      const redirectUri = p.get("redirect_uri");
-      const responseType = p.get("response_type");
-      const codeChallenge = p.get("code_challenge");
-      const codeChallengeMethod = p.get("code_challenge_method") ?? "S256";
-      const resource = p.get("resource");
-      const scope = p.get("scope") ?? undefined;
-      const state = p.get("state") ?? undefined;
-      if (!clientId || !redirectUri) {
-        return oauthError("invalid_request", "client_id and redirect_uri are required");
-      }
-      const client = await resolveClient(clientId);
-      if (!client)
-        return oauthError("invalid_client", "Unknown client_id", 401);
-      if (!client.redirectUris.includes(redirectUri)) {
-        return oauthError("invalid_request", "redirect_uri does not match a registered URI");
-      }
-      if (responseType !== "code") {
-        return redirectToClient(redirectUri, {
-          error: "unsupported_response_type",
-          ...state && { state }
-        });
-      }
-      if (!codeChallenge || codeChallengeMethod !== "S256") {
-        return redirectToClient(redirectUri, {
-          error: "invalid_request",
-          error_description: "PKCE S256 code_challenge is required",
-          ...state && { state }
-        });
-      }
-      if (!resource) {
-        return redirectToClient(redirectUri, {
-          error: "invalid_target",
-          error_description: "resource parameter is required",
-          ...state && { state }
-        });
-      }
-      if (resource !== config.resource) {
-        return redirectToClient(redirectUri, {
-          error: "invalid_target",
-          error_description: "resource is not served by this authorization server",
-          ...state && { state }
-        });
+function normalizeFileToolError(error) {
+  return managedFileAppError(error) ?? normalizeError(error);
+}
+
+// src/tools/transfer/define-download-tool.ts
+function defineDownloadTool(config) {
+  return defineRuntimeTool({
+    name: config.name ?? "download",
+    description: config.description,
+    identity: managedNativeIdentity(config.identity, "POST"),
+    input: config.input,
+    output: ManagedFileRefSchema,
+    transports: config.transports,
+    annotations: config.annotations,
+    present: config.present,
+    handler: async (context) => {
+      const url = await config.resolveUrl(context.input, context);
+      if (!url) {
+        throw new AppError("DOWNLOAD_NOT_FOUND", "Nothing to download", 404);
       }
-      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 }
+      try {
+        return await runDownloadOperation({
+          url,
+          files: config.files,
+          path: config.pathFromInput?.(context.input),
+          allowPrivateHosts: config.allowPrivateHosts,
+          maxBytes: config.maxBytes,
+          timeoutMs: config.timeoutMs,
+          signal: context.signal
         });
-      }
-      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
+      } catch (error) {
+        if (error instanceof DownloadOperationError) {
+          throw new AppError(error.code, `Download failed: ${error.message}`, error.status);
         }
-      };
-      const result = await config.authorizeUser(req, authRequest);
-      if (result instanceof Response)
-        return result;
-      if (!Array.isArray(result.approvedScopes) || !result.approvedScopes.every((scope2) => typeof scope2 === "string")) {
-        throw new Error("authorizeUser must return approvedScopes as an array of strings");
-      }
-      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 managedError = managedFileAppError(error);
+        if (managedError)
+          throw managedError;
+        throw error;
       }
-      const approvedScope = approvedScopes.length > 0 ? approvedScopes.join(" ") : undefined;
-      const code = randomUUID();
-      await config.codes.save(code, {
-        clientId,
-        redirectUri,
-        codeChallenge,
-        codeChallengeMethod: "S256",
-        resource,
-        scope: approvedScope,
-        userId: result.userId,
-        expiresAt: Date.now() + AUTH_CODE_TTL_MS
-      });
-      return redirectToClient(redirectUri, { code, ...state && { state } });
     }
-  };
-  const issueAccessToken = (userId, audience, clientId, scope) => signJwt({ scope, client_id: clientId }, config.signingSecret, {
-    issuer: config.issuer,
-    audience,
-    subject: userId,
-    expiresInSec: ttl
   });
-  const tokenRoute = {
-    method: "ALL",
-    path: tokenPath,
-    handler: async (req) => {
-      if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
-      if (req.method !== "POST")
-        return oauthError("invalid_request", "POST required", 405);
-      const form = await readForm(req);
-      const grantType = form.get("grant_type");
-      if (grantType === "authorization_code") {
-        const code = form.get("code");
-        const verifier = form.get("code_verifier");
-        const redirectUri = form.get("redirect_uri");
-        const clientId = form.get("client_id");
-        if (!code || !verifier || !redirectUri || !clientId) {
-          return oauthError("invalid_request", "code, code_verifier, redirect_uri, client_id required");
-        }
-        const data = await config.codes.take(code);
-        if (!data)
-          return oauthError("invalid_grant", "Unknown or used authorization code");
-        if (data.expiresAt < Date.now())
-          return oauthError("invalid_grant", "Authorization code expired");
-        if (data.clientId !== clientId)
-          return oauthError("invalid_grant", "client_id mismatch");
-        if (data.redirectUri !== redirectUri)
-          return oauthError("invalid_grant", "redirect_uri mismatch");
-        if (!await verifyPkce(verifier, data.codeChallenge)) {
-          return oauthError("invalid_grant", "PKCE verification failed");
-        }
-        const accessToken = await issueAccessToken(data.userId, data.resource, data.clientId, data.scope);
-        let refreshToken;
-        if (config.refreshTokens) {
-          refreshToken = randomUUID();
-          await config.refreshTokens.save(refreshToken, {
-            clientId: data.clientId,
-            resource: data.resource,
-            scope: data.scope,
-            userId: data.userId
-          });
-        }
-        return json({
-          access_token: accessToken,
-          token_type: "Bearer",
-          expires_in: ttl,
-          ...data.scope && { scope: data.scope },
-          ...refreshToken && { refresh_token: refreshToken }
-        });
-      }
-      if (grantType === "refresh_token") {
-        if (!config.refreshTokens) {
-          return oauthError("unsupported_grant_type", "refresh_token grant is not enabled");
-        }
-        const token = form.get("refresh_token");
-        const clientId = form.get("client_id");
-        if (!token || !clientId)
-          return oauthError("invalid_request", "refresh_token and client_id required");
-        const data = await config.refreshTokens.take(token);
-        if (!data)
-          return oauthError("invalid_grant", "Unknown or used refresh token");
-        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 = randomUUID();
-        await config.refreshTokens.save(newRefresh, data);
-        return json({
-          access_token: accessToken,
-          token_type: "Bearer",
-          expires_in: ttl,
-          ...data.scope && { scope: data.scope },
-          refresh_token: newRefresh
-        });
+}
+// src/tools/transfer/define-upload-tool.ts
+import { z as z6 } from "zod";
+
+// src/tools/transfer/upload-core.ts
+function runUploadOperation(files, path, upload, signal) {
+  signal?.throwIfAborted();
+  return files.read(path, { signal }).then((source) => upload(source, signal));
+}
+
+// src/tools/transfer/define-upload-tool.ts
+var UploadToolInputSchema = z6.object({
+  path: ManagedFilePathSchema.describe("Path relative to the configured file boundary")
+});
+function defineUploadTool(config) {
+  return defineRuntimeTool({
+    name: config.name ?? "upload",
+    description: config.description,
+    identity: managedNativeIdentity(config.identity, "POST"),
+    input: UploadToolInputSchema,
+    output: config.output,
+    transports: config.transports,
+    annotations: config.annotations,
+    present: config.present,
+    handler: async (context) => {
+      try {
+        return await runUploadOperation(config.files, context.input.path, (source) => config.upload(source, context), context.signal);
+      } catch (error) {
+        const managedError = managedFileAppError(error);
+        if (managedError)
+          throw managedError;
+        throw error;
       }
-      return oauthError("unsupported_grant_type", `Unsupported grant_type: ${grantType ?? "none"}`);
     }
+  });
+}
+// src/tools/transfer/view-file.ts
+import { extname as extname2 } from "node:path";
+var MAX_INLINE_BYTES = 20 * 1024 * 1024;
+var EXT_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime"
+};
+async function fetchSource(pathOrUrl, options, maxBytes) {
+  const extMime = EXT_MIME[extname2(pathOrUrl).toLowerCase()];
+  if (pathOrUrl.startsWith("http://") || pathOrUrl.startsWith("https://")) {
+    const url = new URL(pathOrUrl);
+    const res = await fetchGuarded(url, options.allowPrivateHosts ?? false, {
+      timeoutMs: options.timeoutMs,
+      signal: options.signal
+    });
+    if (!res.ok)
+      throw new AppError("VIEW_HTTP_ERROR", `HTTP ${res.status}`, 502);
+    const headerMime = mediaTypeEssence(res.headers.get("content-type"));
+    const mimeType = headerMime || extMime || "application/octet-stream";
+    if (mimeType.startsWith("video/")) {
+      await res.body?.cancel();
+      return { video: true, mimeType, bytesRead: 0 };
+    }
+    const declared = Number(res.headers.get("content-length") ?? 0);
+    if (declared > maxBytes) {
+      await res.body?.cancel();
+      return { tooLarge: true, mimeType, bytesRead: 0 };
+    }
+    const buffer = await readCapped(res, maxBytes);
+    return buffer ? { buffer, mimeType, bytesRead: buffer.length } : { tooLarge: true, mimeType, bytesRead: maxBytes };
+  }
+  if (!options.files) {
+    throw new AppError("FILE_INVALID_PATH", "local file paths are disabled — set files to allow them", 400);
+  }
+  options.signal?.throwIfAborted();
+  if (!extMime) {
+    throw new AppError("FILE_INSPECTION_REJECTED", "refusing to read a non-media file", 422);
+  }
+  try {
+    const source = await options.files.read(pathOrUrl, {
+      maxBytes,
+      signal: options.signal
+    });
+    const buffer = Buffer.from(source.bytes);
+    return {
+      buffer,
+      mimeType: source.ref.mediaType ?? extMime,
+      bytesRead: buffer.length
+    };
+  } catch (error) {
+    if (error instanceof ManagedFileError && error.code === "FILE_TOO_LARGE") {
+      return { tooLarge: true, mimeType: extMime, bytesRead: maxBytes };
+    }
+    throw error;
+  }
+}
+async function resolveMediaWithinBudget(pathOrUrl, options, maxBytes) {
+  if (maxBytes <= 0) {
+    return {
+      content: [
+        { type: "text", text: `[media] total inline budget exhausted — ${pathOrUrl}` }
+      ],
+      bytes: 0
+    };
+  }
+  const extMime = EXT_MIME[extname2(pathOrUrl).toLowerCase()];
+  if (extMime?.startsWith("video/")) {
+    return {
+      content: [{ type: "text", text: `[video] ${extMime} — ${pathOrUrl}` }],
+      bytes: 0
+    };
+  }
+  const result = await fetchSource(pathOrUrl, options, maxBytes);
+  if ("video" in result) {
+    return {
+      content: [{ type: "text", text: `[video] ${result.mimeType} — ${pathOrUrl}` }],
+      bytes: result.bytesRead
+    };
+  }
+  if ("tooLarge" in result) {
+    return {
+      content: [
+        { type: "text", text: `[${result.mimeType}] too large to inline — ${pathOrUrl}` }
+      ],
+      bytes: result.bytesRead
+    };
+  }
+  const { buffer, mimeType } = result;
+  const sizeKb = (buffer.length / 1024).toFixed(0);
+  if (mimeType.startsWith("image/")) {
+    return {
+      content: [
+        {
+          type: "image",
+          data: buffer.toString("base64"),
+          mimeType,
+          annotations: { audience: ["user", "assistant"], priority: 0.9 }
+        },
+        { type: "text", text: `[image] ${mimeType}, ${sizeKb}KB` }
+      ],
+      bytes: buffer.length
+    };
+  }
+  if (mimeType.startsWith("audio/")) {
+    return {
+      content: [
+        {
+          type: "audio",
+          data: buffer.toString("base64"),
+          mimeType,
+          annotations: { audience: ["user", "assistant"], priority: 0.9 }
+        },
+        { type: "text", text: `[audio] ${mimeType}, ${sizeKb}KB` }
+      ],
+      bytes: buffer.length
+    };
+  }
+  return {
+    content: [{ type: "text", text: `[${mimeType}] ${sizeKb}KB — ${pathOrUrl}` }],
+    bytes: buffer.length
   };
-  return dcrEnabled ? [metadataRoute, registerRoute, authorizeRoute, tokenRoute] : [metadataRoute, authorizeRoute, tokenRoute];
 }
-// src/tools/registry.ts
-function defineToolRegistry(input) {
-  const defaults = [...input.defaults];
-  const slots = new Set;
-  for (const tool of defaults) {
-    if (!tool.name)
-      throw new Error("A default tool must carry a non-empty name");
-    if (slots.has(tool.name))
-      throw new Error(`Duplicate default tool name: ${tool.name}`);
-    slots.add(tool.name);
-  }
-  const disabled = new Set;
-  const replacements = new Map;
-  const assertKnown = (name, verb) => {
-    if (!slots.has(name)) {
-      throw new Error(`Tool registry ${verb}("${name}") names no default; declared: ${[...slots].sort().join(", ") || "(none)"}`);
+async function resolveMedia(pathOrUrl, options = {}) {
+  return (await resolveMediaWithinBudget(pathOrUrl, options, MAX_INLINE_BYTES)).content;
+}
+async function runViewFileOperation(paths, options = {}, signal) {
+  const list = Array.isArray(paths) ? paths : [paths];
+  const content = [];
+  const errors = [];
+  let remainingBytes = MAX_INLINE_BYTES;
+  for (const pathOrUrl of list) {
+    signal?.throwIfAborted();
+    try {
+      const resolved = await resolveMediaWithinBudget(pathOrUrl, { ...options, signal }, remainingBytes);
+      remainingBytes -= resolved.bytes;
+      content.push(...resolved.content);
+    } catch (error) {
+      if (signal?.aborted)
+        throw signal.reason ?? error;
+      const message = normalizeFileToolError(error).message;
+      errors.push({ path: pathOrUrl, message });
+      content.push({ type: "text", text: `[${pathOrUrl}] Error: ${message}` });
     }
+  }
+  return ViewFileOutputSchema.parse({ content, errors });
+}
+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: ViewFileInputSchema.shape,
+    annotations: { title: "View Media", readOnlyHint: true, idempotentHint: true }
+  }, async (args) => {
+    const result = await runViewFileOperation(args.paths, options);
+    return { content: result.content };
+  });
+}
+
+// src/tools/transfer/define-view-file-tool.ts
+function defineViewFileTool(config) {
+  const defaults = {
+    mcp: (output) => ({ content: output.content }),
+    agent: (output) => ({
+      type: "content",
+      value: output.content.map((part) => {
+        if (part.type === "text")
+          return part;
+        return {
+          type: "file",
+          data: { type: "data", data: part.data },
+          mediaType: part.mimeType
+        };
+      })
+    })
   };
-  const builder = {
-    replace(name, tool) {
-      assertKnown(name, "replace");
-      if (disabled.has(name)) {
-        throw new Error(`Tool registry cannot replace "${name}": it is disabled`);
-      }
-      if (replacements.has(name)) {
-        throw new Error(`Tool registry already replaced "${name}"`);
-      }
-      if (tool.name !== name) {
-        throw new Error(`A replacement for "${name}" must carry that name, not "${tool.name}"`);
-      }
-      replacements.set(name, tool);
-      return builder;
-    },
-    disable(name) {
-      assertKnown(name, "disable");
-      disabled.add(name);
-      return builder;
+  return defineRuntimeTool({
+    name: config.name ?? "view_file",
+    description: config.description,
+    identity: managedNativeIdentity(config.identity, "GET"),
+    input: ViewFileInputSchema,
+    output: ViewFileOutputSchema,
+    transports: config.transports,
+    annotations: config.annotations ?? {
+      title: "View Media",
+      readOnlyHint: true,
+      idempotentHint: true
     },
-    build() {
-      const tools = [];
-      const seen = new Set;
-      for (const tool of defaults) {
-        if (disabled.has(tool.name))
-          continue;
-        const effective = replacements.get(tool.name) ?? tool;
-        if (seen.has(effective.name)) {
-          throw new Error(`Duplicate composed tool name: ${effective.name}`);
-        }
-        seen.add(effective.name);
-        tools.push(effective);
+    present: { ...defaults, ...config.present },
+    handler: (context) => runViewFileOperation(context.input.paths, {
+      files: config.files,
+      allowPrivateHosts: config.allowPrivateHosts,
+      timeoutMs: config.timeoutMs
+    }, context.signal)
+  });
+}
+// src/tools/transfer/mount-download.ts
+import { z as z7 } from "zod";
+function mountDownload(server, config) {
+  const name = config.name ?? "download";
+  assertToolName(name, "<native>", "download");
+  server.registerTool(name, { description: config.description, inputSchema: z7.object(config.inputSchema) }, async (rawArgs) => {
+    const args = isRecord(rawArgs) ? rawArgs : {};
+    try {
+      const url = await config.resolveUrl(args);
+      if (!url)
+        return textResult("Nothing to download.", true);
+      const result = await runDownloadOperation({
+        url,
+        files: config.files,
+        path: config.pathFromArgs?.(args),
+        allowPrivateHosts: config.allowPrivateHosts,
+        maxBytes: config.maxBytes,
+        timeoutMs: config.timeoutMs
+      });
+      return textResult(JSON.stringify(result, null, 2));
+    } catch (error) {
+      if (error instanceof DownloadOperationError) {
+        return textResult(`Download failed [${error.code}]: ${error.message}`, true);
       }
-      return { tools, names: tools.map((tool) => tool.name) };
+      const normalized = normalizeFileToolError(error);
+      return textResult(`Download failed [${normalized.code}]: ${normalized.message}`, true);
     }
-  };
-  return builder;
+  });
 }
-// src/tools/tool-logger.ts
-function createToolLogger(config = {}) {
-  const log = config.log ?? ((line) => console.error(line));
-  return {
-    afterToolCall: ({ toolName, result, durationMs, context, endpoint }) => {
-      const record = {
-        tool: toolName,
-        service: endpoint.serviceName,
-        action: endpoint.key,
-        ok: result.ok,
-        code: result.ok ? undefined : result.code,
-        durationMs: Math.round(durationMs),
-        source: String(context.source),
-        traceId: getTraceId()
-      };
-      const codePart = result.ok ? "" : ` ${result.code}`;
-      log(`[tool] ${result.ok ? "ok" : "warn"} ${toolName} (${endpoint.serviceName}.${endpoint.key})${codePart} ${record.durationMs}ms`);
-      config.onRecord?.(record);
+// src/tools/transfer/mount-upload.ts
+function mountUpload(server, config) {
+  const name = config.name ?? "upload";
+  assertToolName(name, "<native>", "upload");
+  server.registerTool(name, {
+    description: config.description,
+    inputSchema: {
+      path: ManagedFilePathSchema.describe("Path relative to the configured file boundary")
     }
-  };
-}
-// src/tools/toolkit.ts
-function createToolkit() {
-  return {
-    mountMcp: (server, services, config) => mountMcp(server, services, config),
-    mountAgent: (services, config) => mountAgent(services, config),
-    buildMcpServer: (config, auth) => buildMcpServer(config, auth),
-    createMcpHandler: (config) => createMcpHandler(config),
-    createStdioMcpServer: (config) => createStdioMcpServer(config),
-    createCli: (config) => createCli(config)
-  };
+  }, async (rawArgs) => {
+    const args = isRecord(rawArgs) ? rawArgs : {};
+    const path = typeof args.path === "string" ? args.path : "";
+    if (!path)
+      return textResult("Provide `path`.", true);
+    try {
+      const uploaded = await runUploadOperation(config.files, path, config.upload);
+      return textResult(JSON.stringify(uploaded ?? null, null, 2));
+    } catch (error) {
+      const normalized = normalizeFileToolError(error);
+      return textResult(`Upload failed [${normalized.code}]: ${normalized.message}`, true);
+    }
+  });
 }
 // src/tools/transports.ts
-var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT", "CLI"];
-var TOOL_TRANSPORTS2 = ["MCP", "AGENT", "CLI"];
 function emptyCounts() {
   return { HTTP: 0, MCP: 0, AGENT: 0, CLI: 0 };
 }
@@ -2805,7 +2843,7 @@ function contractCounts(service) {
     if (!method.expose || method.expose.includes("HTTP"))
       counts.HTTP += 1;
   }
-  for (const transport of TOOL_TRANSPORTS2) {
+  for (const transport of TOOL_TRANSPORTS) {
     counts[transport] = collectToolSurface({
       surface: { services: [service] },
       transport,
@@ -2817,7 +2855,7 @@ function contractCounts(service) {
 }
 function runtimeCounts(runtimeTools) {
   const counts = emptyCounts();
-  for (const transport of TOOL_TRANSPORTS2) {
+  for (const transport of TOOL_TRANSPORTS) {
     counts[transport] = collectToolSurface({
       surface: { runtimeTools },
       transport,
@@ -2892,7 +2930,6 @@ export {
   defineToolRegistry,
   defineRuntimeTool,
   defineDownloadTool,
-  defineCliCommand,
   defineAsyncOperationContract,
   defineAsyncOperation,
   createToolkit,
@@ -2904,7 +2941,6 @@ export {
   createMcpHttpRoute,
   createMcpHandler,
   createLocalStepDurability,
-  createCli,
   createAsyncOperationSnapshotSchema,
   composeToolLifecycle,
   collectTools,