stitchkit 0.100.1 → 0.100.3

package/dist/entrypoints/tools.js

@@ -1,133 +1,127 @@
 import {
-  ManagedFileError
-} from "../index-paz6sgdp.js";
+  EffectUnresolvedError2,
+  createLocalStepDurability2,
+  AgentToolError2,
+  isAgentToolError2
+} from "../index-a9pd417t.js";
 import {
-  signJwt,
-  verifyPkce
-} from "../index-e01r054k.js";
-import"../index-hr4tzbwq.js";
+  AppError2,
+  STITCH_ERROR_STATUS2
+} from "../index-n53mswt3.js";
 import {
-  DEFAULT_CORS_ALLOW_HEADERS,
-  DEFAULT_PROCESS_SIGNALS,
-  contractOnlyService,
-  defaultSignalSource,
-  guardSignalCallback,
-  mediaTypeEssence,
-  reportSignalError
-} from "../index-2gxzjvyr.js";
-import"../index-2bxbyab0.js";
+  normalizeError2
+} from "../index-b2bz0kdm.js";
 import {
-  redact
-} from "../index-yw4fzmdz.js";
+  resolvePropagationContext2
+} from "../index-hby4qhax.js";
 import {
-  buildToolManifest,
-  describeToolCatalog,
-  mountAgent
-} from "../index-sh3s86na.js";
+  coerceJsonArgs2
+} from "../index-9pw0a51a.js";
 import {
-  AgentToolError,
-  EffectUnresolvedError,
-  createLocalStepDurability,
-  isAgentToolError
-} from "../index-79z7m7dt.js";
-import"../index-rxfy4cq7.js";
+  toJsonSchema
+} from "../index-ct75c3at.js";
 import {
-  ALL_TRANSPORTS,
-  TOOL_TRANSPORTS,
-  defineContract
-} from "../index-k30h66yd.js";
-import"../index-4gcnakhx.js";
+  toolSurfaceOutputSchema,
+  staticInputRounds,
+  validateMcpRoundPolicy,
+  validateResolvedInputRounds,
+  assertToolName,
+  assertUniqueToolName,
+  PORTABLE_JSON_SCHEMA_FORMATS2,
+  findNonPortableFormats2,
+  flattenToolJsonSchema2,
+  presentationMetadata,
+  findUntypedProperties2,
+  prepareProjectedMcpTools
+} from "../index-7z9ym7t8.js";
 import {
-  ManagedFilePathSchema,
-  ManagedFileRefSchema
-} from "../index-6k1937bx.js";
+  parseToolCallArguments,
+  toolResultFromError,
+  ToolExecutionControlError2,
+  isToolExecutionControlError2
+} from "../index-dvwj1f43.js";
 import {
-  AsyncOperationCancelResultSchema,
-  McpAnnotationsSchema,
-  McpMediaContentSchema,
-  ViewFileErrorSchema,
-  ViewFileInputSchema,
-  ViewFileOutputSchema,
-  createAsyncOperationSnapshotSchema
-} from "../index-m9zn6cpq.js";
+  collectTools2,
+  createToolRunner,
+  formatToolError
+} from "../index-n9tyz8z3.js";
 import {
-  createToolInvoker
-} from "../index-5p2m7we1.js";
+  mountAgent2,
+  describeToolCatalog2,
+  buildToolManifest2
+} from "../index-xkhk5d6g.js";
+import"../index-m38ej7e5.js";
 import {
-  WaitTimeoutError,
-  createCli,
-  fetchGuarded,
-  fetchPinnedDocument,
-  readCapped,
-  runWaitOperation
-} from "../index-r066jx76.js";
-import"../index-sbdmyz75.js";
+  ALL_TRANSPORTS2,
+  TOOL_TRANSPORTS2,
+  defineContract2
+} from "../index-ck71tbcf.js";
+import"../index-1bx1xv1k.js";
 import {
-  collectToolSurface
-} from "../index-9t3dffv2.js";
+  redact2
+} from "../index-kzz6rq0w.js";
 import {
-  argumentsDigest
-} from "../index-0b1ess5e.js";
+  AsyncOperationCancelResultSchema2,
+  createAsyncOperationSnapshotSchema2,
+  McpAnnotationsSchema2,
+  McpMediaContentSchema2,
+  ViewFileErrorSchema2,
+  ViewFileOutputSchema2,
+  ViewFileInputSchema2
+} from "../index-5107q189.js";
 import {
-  collectTools,
-  createToolRunner,
-  formatToolError
-} from "../index-bm5rx7n6.js";
+  fetchGuarded,
+  fetchPinnedDocument,
+  readCapped,
+  WaitTimeoutError,
+  runWaitOperation,
+  createCli2
+} from "../index-c6aagrbd.js";
 import {
-  ToolExecutionControlError,
-  isToolExecutionControlError,
-  parseToolCallArguments,
-  toolResultFromError
-} from "../index-8qt2m66q.js";
+  ManagedFilePathSchema2,
+  ManagedFileRefSchema2
+} from "../index-xqhede6x.js";
 import {
-  getRequestContext,
-  getTraceId,
-  runWithRequestContext
-} from "../index-zfrhfn82.js";
-import"../index-35mh5bhj.js";
+  ManagedFileError2
+} from "../index-v4a2fjtk.js";
 import {
-  resolvePropagationContext
-} from "../index-zcgf3gqf.js";
+  signJwt2,
+  verifyPkce2
+} from "../index-45tdvqa3.js";
 import {
-  coerceJsonArgs
-} from "../index-1zbbzgfh.js";
+  DEFAULT_CORS_ALLOW_HEADERS2,
+  contractOnlyService,
+  DEFAULT_PROCESS_SIGNALS,
+  defaultSignalSource,
+  reportSignalError,
+  guardSignalCallback,
+  mediaTypeEssence
+} from "../index-afjvjyck.js";
 import {
-  createRuntimeToolFactory,
-  defineRuntimeTool
-} from "../index-d8m8zpd8.js";
+  collectToolSurface
+} from "../index-ewbaywk5.js";
 import {
-  PORTABLE_JSON_SCHEMA_FORMATS,
-  assertToolName,
-  assertUniqueToolName,
-  findNonPortableFormats,
-  findUntypedProperties,
-  flattenToolJsonSchema,
-  prepareProjectedMcpTools,
-  presentationMetadata,
-  staticInputRounds,
-  toolSurfaceOutputSchema,
-  validateMcpRoundPolicy,
-  validateResolvedInputRounds
-} from "../index-0r0fbk7z.js";
+  argumentsDigest
+} from "../index-r7a7r7ha.js";
 import {
-  toJsonSchema
-} from "../index-eqqvgdb3.js";
+  createToolInvoker2
+} from "../index-m9fndta6.js";
 import {
-  normalizeError
-} from "../index-znfs20ss.js";
-import"../index-p5r7qpdd.js";
+  runWithRequestContext2,
+  getRequestContext2,
+  getTraceId2
+} from "../index-r1z0rd9c.js";
 import {
-  AppError,
-  STITCH_ERROR_STATUS
-} from "../index-2vtcmrj9.js";
+  defineRuntimeTool2,
+  createRuntimeToolFactory2
+} from "../index-jzczzcsb.js";
 import {
   compareCodeUnits,
   serializeCanonicalJson
-} from "../index-k5hsfc3j.js";
-import"../index-kzfs85xp.js";
+} from "../index-zsvzhjtk.js";
 import {
   isRecord
-} from "../index-hffjpmq9.js";
+} from "../index-9jfdm5tg.js";
 // src/server/oauth/cimd.ts
 import { z } from "zod";
 function isPlainDisplayCharacter(character) {
@@ -454,7 +448,7 @@ function wwwAuthenticateHeader(resource) {
 var PUBLIC_CORS = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "GET, OPTIONS",
-  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS
+  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS2
 };
 function oauthProtectedResourceRoute(config) {
   const body = JSON.stringify({
@@ -483,7 +477,7 @@ import { randomUUID } from "node:crypto";
 var PUBLIC_CORS2 = {
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS
+  "Access-Control-Allow-Headers": DEFAULT_CORS_ALLOW_HEADERS2
 };
 var AS_METADATA_PATH = "/.well-known/oauth-authorization-server";
 var AUTH_CODE_TTL_MS = 60000;
@@ -657,7 +651,7 @@ function authorizeRoute(ctx) {
       }
       const requestedScopes = parseScopes(scope);
       const supportedScopes = new Set(config.scopesSupported ?? []);
-      if (config.scopesSupported && requestedScopes.some((requestedScope2) => !supportedScopes.has(requestedScope2))) {
+      if (config.scopesSupported && requestedScopes.some((requestedScope) => !supportedScopes.has(requestedScope))) {
         return ctx.redirectToClient(redirectUri, {
           error: "invalid_scope",
           error_description: "One or more requested scopes are not supported",
@@ -685,11 +679,11 @@ function authorizeRoute(ctx) {
       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")) {
+      if (!Array.isArray(result.approvedScopes) || !result.approvedScopes.every((scope) => typeof scope === "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))) {
+      if (approvedScopes.some((approvedScope) => !requestedScopes.includes(approvedScope) || config.scopesSupported !== undefined && !supportedScopes.has(approvedScope))) {
         throw new Error("authorizeUser approvedScopes must be a subset of requested scopes");
       }
       const approvedScope = approvedScopes.length > 0 ? approvedScopes.join(" ") : undefined;
@@ -737,7 +731,7 @@ function tokenRoute(ctx) {
           return oauthError("invalid_grant", "client_id mismatch");
         if (data.redirectUri !== redirectUri)
           return oauthError("invalid_grant", "redirect_uri mismatch");
-        if (!await verifyPkce(verifier, data.codeChallenge)) {
+        if (!await verifyPkce2(verifier, data.codeChallenge)) {
           return oauthError("invalid_grant", "PKCE verification failed");
         }
         const accessToken = await ctx.issueAccessToken(data.userId, data.resource, data.clientId, data.scope);
@@ -823,7 +817,7 @@ function mountOAuthProvider(config) {
     return dcrClient?.clientId === clientId ? dcrClient : null;
   };
   const redirectToClient = (uri, params) => redirectWith(uri, { ...params, iss: config.issuer });
-  const issueAccessToken = (userId, audience, clientId, scope) => signJwt({ scope, client_id: clientId }, config.signingSecret, {
+  const issueAccessToken = (userId, audience, clientId, scope) => signJwt2({ scope, client_id: clientId }, config.signingSecret, {
     issuer: config.issuer,
     audience,
     subject: userId,
@@ -862,7 +856,7 @@ function composeToolLifecycle(...hooks) {
 // src/tools/list-names.ts
 function listToolNames(surface) {
   const entries = new Map;
-  for (const transport of TOOL_TRANSPORTS) {
+  for (const transport of TOOL_TRANSPORTS2) {
     for (const entry of collectToolSurface({
       surface,
       transport,
@@ -995,7 +989,7 @@ function formatMcpResult(result, mode, toolName, errorHint) {
       serialized = undefined;
     }
     if (serialized === undefined) {
-      const safe = redact(result.data, { sensitiveKeys: /(?!)/ });
+      const safe = redact2(result.data, { sensitiveKeys: /(?!)/ });
       return { content: textBlock(JSON.stringify(safe, null, 2)), structuredContent: safe };
     }
     return { content: textBlock(serialized), structuredContent: result.data };
@@ -1007,7 +1001,7 @@ function formatMcpResult(result, mode, toolName, errorHint) {
 }
 function prepareMcpSurface(services, config = {}) {
   const serviceList = Array.isArray(services) ? services : [services];
-  const tools = serviceList.flatMap((service) => collectTools(service, "MCP", config));
+  const tools = serviceList.flatMap((service) => collectTools2(service, "MCP", config));
   return prepareMcpTools(tools, config);
 }
 function prepareMcpTools(tools, config = {}) {
@@ -1177,7 +1171,7 @@ async function runRoundFailure(tool, rawArgs, runTool, context, code, message) {
       ...tool.method,
       outputSchema: undefined,
       handler: () => {
-        throw new AppError(code, message, 400);
+        throw new AppError2(code, message, 400);
       }
     }
   }, rawArgs, context);
@@ -1322,10 +1316,10 @@ async function resolveMcpRound(options) {
         return { kind: "response", response: options.formatFailure(guarded) };
       }
     }
-    const request2 = requests[0];
-    if (!request2)
+    const request = requests[0];
+    if (!request)
       throw new Error("[stitchkit] validated MRTR policy has no first round");
-    return askRound(options.runtime, options.context, request2, {
+    return askRound(options.runtime, options.context, request, {
       identity: operationIdentity(options.tool),
       argumentsDigest: digest,
       round: 0,
@@ -1388,7 +1382,7 @@ import {
   TRACESTATE_META_KEY
 } from "@modelcontextprotocol/server";
 function runInMcpRequestContext(context, toolName, body) {
-  const ambient = getRequestContext();
+  const ambient = getRequestContext2();
   const metadata = context.mcpReq._meta;
   const propagation = metadata ? {
     traceparent: metadata[TRACEPARENT_META_KEY],
@@ -1402,7 +1396,7 @@ function runInMcpRequestContext(context, toolName, body) {
       path: `/mcp/${toolName}`,
       startedAt: process.hrtime.bigint()
     },
-    trace: resolvePropagationContext(propagation, ambient?.trace),
+    trace: resolvePropagationContext2(propagation, ambient?.trace),
     source: "mcp",
     method: "MCP",
     path: `/mcp/${toolName}`,
@@ -1410,7 +1404,7 @@ function runInMcpRequestContext(context, toolName, body) {
     dimensions: ambient?.dimensions ? { ...ambient.dimensions } : undefined,
     error: undefined
   };
-  return runWithRequestContext(request, body);
+  return runWithRequestContext2(request, body);
 }
 
 // src/tools/mcp/register.ts
@@ -1442,28 +1436,28 @@ function registerMcpTool(server, presentation, descriptor, config) {
         policy: mountable.method.mcp,
         runtime: config.multiRoundRuntime,
         runTool: config.runTool,
-        formatFailure: (result2) => format(result2, "none", name)
+        formatFailure: (result) => format(result, "none", name)
       });
       if (round.kind === "response")
         return round.response;
       const { present } = presentation;
       if (!present) {
-        const result2 = await config.runTool(mountable, args, round.context);
-        return format(result2, descriptor.outputMode, name);
+        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 AppError("INTERNAL_SERVER_ERROR", "Runtime MCP presenter did not return a result", 500);
+            throw new AppError2("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);
+            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 AppError("INTERNAL_SERVER_ERROR", "Runtime MCP presenter returned an invalid CallToolResult", 500);
+            throw new AppError2("INTERNAL_SERVER_ERROR", "Runtime MCP presenter returned an invalid CallToolResult", 500);
           }
           return response;
         }
@@ -2091,16 +2085,16 @@ function buildCanonicalEndpointTable(config, startOutput) {
     startOutput,
     id: config.id,
     snapshot: config.snapshot,
-    cancelResult: AsyncOperationCancelResultSchema
+    cancelResult: AsyncOperationCancelResultSchema2
   };
   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);
+    endpoints.cancel = endpoint("cancel", "POST", "/cancel", config.id, AsyncOperationCancelResultSchema2);
     capabilities.cancel = "cancel";
-    schemas.cancel = AsyncOperationCancelResultSchema;
+    schemas.cancel = AsyncOperationCancelResultSchema2;
     inputFor.cancel = (id) => adapterResult("cancel", "input", config.id, id);
   }
   if (config.result) {
@@ -2126,7 +2120,7 @@ function defineAsyncOperationContract(config) {
   }
   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 contract = config.scope ? defineContract2({ prefix: config.prefix, scope: config.scope }, endpoints) : defineContract2({ 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);
@@ -2158,7 +2152,7 @@ function defineWaitTool(config) {
     }
   } : undefined;
   const present = renderedMcp || config.present ? { ...renderedMcp, ...config.present } : undefined;
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     name: config.name ?? "wait",
     description: config.description,
     identity: managedNativeIdentity(config.identity, "GET"),
@@ -2180,16 +2174,16 @@ function defineWaitTool(config) {
         });
       } catch (error) {
         if (error instanceof WaitTimeoutError) {
-          throw new AppError("WAIT_TIMEOUT", "Wait timed out before the first snapshot", 408);
+          throw new AppError2("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);
+        throw new AppError2("WAIT_TIMEOUT", rendered?.text ?? "Wait timed out before the operation completed", 408);
       }
       if (rendered?.isError) {
-        throw new AppError("WAIT_FAILED", rendered.text, 409);
+        throw new AppError2("WAIT_FAILED", rendered.text, 409);
       }
       return result.state;
     }
@@ -2234,7 +2228,7 @@ function createRuntimeOperationSurface(config) {
 }
 function defineObservationTools(surface) {
   const { config } = surface;
-  const status = defineRuntimeTool({
+  const status = defineRuntimeTool2({
     ...surface.common("status"),
     identity: surface.identity("status", "GET"),
     input: config.id,
@@ -2255,11 +2249,11 @@ function defineObservationTools(surface) {
   return { status, wait };
 }
 function defineCancelTool(surface, capability) {
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     ...surface.common("cancel"),
     identity: surface.identity("cancel", "DELETE"),
     input: surface.config.id,
-    output: AsyncOperationCancelResultSchema,
+    output: AsyncOperationCancelResultSchema2,
     handler: async (context) => {
       const inspected = await surface.inspect("cancel", context);
       return capability.handler(inspected.state, context);
@@ -2267,7 +2261,7 @@ function defineCancelTool(surface, capability) {
   });
 }
 function defineSucceededOutputTool(surface, kind, capability, unavailableMessage) {
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     ...surface.common(kind),
     identity: surface.identity(kind, "GET"),
     input: surface.config.id,
@@ -2275,7 +2269,7 @@ function defineSucceededOutputTool(surface, kind, capability, unavailableMessage
     handler: async (context) => {
       const inspected = await surface.inspect(kind, context);
       if (!succeeded(inspected.snapshot)) {
-        throw new AppError("OPERATION_NOT_SUCCEEDED", unavailableMessage, 409);
+        throw new AppError2("OPERATION_NOT_SUCCEEDED", unavailableMessage, 409);
       }
       return capability.handler(inspected.state, context);
     }
@@ -2285,7 +2279,7 @@ function defineSucceededOutputTool(surface, kind, capability, unavailableMessage
 // src/tools/operations/async-operation-runtime.ts
 function defineAsyncOperation(config) {
   const surface = createRuntimeOperationSurface(config);
-  const start = defineRuntimeTool({
+  const start = defineRuntimeTool2({
     ...surface.common("start"),
     identity: surface.identity("start", "POST"),
     input: config.startInput,
@@ -2314,7 +2308,7 @@ function defineAsyncOperation(config) {
     schemas: {
       id: config.id,
       snapshot: config.snapshot,
-      cancelResult: AsyncOperationCancelResultSchema
+      cancelResult: AsyncOperationCancelResultSchema2
     }
   };
 }
@@ -2431,7 +2425,7 @@ function createToolLogger(config = {}) {
         code: result.ok ? undefined : result.code,
         durationMs: Math.round(durationMs),
         source: String(context.source),
-        traceId: getTraceId()
+        traceId: getTraceId2()
       };
       const codePart = result.ok ? "" : ` ${result.code}`;
       log(`[tool] ${result.ok ? "ok" : "warn"} ${toolName} (${endpoint.serviceName}.${endpoint.key})${codePart} ${record.durationMs}ms`);
@@ -2443,11 +2437,11 @@ function createToolLogger(config = {}) {
 function createToolkit() {
   return {
     mountMcp: (server, services, config) => mountMcp(server, services, config),
-    mountAgent: (services, config) => mountAgent(services, config),
+    mountAgent: (services, config) => mountAgent2(services, config),
     buildMcpServer: (config, auth) => buildMcpServer(config, auth),
     createMcpHandler: (config) => createMcpHandler(config),
     createStdioMcpServer: (config) => createStdioMcpServer(config),
-    createCli: (config) => createCli(config)
+    createCli: (config) => createCli2(config)
   };
 }
 // src/tools/transfer/download-core.ts
@@ -2527,7 +2521,7 @@ var SAFE_MANAGED_FILE_MESSAGES = {
   FILE_EXISTS: "Managed file already exists"
 };
 function managedFileAppError(error) {
-  if (!(error instanceof ManagedFileError))
+  if (!(error instanceof ManagedFileError2))
     return null;
   switch (error.code) {
     case "FILE_INVALID_PATH":
@@ -2537,30 +2531,30 @@ function managedFileAppError(error) {
     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]);
+      return new AppError2(error.code, SAFE_MANAGED_FILE_MESSAGES[error.code], STITCH_ERROR_STATUS2[error.code]);
     case "FILE_IO_ERROR":
       return null;
   }
 }
 function normalizeFileToolError(error) {
-  return managedFileAppError(error) ?? normalizeError(error);
+  return managedFileAppError(error) ?? normalizeError2(error);
 }
 
 // src/tools/transfer/define-download-tool.ts
 function defineDownloadTool(config) {
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     name: config.name ?? "download",
     description: config.description,
     identity: managedNativeIdentity(config.identity, "POST"),
     input: config.input,
-    output: ManagedFileRefSchema,
+    output: ManagedFileRefSchema2,
     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);
+        throw new AppError2("DOWNLOAD_NOT_FOUND", "Nothing to download", 404);
       }
       try {
         return await runDownloadOperation({
@@ -2574,7 +2568,7 @@ function defineDownloadTool(config) {
         });
       } catch (error) {
         if (error instanceof DownloadOperationError) {
-          throw new AppError(error.code, `Download failed: ${error.message}`, error.status);
+          throw new AppError2(error.code, `Download failed: ${error.message}`, error.status);
         }
         const managedError = managedFileAppError(error);
         if (managedError)
@@ -2595,10 +2589,10 @@ function runUploadOperation(files, path, upload, signal) {
 
 // src/tools/transfer/define-upload-tool.ts
 var UploadToolInputSchema = z6.object({
-  path: ManagedFilePathSchema.describe("Path relative to the configured file boundary")
+  path: ManagedFilePathSchema2.describe("Path relative to the configured file boundary")
 });
 function defineUploadTool(config) {
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     name: config.name ?? "upload",
     description: config.description,
     identity: managedNativeIdentity(config.identity, "POST"),
@@ -2645,7 +2639,7 @@ async function fetchSource(pathOrUrl, options, maxBytes) {
       signal: options.signal
     });
     if (!res.ok)
-      throw new AppError("VIEW_HTTP_ERROR", `HTTP ${res.status}`, 502);
+      throw new AppError2("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/")) {
@@ -2661,11 +2655,11 @@ async function fetchSource(pathOrUrl, options, 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);
+    throw new AppError2("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);
+    throw new AppError2("FILE_INSPECTION_REJECTED", "refusing to read a non-media file", 422);
   }
   try {
     const source = await options.files.read(pathOrUrl, {
@@ -2679,7 +2673,7 @@ async function fetchSource(pathOrUrl, options, maxBytes) {
       bytesRead: buffer.length
     };
   } catch (error) {
-    if (error instanceof ManagedFileError && error.code === "FILE_TOO_LARGE") {
+    if (error instanceof ManagedFileError2 && error.code === "FILE_TOO_LARGE") {
       return { tooLarge: true, mimeType: extMime, bytesRead: maxBytes };
     }
     throw error;
@@ -2773,12 +2767,12 @@ async function runViewFileOperation(paths, options = {}, signal) {
       content.push({ type: "text", text: `[${pathOrUrl}] Error: ${message}` });
     }
   }
-  return ViewFileOutputSchema.parse({ content, errors });
+  return ViewFileOutputSchema2.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,
+    inputSchema: ViewFileInputSchema2.shape,
     annotations: { title: "View Media", readOnlyHint: true, idempotentHint: true }
   }, async (args) => {
     const result = await runViewFileOperation(args.paths, options);
@@ -2803,12 +2797,12 @@ function defineViewFileTool(config) {
       })
     })
   };
-  return defineRuntimeTool({
+  return defineRuntimeTool2({
     name: config.name ?? "view_file",
     description: config.description,
     identity: managedNativeIdentity(config.identity, "GET"),
-    input: ViewFileInputSchema,
-    output: ViewFileOutputSchema,
+    input: ViewFileInputSchema2,
+    output: ViewFileOutputSchema2,
     transports: config.transports,
     annotations: config.annotations ?? {
       title: "View Media",
@@ -2859,7 +2853,7 @@ function mountUpload(server, config) {
   server.registerTool(name, {
     description: config.description,
     inputSchema: {
-      path: ManagedFilePathSchema.describe("Path relative to the configured file boundary")
+      path: ManagedFilePathSchema2.describe("Path relative to the configured file boundary")
     }
   }, async (rawArgs) => {
     const args = isRecord(rawArgs) ? rawArgs : {};
@@ -2885,7 +2879,7 @@ function contractCounts(service) {
     if (!method.expose || method.expose.includes("HTTP"))
       counts.HTTP += 1;
   }
-  for (const transport of TOOL_TRANSPORTS) {
+  for (const transport of TOOL_TRANSPORTS2) {
     counts[transport] = collectToolSurface({
       surface: { services: [service] },
       transport,
@@ -2897,7 +2891,7 @@ function contractCounts(service) {
 }
 function runtimeCounts(runtimeTools) {
   const counts = emptyCounts();
-  for (const transport of TOOL_TRANSPORTS) {
+  for (const transport of TOOL_TRANSPORTS2) {
     counts[transport] = collectToolSurface({
       surface: { runtimeTools },
       transport,
@@ -2908,7 +2902,7 @@ function runtimeCounts(runtimeTools) {
   return counts;
 }
 function addCounts(target, source) {
-  for (const transport of ALL_TRANSPORTS)
+  for (const transport of ALL_TRANSPORTS2)
     target[transport] += source[transport];
 }
 function summarizeTransports(surface) {
@@ -2941,69 +2935,69 @@ function summarizeTransports(surface) {
   };
 }
 export {
-  wwwAuthenticateHeader,
-  validateMcpSchemas,
-  summarizeTransports,
-  resolveMedia,
-  readMcpCatalogStamp,
-  protectedResourceMetadataUrl,
-  oauthProtectedResourceRoute,
-  mountWait,
-  mountViewFile,
-  mountUpload,
-  mountOAuthProvider,
-  mountMcpResource,
-  mountMcp,
-  mountDownload,
-  mountAgent,
-  mcpCatalogMeta,
-  listToolNames,
-  listContractToolNames,
-  isToolExecutionControlError,
-  isAgentToolError,
-  inlineMcpAppBundle,
-  flattenToolJsonSchema,
-  findUntypedProperties,
-  findNonPortableFormats,
-  describeToolCatalog,
-  defineWaitTool,
-  defineViewFileTool,
-  defineUploadTool,
-  defineToolRegistry,
-  defineRuntimeTool,
-  defineDownloadTool,
-  defineAsyncOperationContract,
-  defineAsyncOperation,
-  createToolkit,
-  createToolLogger,
-  createToolInvoker,
-  createStdioMcpServer,
-  createSecureClientMetadataFetcher,
-  createRuntimeToolFactory,
-  createMcpHttpRoute,
-  createMcpHandler,
-  createLocalStepDurability,
-  createAsyncOperationSnapshotSchema,
-  composeToolLifecycle,
-  collectTools,
-  coerceJsonArgs,
-  buildToolManifest,
-  buildMcpServer,
-  bindStdioProcessSignals,
-  bindContractAsyncOperation,
-  ViewFileOutputSchema,
-  ViewFileInputSchema,
-  ViewFileErrorSchema,
-  UploadToolInputSchema,
-  ToolExecutionControlError,
-  RESOURCE_MIME_TYPE,
-  PROTECTED_RESOURCE_PATH,
-  PORTABLE_JSON_SCHEMA_FORMATS,
-  McpMediaContentSchema,
-  McpAnnotationsSchema,
-  MCP_CATALOG_META_KEY,
-  EffectUnresolvedError,
+  AgentToolError2 as AgentToolError,
+  AsyncOperationCancelResultSchema2 as AsyncOperationCancelResultSchema,
   EXT_APPS_BUNDLE_PLACEHOLDER,
-  AsyncOperationCancelResultSchema,
-  AgentToolError
+  EffectUnresolvedError2 as EffectUnresolvedError,
+  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,
+  ToolExecutionControlError2 as ToolExecutionControlError,
+  UploadToolInputSchema,
+  ViewFileErrorSchema2 as ViewFileErrorSchema,
+  ViewFileInputSchema2 as ViewFileInputSchema,
+  ViewFileOutputSchema2 as ViewFileOutputSchema,
+  bindContractAsyncOperation,
+  bindStdioProcessSignals,
+  buildMcpServer,
+  buildToolManifest2 as buildToolManifest,
+  coerceJsonArgs2 as coerceJsonArgs,
+  collectTools2 as collectTools,
+  composeToolLifecycle,
+  createAsyncOperationSnapshotSchema2 as createAsyncOperationSnapshotSchema,
+  createLocalStepDurability2 as createLocalStepDurability,
+  createMcpHandler,
+  createMcpHttpRoute,
+  createRuntimeToolFactory2 as createRuntimeToolFactory,
+  createSecureClientMetadataFetcher,
+  createStdioMcpServer,
+  createToolInvoker2 as createToolInvoker,
+  createToolLogger,
+  createToolkit,
+  defineAsyncOperation,
+  defineAsyncOperationContract,
+  defineDownloadTool,
+  defineRuntimeTool2 as defineRuntimeTool,
+  defineToolRegistry,
+  defineUploadTool,
+  defineViewFileTool,
+  defineWaitTool,
+  describeToolCatalog2 as describeToolCatalog,
+  findNonPortableFormats2 as findNonPortableFormats,
+  findUntypedProperties2 as findUntypedProperties,
+  flattenToolJsonSchema2 as flattenToolJsonSchema,
+  inlineMcpAppBundle,
+  isAgentToolError2 as isAgentToolError,
+  isToolExecutionControlError2 as isToolExecutionControlError,
+  listContractToolNames,
+  listToolNames,
+  mcpCatalogMeta,
+  mountAgent2 as mountAgent,
+  mountDownload,
+  mountMcp,
+  mountMcpResource,
+  mountOAuthProvider,
+  mountUpload,
+  mountViewFile,
+  mountWait,
+  oauthProtectedResourceRoute,
+  protectedResourceMetadataUrl,
+  readMcpCatalogStamp,
+  resolveMedia,
+  summarizeTransports,
+  validateMcpSchemas,
+  wwwAuthenticateHeader
 };