stitchkit 0.103.13 → 0.104.1

package/dist/entrypoints/tools.js

@@ -1,55 +1,41 @@
 import {
   EffectUnresolvedError2,
   createLocalStepDurability2
-} from "../index-69nvze1q.js";
+} from "../index-pptyv13k.js";
 import {
   AppError2,
   STITCH_ERROR_STATUS2
-} from "../index-n53mswt3.js";
+} from "../index-x928baz2.js";
 import {
   AgentToolError2,
   isAgentToolError2
 } from "../index-nggfa2yn.js";
 import {
   normalizeError2
-} from "../index-b2bz0kdm.js";
-import {
-  resolvePropagationContext2
-} from "../index-yex7eg1v.js";
+} from "../index-kb8styz3.js";
+import"../index-yex7eg1v.js";
 import {
   coerceJsonArgs2
 } from "../index-9pw0a51a.js";
+import"../index-ct75c3at.js";
 import {
-  toJsonSchema
-} from "../index-ct75c3at.js";
-import {
-  toolSurfaceOutputSchema,
-  staticInputRounds,
-  validateMcpRoundPolicy,
-  validateResolvedInputRounds,
   assertToolName,
   assertUniqueToolName,
   PORTABLE_JSON_SCHEMA_FORMATS2,
   findNonPortableFormats2,
   flattenToolJsonSchema2,
-  presentationMetadata,
-  findUntypedProperties2,
-  prepareProjectedMcpTools
-} from "../index-x87j7csh.js";
+  findUntypedProperties2
+} from "../index-77nxk6ay.js";
 import {
-  parseToolCallArguments,
-  toolResultFromError,
   ToolExecutionControlError2,
   isToolExecutionControlError2
-} from "../index-m2xqkv55.js";
+} from "../index-2vnh05w4.js";
 import {
-  collectTools2,
-  createToolRunner,
-  formatToolError
-} from "../index-r956rndn.js";
+  collectTools2
+} from "../index-2hyavjjj.js";
 import {
   mountAgent2
-} from "../index-1khy8y7n.js";
+} from "../index-t1sr4aks.js";
 import"../index-m38ej7e5.js";
 import {
   ALL_TRANSPORTS2,
@@ -57,10 +43,29 @@ import {
   defineContract2
 } from "../index-ck71tbcf.js";
 import"../index-1bx1xv1k.js";
-import"../index-sznqf8fx.js";
 import {
-  redact2
-} from "../index-e6c2spsd.js";
+  PROTECTED_RESOURCE_PATH2,
+  protectedResourceMetadataUrl2,
+  wwwAuthenticateHeader2,
+  oauthProtectedResourceRoute2,
+  RESOURCE_MIME_TYPE2,
+  EXT_APPS_BUNDLE_PLACEHOLDER2,
+  inlineMcpAppBundle2,
+  MCP_CATALOG_META_KEY2,
+  mcpCatalogMeta2,
+  readMcpCatalogStamp2,
+  createMcpProgressReporter,
+  validateMcpSchemas2,
+  mountMcp2,
+  buildMcpServer2,
+  mountMcpResource2,
+  createMcpHandler2,
+  createMcpHttpRoute2,
+  createStdioMcpServer2,
+  bindStdioProcessSignals2
+} from "../index-bhb950qs.js";
+import"../index-sznqf8fx.js";
+import"../index-e6c2spsd.js";
 import {
   AsyncOperationCancelResultSchema2,
   createAsyncOperationSnapshotSchema2,
@@ -77,56 +82,45 @@ import {
   WaitTimeoutError,
   runWaitOperation,
   createCli2
-} from "../index-8zfsgar0.js";
+} from "../index-6drst9sg.js";
 import {
   ManagedFilePathSchema2,
   ManagedFileRefSchema2
 } from "../index-xqhede6x.js";
 import {
   ManagedFileError2
-} from "../index-sybedc8b.js";
+} from "../index-hbd32c6a.js";
 import {
   composeToolLifecycle2
 } from "../index-ze1eph1k.js";
 import {
   signJwt2,
   verifyPkce2
-} from "../index-45tdvqa3.js";
+} from "../index-wh0ecvyk.js";
 import {
-  DEFAULT_CORS_ALLOW_HEADERS2,
   contractOnlyService,
-  DEFAULT_PROCESS_SIGNALS,
-  defaultSignalSource,
-  reportSignalError,
-  guardSignalCallback,
   mediaTypeEssence
-} from "../index-afjvjyck.js";
+} from "../index-g2j7pnak.js";
 import {
   describeToolCatalog2,
   buildToolManifest2
-} from "../index-kmpzj1cq.js";
+} from "../index-a3wma1hk.js";
+import {
+  DEFAULT_CORS_ALLOW_HEADERS2
+} from "../index-yk4g8805.js";
 import {
   collectToolSurface
-} from "../index-dnn9z96q.js";
+} from "../index-a0zzh8ak.js";
 import {
-  argumentsDigest
-} from "../index-r7a7r7ha.js";
+  defineRuntimeTool2,
+  createRuntimeToolFactory2
+} from "../index-cvda079a.js";
 import {
   createToolInvoker2
-} from "../index-n2gre124.js";
+} from "../index-fa4wg312.js";
 import {
-  runWithRequestContext2,
-  getRequestContext2,
   getTraceId2
 } from "../index-7n68nmc6.js";
-import {
-  defineRuntimeTool2,
-  createRuntimeToolFactory2
-} from "../index-tgzhq07n.js";
-import {
-  compareCodeUnits,
-  serializeCanonicalJson
-} from "../index-zsvzhjtk.js";
 import {
   isRecord
 } from "../index-9jfdm5tg.js";
@@ -441,48 +435,9 @@ function isLoopbackRedirectUri(value) {
     return false;
   }
 }
-// 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}`;
-}
-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_HEADERS2
-};
-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/server/oauth/endpoints.ts
 import { randomUUID } from "node:crypto";
-var PUBLIC_CORS2 = {
+var PUBLIC_CORS = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
   "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS2
@@ -503,7 +458,7 @@ function parseScopes(value) {
 function json(body, status = 200, extraHeaders) {
   return new Response(JSON.stringify(body), {
     status,
-    headers: { "Content-Type": "application/json", ...PUBLIC_CORS2, ...extraHeaders }
+    headers: { "Content-Type": "application/json", ...PUBLIC_CORS, ...extraHeaders }
   });
 }
 function oauthError(error, description, status = 400) {
@@ -537,7 +492,7 @@ function metadataRoute(ctx) {
     path: AS_METADATA_PATH,
     handler: (req) => {
       if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+        return new Response(null, { status: 204, headers: PUBLIC_CORS });
       return json({
         issuer: config.issuer,
         authorization_endpoint: `${config.issuer}${ctx.paths.authorize}`,
@@ -563,7 +518,7 @@ function registerRoute(ctx) {
     path: ctx.paths.register,
     handler: async (req) => {
       if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+        return new Response(null, { status: 204, headers: PUBLIC_CORS });
       if (req.method !== "POST")
         return oauthError("invalid_request", "POST required", 405);
       const meta = await req.json().catch(() => null);
@@ -610,7 +565,7 @@ function authorizeRoute(ctx) {
     path: ctx.paths.authorize,
     handler: async (req) => {
       if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+        return new Response(null, { status: 204, headers: PUBLIC_CORS });
       const url = new URL(req.url);
       const p = url.searchParams;
       const clientId = p.get("client_id");
@@ -717,7 +672,7 @@ function tokenRoute(ctx) {
     path: ctx.paths.token,
     handler: async (req) => {
       if (req.method === "OPTIONS")
-        return new Response(null, { status: 204, headers: PUBLIC_CORS2 });
+        return new Response(null, { status: 204, headers: PUBLIC_CORS });
       if (req.method !== "POST")
         return oauthError("invalid_request", "POST required", 405);
       const form = await readForm(req);
@@ -873,1028 +828,8 @@ function listToolNames(surface) {
 function listContractToolNames(contracts) {
   return listToolNames({ services: contracts.map(contractOnlyService) });
 }
-// src/tools/mcp/app.ts
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-var RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
-var EXT_APPS_BUNDLE_PLACEHOLDER = "/*__EXT_APPS_BUNDLE__*/";
-function inlineMcpAppBundle(html) {
-  if (!html.includes(EXT_APPS_BUNDLE_PLACEHOLDER))
-    return html;
-  let bundlePath;
-  try {
-    bundlePath = fileURLToPath(import.meta.resolve("@modelcontextprotocol/ext-apps/app-with-deps"));
-  } catch {
-    throw new Error("[stitchkit] inlineMcpAppBundle: '@modelcontextprotocol/ext-apps' is not installed. " + "Add it as a dependency to serve MCP App widgets.");
-  }
-  const bundle = readFileSync(bundlePath, "utf8").replace(/export\{([^}]+)\};?\s*$/, (_match, body) => `globalThis.ExtApps={${body.split(",").map((pair) => {
-    const [local, exported] = pair.split(" as ").map((s) => s.trim());
-    return `${exported ?? local}:${local}`;
-  }).join(",")}};`);
-  return html.replace(EXT_APPS_BUNDLE_PLACEHOLDER, () => bundle);
-}
-// src/tools/mcp/catalog.ts
-import { createHash } from "node:crypto";
-var MCP_CATALOG_META_KEY = "stitchkit/catalog";
-var stampCache = new WeakMap;
-function toolFingerprint(descriptor) {
-  const { mountable } = descriptor;
-  return {
-    name: mountable.name,
-    description: mountable.method.desc,
-    input: descriptor.inputSchema,
-    output: descriptor.outputSchema ? toJsonSchema(descriptor.outputSchema, "output", "any") : null,
-    annotations: mountable.method.annotations ?? null
-  };
-}
-function mcpCatalogStamp(surface) {
-  const cached = stampCache.get(surface);
-  if (cached)
-    return cached;
-  const descriptors = [
-    ...surface.contractTools,
-    ...surface.runtimeTools.map((entry) => entry.descriptor)
-  ].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),
-    tools: descriptors.length
-  };
-  stampCache.set(surface, stamp);
-  return stamp;
-}
-function mcpCatalogMeta(stamp) {
-  return { [MCP_CATALOG_META_KEY]: { ...stamp } };
-}
-function readMcpCatalogStamp(meta) {
-  if (!isRecord(meta))
-    return null;
-  const value = meta[MCP_CATALOG_META_KEY];
-  if (!isRecord(value))
-    return null;
-  const { digest, tools } = value;
-  if (typeof digest !== "string" || digest.length === 0)
-    return null;
-  if (typeof tools !== "number" || !Number.isInteger(tools) || tools < 0)
-    return null;
-  return { digest, tools };
-}
-function stampToolRegistration(config, stamp) {
-  if (!stamp)
-    return config;
-  return { ...config, _meta: { ...config._meta, ...mcpCatalogMeta(stamp) } };
-}
-function stampToolResult(result, stamp) {
-  if (!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
-function textBlock(text) {
-  return [{ type: "text", text }];
-}
-function formatMcpResult(result, mode, toolName, errorHint) {
-  if (result.ok) {
-    if (mode === "none")
-      return { content: [] };
-    let serialized;
-    try {
-      serialized = JSON.stringify(result.data, null, 2);
-    } catch {
-      serialized = undefined;
-    }
-    if (serialized === undefined) {
-      const safe = redact2(result.data, { sensitiveKeys: /(?!)/ });
-      return { content: textBlock(JSON.stringify(safe, null, 2)), structuredContent: safe };
-    }
-    return { content: textBlock(serialized), structuredContent: result.data };
-  }
-  return {
-    content: textBlock(JSON.stringify(formatToolError(result, toolName, errorHint), null, 2)),
-    isError: true
-  };
-}
-function prepareMcpSurface(services, config = {}) {
-  const serviceList = Array.isArray(services) ? services : [services];
-  const tools = serviceList.flatMap((service) => collectTools2(service, "MCP", config));
-  return prepareMcpTools(tools, config);
-}
-function prepareMcpTools(tools, config = {}) {
-  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,
-      inputSchema: entry.inputSchema,
-      ...entry.outputSchema !== undefined && { outputSchema: entry.outputSchema },
-      outputMode: entry.outputSchema === undefined ? "none" : "direct"
-    });
-  });
-  return Object.freeze(prepared);
-}
-function prepareMcpServerSurface(surface, config = {}) {
-  const contractMountables = [];
-  const definitions = [];
-  const runtimeMountables = [];
-  for (const entry of collectToolSurface({
-    surface,
-    transport: "MCP",
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput
-  })) {
-    if (entry.kind === "contract") {
-      contractMountables.push(entry.mountable);
-    } else {
-      definitions.push(entry.definition);
-      runtimeMountables.push(entry.mountable);
-    }
-  }
-  const contractTools = prepareMcpTools(contractMountables, config);
-  const runtimeDescriptors = prepareMcpTools(runtimeMountables, {
-    schemaValidation: config.schemaValidation,
-    logger: config.logger,
-    multiRound: config.multiRound
-  });
-  const descriptorsByName = new Map(runtimeDescriptors.map((descriptor) => [descriptor.mountable.name, descriptor]));
-  const runtimeTools = [];
-  for (const definition of definitions) {
-    const descriptor = descriptorsByName.get(definition.name);
-    if (descriptor)
-      runtimeTools.push(Object.freeze({ definition, descriptor }));
-  }
-  return Object.freeze({ contractTools, runtimeTools: Object.freeze(runtimeTools) });
-}
-
-// src/tools/mcp/register.ts
-import {
-  isCallToolResult
-} from "@modelcontextprotocol/server";
-import { z as z3 } from "zod";
-
-// src/tools/mcp/round.ts
-import {
-  acceptedContent,
-  inputRequired,
-  inputResponse
-} from "@modelcontextprotocol/server";
-import { z as z2 } from "zod";
-
-// src/tools/mcp/round-context.ts
-import {
-  CLIENT_INFO_META_KEY,
-  PROTOCOL_VERSION_META_KEY
-} from "@modelcontextprotocol/server";
-
-// src/tools/mcp/progress.ts
-function mcpProgressToken(context) {
-  const token = context.mcpReq._meta?.progressToken;
-  return typeof token === "string" || typeof token === "number" ? token : undefined;
-}
-function createMcpProgressReporter(context) {
-  const token = mcpProgressToken(context);
-  if (token === undefined)
-    return async () => {
-      return;
-    };
-  let sent = 0;
-  let highWater = 0;
-  return async (update) => {
-    sent += 1;
-    const value = update.progress ?? Math.max(sent, highWater + 1);
-    highWater = Math.max(highWater, value);
-    try {
-      await context.mcpReq.notify({
-        method: "notifications/progress",
-        params: {
-          progressToken: token,
-          progress: value,
-          ...update.total !== undefined && { total: update.total },
-          ...update.message !== undefined && { message: update.message }
-        }
-      });
-    } catch {}
-  };
-}
-
-// src/tools/mcp/round-context.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;
-  const clientInfoValue = isRecord(context.mcpReq.envelope) ? Reflect.get(context.mcpReq.envelope, CLIENT_INFO_META_KEY) : undefined;
-  const clientInfo = isRecord(clientInfoValue) && typeof clientInfoValue.name === "string" && typeof clientInfoValue.version === "string" ? { name: clientInfoValue.name, version: clientInfoValue.version } : undefined;
-  const token = mcpProgressToken(context);
-  return {
-    signal: context.mcpReq.signal,
-    mcp: {
-      era: context.mcpReq.envelope ? "modern" : "legacy",
-      method: context.mcpReq.method,
-      toolName,
-      ...protocolVersion !== undefined && { protocolVersion },
-      ...clientInfo !== undefined && { clientInfo },
-      ...outcome !== undefined && { outcome },
-      ...round !== undefined && { round },
-      ...token !== undefined && { progressToken: token }
-    },
-    reportProgress: createMcpProgressReporter(context)
-  };
-}
-function operationIdentity(tool) {
-  return {
-    toolName: tool.name,
-    serviceName: tool.method.serviceName,
-    action: tool.method.key,
-    method: tool.method.method,
-    ...tool.method.scope !== undefined && { scope: tool.method.scope }
-  };
-}
-function sameIdentity(left, right) {
-  return left.toolName === right.toolName && left.serviceName === right.serviceName && left.action === right.action && left.method === right.method && left.scope === right.scope;
-}
-async function runRoundSuccess(tool, rawArgs, runTool, context) {
-  return runTool({
-    ...tool,
-    method: {
-      ...tool.method,
-      outputSchema: undefined,
-      handler: () => {
-        return;
-      }
-    }
-  }, rawArgs, context);
-}
-async function runRoundFailure(tool, rawArgs, runTool, context, code, message) {
-  return runTool({
-    ...tool,
-    method: {
-      ...tool.method,
-      outputSchema: undefined,
-      handler: () => {
-        throw new AppError2(code, message, 400);
-      }
-    }
-  }, rawArgs, context);
-}
-async function failedResolution(options) {
-  const result = await runRoundFailure(options.tool, options.rawArgs, options.runTool, options.context, options.code, options.message);
-  return { kind: "response", response: options.formatFailure(result) };
-}
-
-// src/tools/mcp/round.ts
-function roundPlanDigest(requests) {
-  return argumentsDigest({
-    plan: requests.map((request) => ({
-      key: request.key,
-      message: request.message,
-      schema: z2.toJSONSchema(request.schema, { io: "input", unrepresentable: "any" })
-    }))
-  });
-}
-async function resolveRequests(options, policy) {
-  const declared = staticInputRounds(policy);
-  if (declared)
-    return { requests: declared, guarded: false };
-  const parsed = parseToolCallArguments(options.tool.method, options.rawArgs, {
-    coerceJson: options.coerceJsonArgs ?? true,
-    toolSurface: true
-  });
-  if (!parsed.ok) {
-    return { requests: [], guarded: false };
-  }
-  const resolver = policy.inputRequired;
-  const resolved = await resolver({ params: parsed.params, input: parsed.input });
-  validateResolvedInputRounds(options.tool, resolved, options.runtime?.maxRounds ?? 1);
-  return { requests: resolved, guarded: false };
-}
-async function askRound(runtime, context, request, state) {
-  const requestState = await runtime.codec.mint(state, context);
-  return {
-    kind: "response",
-    response: inputRequired({
-      inputRequests: {
-        [request.key]: inputRequired.elicit({
-          message: request.message,
-          requestedSchema: request.schema
-        })
-      },
-      requestState
-    })
-  };
-}
-function readRoundAnswer(context, request) {
-  const view = inputResponse(context.mcpReq.inputResponses, request.key);
-  if (view.kind !== "elicit") {
-    return {
-      refusal: {
-        outcome: "invalid",
-        code: "INVALID_INPUT_RESPONSE",
-        message: "Expected an elicitation response for the current round"
-      }
-    };
-  }
-  if (view.action !== "accept") {
-    const declined = view.action === "decline";
-    return {
-      refusal: {
-        outcome: declined ? "declined" : "cancelled",
-        code: declined ? "INPUT_DECLINED" : "INPUT_CANCELLED",
-        message: declined ? "Required input was declined" : "Required input was cancelled"
-      }
-    };
-  }
-  const content = acceptedContent(context.mcpReq.inputResponses, request.key, request.schema);
-  if (!content) {
-    return {
-      refusal: {
-        outcome: "invalid",
-        code: "INVALID_INPUT_RESPONSE",
-        message: "Accepted input failed its declared schema"
-      }
-    };
-  }
-  return { content };
-}
-async function resolveMcpRound(options) {
-  const { policy } = options;
-  if (!policy) {
-    return {
-      kind: "continue",
-      context: transportContext(options.context, options.tool.name)
-    };
-  }
-  if (!options.runtime) {
-    throw new Error(`[stitchkit] MCP tool "${options.tool.name}" declares inputRequired but no multiRound.state key is configured`);
-  }
-  validateMcpRoundPolicy(options.tool, policy, {
-    stateConfigured: true,
-    maxRounds: options.runtime.maxRounds
-  });
-  const state = options.context.mcpReq.requestState();
-  const digest = argumentsDigest(options.rawArgs);
-  if (state) {
-    const mismatched = !sameIdentity(state.identity, operationIdentity(options.tool)) || state.argumentsDigest !== digest || !Number.isInteger(state.round) || state.round < 0 || state.round >= options.runtime.maxRounds || !isRecord(state.accepted);
-    if (mismatched) {
-      return failedResolution({
-        ...options,
-        context: transportContext(options.context, options.tool.name, "invalid", Number.isInteger(state.round) ? state.round : 0),
-        code: "INVALID_REQUEST_STATE",
-        message: "Continuation state does not match this operation, arguments or round"
-      });
-    }
-  }
-  const dynamic = staticInputRounds(policy) === undefined;
-  if (dynamic) {
-    const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", state?.round ?? 0));
-    if (!guarded.ok)
-      return { kind: "response", response: options.formatFailure(guarded) };
-  }
-  const resolution = await resolveRequests(options, policy);
-  if ("failure" in resolution)
-    return resolution.failure;
-  const requests = resolution.requests;
-  const alreadyGuarded = dynamic;
-  const planDigest = roundPlanDigest(requests);
-  if (requests.length === 0 && !state) {
-    return {
-      kind: "continue",
-      context: transportContext(options.context, options.tool.name)
-    };
-  }
-  if (!state) {
-    if (isRecord(options.context.mcpReq.inputResponses)) {
-      return failedResolution({
-        ...options,
-        context: transportContext(options.context, options.tool.name, "invalid", 0),
-        code: "INVALID_REQUEST_STATE",
-        message: "Input responses require a valid continuation state"
-      });
-    }
-    if (!alreadyGuarded) {
-      const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", 0));
-      if (!guarded.ok) {
-        return { kind: "response", response: options.formatFailure(guarded) };
-      }
-    }
-    const request = requests[0];
-    if (!request)
-      throw new Error("[stitchkit] validated MRTR policy has no first round");
-    return askRound(options.runtime, options.context, request, {
-      identity: operationIdentity(options.tool),
-      argumentsDigest: digest,
-      round: 0,
-      accepted: {},
-      planDigest
-    });
-  }
-  if (state.planDigest !== planDigest || state.round >= requests.length) {
-    return failedResolution({
-      ...options,
-      context: transportContext(options.context, options.tool.name, "invalid", state.round),
-      code: "INVALID_REQUEST_STATE",
-      message: state.round >= requests.length ? "Continuation state does not match this operation, arguments or round" : "The questions for this call changed between rounds"
-    });
-  }
-  const request = requests[state.round];
-  if (!request)
-    throw new Error("[stitchkit] validated MRTR state points outside its policy");
-  const answer = readRoundAnswer(options.context, request);
-  if ("refusal" in answer) {
-    return failedResolution({
-      ...options,
-      context: transportContext(options.context, options.tool.name, answer.refusal.outcome, state.round),
-      code: answer.refusal.code,
-      message: answer.refusal.message
-    });
-  }
-  const { content } = answer;
-  const accepted = { ...state.accepted, [request.key]: content };
-  const nextRound = state.round + 1;
-  const nextRequest = requests[nextRound];
-  if (nextRequest) {
-    if (!alreadyGuarded) {
-      const guarded = await runRoundSuccess(options.tool, options.rawArgs, options.runTool, transportContext(options.context, options.tool.name, "input_required", nextRound));
-      if (!guarded.ok) {
-        return { kind: "response", response: options.formatFailure(guarded) };
-      }
-    }
-    return askRound(options.runtime, options.context, nextRequest, {
-      identity: state.identity,
-      argumentsDigest: state.argumentsDigest,
-      round: nextRound,
-      accepted,
-      planDigest
-    });
-  }
-  return {
-    kind: "continue",
-    context: {
-      ...transportContext(options.context, options.tool.name, "complete", state.round),
-      mcpInput: accepted
-    }
-  };
-}
-
-// src/tools/mcp/trace.ts
-import {
-  BAGGAGE_META_KEY,
-  TRACEPARENT_META_KEY,
-  TRACESTATE_META_KEY
-} from "@modelcontextprotocol/server";
-function runInMcpRequestContext(context, toolName, body) {
-  const ambient = getRequestContext2();
-  const metadata = context.mcpReq._meta;
-  const propagation = metadata ? {
-    traceparent: metadata[TRACEPARENT_META_KEY],
-    tracestate: metadata[TRACESTATE_META_KEY],
-    baggage: metadata[BAGGAGE_META_KEY]
-  } : undefined;
-  const request = {
-    ...ambient ?? {
-      source: "mcp",
-      method: "MCP",
-      path: `/mcp/${toolName}`,
-      startedAt: process.hrtime.bigint()
-    },
-    trace: resolvePropagationContext2(propagation, ambient?.trace),
-    source: "mcp",
-    method: "MCP",
-    path: `/mcp/${toolName}`,
-    startedAt: process.hrtime.bigint(),
-    dimensions: ambient?.dimensions ? { ...ambient.dimensions } : undefined,
-    error: undefined
-  };
-  return runWithRequestContext2(request, body);
-}
-
-// 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
-    };
-  }
-  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: config.runTool,
-        formatFailure: (result) => format(result, "none", name)
-      });
-      if (round.kind === "response")
-        return round.response;
-      const { present } = presentation;
-      if (!present) {
-        const result = await config.runTool(mountable, args, round.context);
-        return format(result, descriptor.outputMode, name);
-      }
-      const result = await config.runTool(mountable, args, round.context, {
-        finalizeOutput: async (data) => {
-          const presented = await present(data);
-          if (!isRecord(presented)) {
-            throw new AppError2("INTERNAL_SERVER_ERROR", "Runtime MCP presenter did not return a result", 500);
-          }
-          if ("structuredContent" in presented || "isError" in presented) {
-            throw new AppError2("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 AppError2("INTERNAL_SERVER_ERROR", "Runtime MCP presenter returned an invalid CallToolResult", 500);
-          }
-          return response;
-        }
-      });
-      if (!result.ok)
-        return format(result, "none", name);
-      if (!isCallToolResult(result.data)) {
-        throw new Error("[stitchkit] Runtime MCP presenter invariant failed");
-      }
-      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/mount.ts
-function validateMcpSchemas(config) {
-  prepareMcpSurface(config.services, {
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput,
-    schemaValidation: config,
-    logger: config.logger
-  });
-}
-function mountMcp(mcpServer, services, config = {}) {
-  const prepared = prepareMcpSurface(services, {
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput,
-    schemaValidation: config.schemaValidation,
-    logger: config.logger
-  });
-  mountPreparedMcp(mcpServer, prepared, {
-    ...config,
-    catalog: mcpCatalogStamp({ contractTools: prepared, runtimeTools: [] })
-  });
-}
-function mountPreparedMcp(mcpServer, prepared, config = {}) {
-  const runTool = createToolRunner({
-    source: "mcp",
-    toolSurface: true,
-    extend: config.extend,
-    context: config.context,
-    hooks: config.hooks,
-    lifecycle: config.lifecycle,
-    coerceJsonArgs: config.coerceJsonArgs,
-    onOutputStrip: config.onOutputStrip
-  });
-  for (const descriptor of prepared) {
-    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) {
-  if (!isMcpServerBuildConfig(config)) {
-    throw new TypeError("[stitchkit] buildMcpServer requires a valid config object");
-  }
-  let surface;
-  if (config.surfaces) {
-    const key = config.selectSurface(auth);
-    if (!Object.hasOwn(config.surfaces, key)) {
-      throw new Error(`[stitchkit] Unknown MCP surface "${key}"`);
-    }
-    const selected = config.surfaces[key];
-    if (!selected)
-      throw new Error(`[stitchkit] Unknown MCP surface "${key}"`);
-    surface = selected;
-  } else {
-    const services = typeof config.services === "function" ? config.services(auth) : config.services;
-    const runtimeTools = typeof config.runtimeTools === "function" ? config.runtimeTools(auth) : config.runtimeTools;
-    surface = { services, runtimeTools };
-  }
-  const prepared = prepareMcpServerSurface(surface, {
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput,
-    schemaValidation: config.schemaValidation,
-    logger: config.logger,
-    multiRound: {
-      stateConfigured: config.multiRound !== undefined,
-      maxRounds: config.multiRound?.serving?.maxRounds ?? 10
-    }
-  });
-  return buildMcpServerFromPrepared(config, auth, prepared);
-}
-function isMcpServerBuildConfig(value) {
-  return isRecord(value) && isRecord(value.serverInfo);
-}
-function buildMcpServerFromPrepared(config, auth, prepared) {
-  let roundCodec;
-  if (config.multiRound) {
-    const principal = config.multiRound.state.principal(auth);
-    roundCodec = createRequestStateCodec({
-      key: config.multiRound.state.key,
-      ttlSeconds: config.multiRound.state.ttlSeconds,
-      bind: (mcpContext) => `${mcpContext.mcpReq.method}\x00${principal}`
-    });
-  }
-  const dynamicSurface = !config.surfaces && (typeof config.services === "function" || typeof config.runtimeTools === "function");
-  const serverOptions = {
-    ...config.instructions !== undefined && { instructions: config.instructions },
-    ...!dynamicSurface && config.cache?.operations !== undefined && {
-      cacheHints: config.cache.operations
-    },
-    ...config.multiRound?.serving !== undefined && {
-      inputRequired: config.multiRound.serving
-    },
-    ...roundCodec !== undefined && {
-      requestState: { verify: roundCodec.verify }
-    }
-  };
-  const server = new McpServer(config.serverInfo, serverOptions);
-  const context = config.context?.(auth);
-  const catalog = mcpCatalogStamp(prepared);
-  mountPreparedMcp(server, prepared.contractTools, {
-    catalog,
-    context,
-    hooks: config.hooks,
-    lifecycle: config.lifecycle,
-    extend: config.extend,
-    schemaValidation: config.schemaValidation,
-    logger: config.logger,
-    coerceJsonArgs: config.coerceJsonArgs,
-    flattenUnionInput: config.flattenUnionInput,
-    errorHint: config.errorHint,
-    onOutputStrip: config.onOutputStrip,
-    ...roundCodec !== undefined && {
-      multiRoundRuntime: {
-        codec: roundCodec,
-        maxRounds: config.multiRound?.serving?.maxRounds ?? 10
-      }
-    }
-  });
-  mountPreparedRuntimeMcp(server, prepared.runtimeTools, {
-    catalog,
-    context,
-    hooks: config.hooks,
-    lifecycle: config.lifecycle,
-    coerceJsonArgs: config.coerceJsonArgs,
-    onOutputStrip: config.onOutputStrip,
-    formatResult: (result, mode, toolName) => formatMcpResult(result, mode, toolName, config.errorHint),
-    ...roundCodec !== undefined && {
-      multiRoundRuntime: {
-        codec: roundCodec,
-        maxRounds: config.multiRound?.serving?.maxRounds ?? 10
-      }
-    }
-  });
-  config.rawTools?.(server, auth);
-  for (const resource of config.resources ?? []) {
-    mountMcpResource(server, resource);
-  }
-  return server;
-}
-function mountMcpResource(server, resource) {
-  server.registerResource(resource.name, resource.uri, {
-    mimeType: resource.mimeType ?? RESOURCE_MIME_TYPE,
-    ...resource.cacheHint !== undefined && { cacheHint: resource.cacheHint }
-  }, async () => ({
-    contents: [
-      {
-        uri: resource.uri,
-        mimeType: resource.mimeType ?? RESOURCE_MIME_TYPE,
-        text: await resource.read(),
-        ...resource.ui && { _meta: { ui: resource.ui } }
-      }
-    ]
-  }));
-}
-
-// src/tools/mcp/handler.ts
-function jsonRpcError(code, message, status, headers) {
-  return Response.json({ jsonrpc: "2.0", error: { code, message }, id: null }, { status, headers });
-}
-function hostValidationResponse(request, allowedHosts) {
-  if (request.headers.has("host")) {
-    return hostHeaderValidationResponse(request, [...allowedHosts]);
-  }
-  const hostname = new URL(request.url).hostname;
-  if (allowedHosts.includes(hostname))
-    return;
-  return jsonRpcError(-32000, "Invalid Host header", 403);
-}
-function prepareStaticSurface(config) {
-  const preparation = {
-    logger: config.logger,
-    extend: config.extend,
-    flattenUnionInput: config.flattenUnionInput,
-    schemaValidation: config.schemaValidation,
-    multiRound: {
-      stateConfigured: config.multiRound !== undefined,
-      maxRounds: config.multiRound?.serving?.maxRounds ?? 10
-    }
-  };
-  if (config.surfaces && config.selectSurface) {
-    const preparedByKey = new Map;
-    const preparedBySurface = new WeakMap;
-    for (const key in config.surfaces) {
-      if (!Object.hasOwn(config.surfaces, key))
-        continue;
-      const surface = config.surfaces[key];
-      if (!surface)
-        continue;
-      const existing = preparedBySurface.get(surface);
-      const prepared = existing ?? prepareMcpServerSurface(surface, preparation);
-      if (!existing)
-        preparedBySurface.set(surface, prepared);
-      preparedByKey.set(key, prepared);
-    }
-    return (auth) => {
-      const key = config.selectSurface(auth);
-      const prepared = preparedByKey.get(key);
-      if (!prepared)
-        throw new Error(`[stitchkit] Unknown MCP surface "${key}"`);
-      return buildMcpServerFromPrepared(config, auth, prepared);
-    };
-  }
-  if (config.services && typeof config.services !== "function" && typeof config.runtimeTools !== "function") {
-    const prepared = prepareMcpServerSurface({ services: config.services, runtimeTools: config.runtimeTools }, preparation);
-    return (auth) => buildMcpServerFromPrepared(config, auth, prepared);
-  }
-  return null;
-}
-function createMcpHandler(config) {
-  const buildPrepared = prepareStaticSurface(config);
-  const authByCarrier = new WeakMap;
-  let closed = false;
-  let resolveClosed;
-  const closedSignal = new Promise((resolve) => {
-    resolveClosed = resolve;
-  });
-  const sdkHandler = createSdkMcpHandler(({ authInfo }) => {
-    const resolved = authInfo ? authByCarrier.get(authInfo) : undefined;
-    if (!resolved) {
-      throw new Error("[stitchkit] MCP request reached the SDK without resolved auth");
-    }
-    const auth = resolved.value;
-    return buildPrepared ? buildPrepared(auth) : buildMcpServer(config, auth);
-  }, {
-    legacy: config.legacy === "reject" ? "reject" : "stateless",
-    maxSubscriptions: 0
-  });
-  const unauthorized = () => {
-    const headers = config.protectedResource ? { "WWW-Authenticate": wwwAuthenticateHeader(config.protectedResource.resource) } : undefined;
-    return jsonRpcError(-32001, "Authorization required", 401, headers);
-  };
-  const observeRejection = (request, response) => {
-    if (response.status < 400 || !config.onTransportRejected)
-      return response;
-    Promise.resolve(config.onTransportRejected({ request, response: response.clone() })).catch(() => {
-      return;
-    });
-    return response;
-  };
-  return {
-    fetch: async (request) => {
-      if (closed) {
-        return observeRejection(request, jsonRpcError(-32000, "MCP handler is closed", 503));
-      }
-      const allowedHosts = config.security?.allowedHosts ?? localhostAllowedHostnames();
-      const hostRejection = hostValidationResponse(request, allowedHosts);
-      if (hostRejection)
-        return observeRejection(request, hostRejection);
-      const allowedOrigins = config.security?.allowedOrigins ?? localhostAllowedOrigins();
-      const originRejection = originValidationResponse(request, [...allowedOrigins]);
-      if (originRejection)
-        return observeRejection(request, originRejection);
-      const auth = await Promise.race([
-        Promise.resolve(config.auth(request)),
-        closedSignal.then(() => null)
-      ]);
-      if (closed) {
-        return observeRejection(request, jsonRpcError(-32000, "MCP handler is closed", 503));
-      }
-      if (auth == null)
-        return observeRejection(request, unauthorized());
-      const authCarrier = {
-        token: "",
-        clientId: config.multiRound?.state.principal(auth) ?? "stitchkit",
-        scopes: []
-      };
-      authByCarrier.set(authCarrier, { value: auth });
-      try {
-        return observeRejection(request, await sdkHandler.fetch(request, { authInfo: authCarrier }));
-      } finally {
-        authByCarrier.delete(authCarrier);
-      }
-    },
-    close: async () => {
-      if (closed)
-        return;
-      closed = true;
-      resolveClosed?.();
-      await sdkHandler.close();
-    }
-  };
-}
-function createMcpHttpRoute(config) {
-  return {
-    method: "ALL",
-    path: config.path,
-    handler: (request) => config.handler.fetch(request)
-  };
-}
-// src/tools/mcp/stdio.ts
-import { serveStdio } from "@modelcontextprotocol/server/stdio";
-async function createStdioMcpServer(config) {
-  const auth = await config.auth;
-  return serveStdio(() => buildMcpServer(config, auth), {
-    legacy: config.legacy ?? "serve",
-    maxSubscriptions: 0
-  });
-}
-// src/tools/mcp/stdio-signals.ts
-var bound = new WeakSet;
-function bindStdioProcessSignals(handle, options = {}) {
-  if (bound.has(handle)) {
-    throw new Error("[stitchkit] bindStdioProcessSignals: this stdio handle is already bound; close the first binding before creating another");
-  }
-  bound.add(handle);
-  const signals = [...new Set(options.signals ?? DEFAULT_PROCESS_SIGNALS)];
-  const source = options.signalSource ?? defaultSignalSource;
-  const handlers = [];
-  let started = false;
-  let sameTurnAsStart = false;
-  let closed = false;
-  let resolveChain = () => {
-    return;
-  };
-  let rejectChain = () => {
-    return;
-  };
-  const promise = new Promise((resolve, reject) => {
-    resolveChain = resolve;
-    rejectChain = reject;
-  });
-  promise.catch(() => {
-    return;
-  });
-  const removeListeners = () => {
-    if (closed)
-      return;
-    closed = true;
-    for (const [signal, handler] of handlers)
-      source.off(signal, handler);
-    if (!started)
-      bound.delete(handle);
-  };
-  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";
+import { z as z2 } from "zod";
 function adapterResult(capability, target, schema, value) {
   const parsed = schema.safeParse(value);
   if (!parsed.success) {
@@ -1923,7 +858,7 @@ function assertWireStableIdSchema(schema, boundary) {
     if (typeof value !== "object" || value === null || visited.has(value))
       continue;
     visited.add(value);
-    if (value instanceof z4.ZodType) {
+    if (value instanceof z2.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`);
@@ -2303,7 +1238,7 @@ function defineAsyncOperation(config) {
   };
 }
 // src/tools/operations/mount-wait.ts
-import { z as z5 } from "zod";
+import { z as z3 } from "zod";
 
 // src/tools/transfer/native-result.ts
 function textResult(text, isError = false) {
@@ -2315,7 +1250,7 @@ function textResult(text, isError = false) {
 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) => {
+  server.registerTool(name, { description: config.description, inputSchema: z3.object(config.inputSchema) }, async (rawArgs, mcpContext) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
     const report = createMcpProgressReporter(mcpContext);
     let last;
@@ -2426,11 +1361,11 @@ function createToolLogger(config = {}) {
 // src/tools/toolkit.ts
 function createToolkit() {
   return {
-    mountMcp: (server, services, config) => mountMcp(server, services, config),
+    mountMcp: (server, services, config) => mountMcp2(server, services, config),
     mountAgent: (services, config) => mountAgent2(services, config),
-    buildMcpServer: (config, auth) => buildMcpServer(config, auth),
-    createMcpHandler: (config) => createMcpHandler(config),
-    createStdioMcpServer: (config) => createStdioMcpServer(config),
+    buildMcpServer: (config, auth) => buildMcpServer2(config, auth),
+    createMcpHandler: (config) => createMcpHandler2(config),
+    createStdioMcpServer: (config) => createStdioMcpServer2(config),
     createCli: (config) => createCli2(config)
   };
 }
@@ -2578,7 +1513,7 @@ function defineDownloadTool(config) {
   });
 }
 // src/tools/transfer/define-upload-tool.ts
-import { z as z6 } from "zod";
+import { z as z4 } from "zod";
 
 // src/tools/transfer/upload-core.ts
 function runUploadOperation(files, path, upload, signal) {
@@ -2587,7 +1522,7 @@ function runUploadOperation(files, path, upload, signal) {
 }
 
 // src/tools/transfer/define-upload-tool.ts
-var UploadToolInputSchema = z6.object({
+var UploadToolInputSchema = z4.object({
   path: ManagedFilePathSchema2.describe("Path relative to the configured file boundary")
 });
 function defineUploadTool(config) {
@@ -2818,11 +1753,11 @@ function defineViewFileTool(config) {
   });
 }
 // src/tools/transfer/mount-download.ts
-import { z as z7 } from "zod";
+import { z as z5 } 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) => {
+  server.registerTool(name, { description: config.description, inputSchema: z5.object(config.inputSchema) }, async (rawArgs) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
     try {
       const url = await config.resolveUrl(args);
@@ -2937,33 +1872,33 @@ function summarizeTransports(surface) {
 export {
   AgentToolError2 as AgentToolError,
   AsyncOperationCancelResultSchema2 as AsyncOperationCancelResultSchema,
-  EXT_APPS_BUNDLE_PLACEHOLDER,
+  EXT_APPS_BUNDLE_PLACEHOLDER2 as EXT_APPS_BUNDLE_PLACEHOLDER,
   EffectUnresolvedError2 as EffectUnresolvedError,
-  MCP_CATALOG_META_KEY,
+  MCP_CATALOG_META_KEY2 as MCP_CATALOG_META_KEY,
   McpAnnotationsSchema2 as McpAnnotationsSchema,
   McpMediaContentSchema2 as McpMediaContentSchema,
   PORTABLE_JSON_SCHEMA_FORMATS2 as PORTABLE_JSON_SCHEMA_FORMATS,
-  PROTECTED_RESOURCE_PATH,
-  RESOURCE_MIME_TYPE,
+  PROTECTED_RESOURCE_PATH2 as PROTECTED_RESOURCE_PATH,
+  RESOURCE_MIME_TYPE2 as RESOURCE_MIME_TYPE,
   ToolExecutionControlError2 as ToolExecutionControlError,
   UploadToolInputSchema,
   ViewFileErrorSchema2 as ViewFileErrorSchema,
   ViewFileInputSchema2 as ViewFileInputSchema,
   ViewFileOutputSchema2 as ViewFileOutputSchema,
   bindContractAsyncOperation,
-  bindStdioProcessSignals,
-  buildMcpServer,
+  bindStdioProcessSignals2 as bindStdioProcessSignals,
+  buildMcpServer2 as buildMcpServer,
   buildToolManifest2 as buildToolManifest,
   coerceJsonArgs2 as coerceJsonArgs,
   collectTools2 as collectTools,
   composeToolLifecycle2 as composeToolLifecycle,
   createAsyncOperationSnapshotSchema2 as createAsyncOperationSnapshotSchema,
   createLocalStepDurability2 as createLocalStepDurability,
-  createMcpHandler,
-  createMcpHttpRoute,
+  createMcpHandler2 as createMcpHandler,
+  createMcpHttpRoute2 as createMcpHttpRoute,
   createRuntimeToolFactory2 as createRuntimeToolFactory,
   createSecureClientMetadataFetcher,
-  createStdioMcpServer,
+  createStdioMcpServer2 as createStdioMcpServer,
   createToolInvoker2 as createToolInvoker,
   createToolLogger,
   createToolkit,
@@ -2979,25 +1914,25 @@ export {
   findNonPortableFormats2 as findNonPortableFormats,
   findUntypedProperties2 as findUntypedProperties,
   flattenToolJsonSchema2 as flattenToolJsonSchema,
-  inlineMcpAppBundle,
+  inlineMcpAppBundle2 as inlineMcpAppBundle,
   isAgentToolError2 as isAgentToolError,
   isToolExecutionControlError2 as isToolExecutionControlError,
   listContractToolNames,
   listToolNames,
-  mcpCatalogMeta,
+  mcpCatalogMeta2 as mcpCatalogMeta,
   mountAgent2 as mountAgent,
   mountDownload,
-  mountMcp,
-  mountMcpResource,
+  mountMcp2 as mountMcp,
+  mountMcpResource2 as mountMcpResource,
   mountOAuthProvider,
   mountUpload,
   mountViewFile,
   mountWait,
-  oauthProtectedResourceRoute,
-  protectedResourceMetadataUrl,
-  readMcpCatalogStamp,
+  oauthProtectedResourceRoute2 as oauthProtectedResourceRoute,
+  protectedResourceMetadataUrl2 as protectedResourceMetadataUrl,
+  readMcpCatalogStamp2 as readMcpCatalogStamp,
   resolveMedia,
   summarizeTransports,
-  validateMcpSchemas,
-  wwwAuthenticateHeader
+  validateMcpSchemas2 as validateMcpSchemas,
+  wwwAuthenticateHeader2 as wwwAuthenticateHeader
 };