stitchkit 0.93.0 → 0.94.1

package/dist/index-hffjpmq9.js

@@ -0,0 +1,30 @@
+// src/internal/typed.ts
+function typedEntries(value) {
+  return Object.entries(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function callRuntimeHandler(handler, context) {
+  if (typeof handler !== "function") {
+    throw new TypeError("Runtime handler must be a function");
+  }
+  return Reflect.apply(handler, undefined, [context]);
+}
+function transportResult(value) {
+  return value;
+}
+function mapObject(source, mapper) {
+  const result = {};
+  for (const [key, value] of typedEntries(source)) {
+    const mapped = mapper(key, value);
+    if (mapped !== undefined)
+      result[key] = mapped;
+  }
+  return result;
+}
+function mapObjectTypeBoundary(source, mapper) {
+  return mapObject(source, (key, value) => mapper(key, value));
+}
+
+export { typedEntries, isRecord, callRuntimeHandler, transportResult, mapObject, mapObjectTypeBoundary };

package/dist/index-hmp4800j.js

@@ -0,0 +1,51 @@
+import {
+  contractToolMountable
+} from "./index-khtgb21r.js";
+import {
+  runtimeToolMountable
+} from "./index-xw3s75nj.js";
+import {
+  projectToolSurface
+} from "./index-np4m8hd3.js";
+
+// src/tools/surface.ts
+function collectToolSurface({
+  surface,
+  transport,
+  assertUniqueNames = true,
+  ...collectConfig
+}) {
+  const entries = [];
+  const append = (entry) => {
+    entries.push(entry);
+  };
+  for (const projected of projectToolSurface(surface, transport, {
+    extend: collectConfig.extend,
+    flattenUnionInput: collectConfig.flattenUnionInput,
+    assertNames: collectConfig.assertNames,
+    assertUniqueNames
+  })) {
+    if (projected.kind === "contract") {
+      const mountable = contractToolMountable(projected, collectConfig.extend);
+      append({
+        kind: "contract",
+        service: projected.serviceName,
+        action: mountable.method.key,
+        mountable,
+        projection: projected
+      });
+    } else {
+      append({
+        kind: "runtime",
+        service: projected.serviceName,
+        action: projected.action,
+        mountable: runtimeToolMountable(projected.source, false),
+        definition: projected.source,
+        projection: projected
+      });
+    }
+  }
+  return entries;
+}
+
+export { collectToolSurface };

package/dist/index-k30h66yd.js

@@ -0,0 +1,317 @@
+import {
+  resolveRouteParamsSchema
+} from "./index-4gcnakhx.js";
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/contract/tool-view.ts
+import { z } from "zod";
+var DECLARED_TOOL_VIEW = Symbol.for("stitchkit.toolView");
+function withToolView(endpoint, view) {
+  const declared = { ...view, [DECLARED_TOOL_VIEW]: true };
+  return { ...endpoint, tool: { ...endpoint.tool, view: declared } };
+}
+function objectKeys(schema) {
+  return schema instanceof z.ZodObject ? new Set(Object.keys(schema.shape)) : new Set;
+}
+function assertToolView(prefix, key, ep) {
+  const where = `Contract "${prefix}": endpoint "${key}" tool.view`;
+  const tool = Reflect.get(ep, "tool");
+  const view = isRecord(tool) ? tool.view : undefined;
+  if (!isRecord(view))
+    throw new Error(`${where} must be an object`);
+  if (Reflect.get(view, DECLARED_TOOL_VIEW) !== true) {
+    throw new Error(`${where} must be declared with withToolView, which types its project`);
+  }
+  if (ep.rawResponse || ep.rawBody || ep.multipart || "responseMeta" in ep || "stream" in ep) {
+    throw new Error(`${where} is only for a JSON tool endpoint — this one is HTTP-only by kind`);
+  }
+  if (!ep.output) {
+    throw new Error(`${where} needs the endpoint's full output — the view is derived from it`);
+  }
+  const output = view.output;
+  const project = view.project;
+  if (output !== undefined && !(output instanceof z.ZodType)) {
+    throw new Error(`${where}.output must be a Zod schema`);
+  }
+  if (project !== undefined && typeof project !== "function") {
+    throw new Error(`${where}.project must be a function`);
+  }
+  const defaults = view.defaults;
+  if (defaults !== undefined && !isRecord(defaults)) {
+    throw new Error(`${where}.defaults must be an object`);
+  }
+  const entries = defaults === undefined ? [] : Object.entries(defaults);
+  if (output === undefined && project === undefined && entries.length === 0) {
+    throw new Error(`${where} declares no defaults, output or project — it would change nothing`);
+  }
+  if (entries.length === 0)
+    return;
+  if (!(ep.input instanceof z.ZodObject)) {
+    throw new Error(`${where}.defaults needs an object input schema to name keys of`);
+  }
+  const inputKeys = objectKeys(ep.input);
+  const paramKeys = objectKeys(ep.params);
+  for (const [name, value] of entries) {
+    if (paramKeys.has(name)) {
+      throw new Error(`${where}.defaults.${name} is a path param — a route segment has no default`);
+    }
+    if (!inputKeys.has(name)) {
+      throw new Error(`${where}.defaults.${name} is not a key of the endpoint's input`);
+    }
+    const field = ep.input.shape[name];
+    if (field === undefined || !z.safeParse(field, value).success) {
+      throw new Error(`${where}.defaults.${name} is not a valid value for that input key`);
+    }
+  }
+}
+
+// src/contract/define-validation.ts
+function assertPositiveLimit(where, name, value) {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
+    throw new Error(`${where} ${name} must be a positive safe integer, received ${value}`);
+  }
+}
+function assertMultipartEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": multipart endpoint "${key}"`;
+  if (ep.method !== "POST" && ep.method !== "PUT" && ep.method !== "PATCH") {
+    throw new Error(`${where} must use POST, PUT or PATCH`);
+  }
+  const multipart = ep.multipart;
+  if (!multipart || typeof multipart !== "object") {
+    throw new Error(`${where} must declare a multipart descriptor`);
+  }
+  assertPositiveLimit(where, "maxRequestBytes", multipart.maxRequestBytes);
+  assertPositiveLimit(where, "maxFieldBytes", multipart.maxFieldBytes);
+  const entries = Object.entries(multipart.files);
+  if (entries.length === 0)
+    throw new Error(`${where} must declare at least one file field`);
+  for (const [field, policy] of entries) {
+    if (!field || isUnsafeKey(field))
+      throw new Error(`${where} has an invalid file field name`);
+    assertPositiveLimit(`${where} field "${field}"`, "maxBytes", policy.maxBytes);
+    assertPositiveLimit(`${where} field "${field}"`, "maxFiles", policy.maxFiles);
+    if (policy.multiple !== true && policy.maxFiles !== undefined) {
+      throw new Error(`${where} field "${field}" may set maxFiles only with multiple: true`);
+    }
+    if (policy.contentTypes) {
+      if (policy.contentTypes.length === 0) {
+        throw new Error(`${where} field "${field}" contentTypes cannot be empty`);
+      }
+      for (const contentType of policy.contentTypes) {
+        if (!/^[a-z0-9!#$&^_.+-]+\/(?:[a-z0-9!#$&^_.+-]+|\*)$/i.test(contentType)) {
+          throw new Error(`${where} field "${field}" has invalid content type policy "${contentType}"`);
+        }
+      }
+    }
+  }
+}
+function assertRawEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": raw endpoint "${key}"`;
+  if (ep.output)
+    throw new Error(`${where} cannot declare an output schema`);
+  assertNoToolOptions(where, ep);
+  const nonHttp = (ep.expose ?? []).filter((t) => t !== "HTTP");
+  if (nonHttp.length > 0) {
+    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
+  }
+}
+function assertStreamingResponseEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": streaming endpoint "${key}"`;
+  if (!("stream" in ep) || !ep.stream || typeof ep.stream !== "object") {
+    throw new Error(`${where} must declare a stream descriptor`);
+  }
+  if (!ep.stream.item || typeof ep.stream.item.parse !== "function") {
+    throw new Error(`${where} must declare an item schema`);
+  }
+  const runtimeFormat = Reflect.get(ep.stream, "format");
+  const runtimeFinalLine = Reflect.get(ep.stream, "finalLine");
+  if (ep.stream.framing === "item" && runtimeFormat === "sse") {
+    throw new Error(`${where} item framing is supported only for ndjson`);
+  }
+  if (ep.stream.framing === "item" && ep.stream.completion !== "terminal") {
+    throw new Error(`${where} item framing requires terminal completion`);
+  }
+  if (ep.stream.completion === "terminal" && !ep.stream.terminal) {
+    throw new Error(`${where} terminal completion requires a terminal schema`);
+  }
+  if (runtimeFinalLine === "require-newline" && runtimeFormat === "sse") {
+    throw new Error(`${where} finalLine applies only to ndjson`);
+  }
+  assertPositiveLimit(where, "maxFrameBytes", ep.stream.maxFrameBytes);
+  assertPositiveLimit(where, "lifetimeMs", ep.stream.lifetimeMs);
+  assertPositiveLimit(where, "heartbeatMs", ep.stream.heartbeatMs);
+  if (ep.stream.idleTimeoutSeconds !== undefined && (!Number.isSafeInteger(ep.stream.idleTimeoutSeconds) || ep.stream.idleTimeoutSeconds < 0)) {
+    throw new Error(`${where} idleTimeoutSeconds must be a non-negative safe integer`);
+  }
+  if (ep.output)
+    throw new Error(`${where} cannot declare an output schema`);
+  if (ep.rawResponse)
+    throw new Error(`${where} cannot also be rawResponse`);
+  if (ep.multipart)
+    throw new Error(`${where} cannot be multipart`);
+  assertNoToolOptions(where, ep);
+  const nonHttp = (ep.expose ?? []).filter((transport) => transport !== "HTTP");
+  if (nonHttp.length > 0) {
+    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
+  }
+}
+var UNGROUPED_TOOL_OPTIONS = {
+  toolName: "tool.name",
+  toolView: "tool.view (declared with withToolView)",
+  ui: "tool.ui",
+  annotations: "tool.annotations",
+  mcp: "tool.mcp"
+};
+var TOOL_OPTION_KEYS = {
+  name: true,
+  view: true,
+  ui: true,
+  annotations: true,
+  mcp: true
+};
+function assertNoUngroupedToolOptions(prefix, key, ep) {
+  const where = `Contract "${prefix}": endpoint "${key}"`;
+  for (const [name, moved] of Object.entries(UNGROUPED_TOOL_OPTIONS)) {
+    if (Object.hasOwn(ep, name)) {
+      throw new Error(`${where} sets \`${name}\` — tool options live in \`tool\` since 0.94.0: use ${moved}`);
+    }
+  }
+  const group = "tool" in ep ? ep.tool : undefined;
+  if (group === undefined)
+    return;
+  for (const name of Object.keys(group)) {
+    if (!Object.hasOwn(TOOL_OPTION_KEYS, name)) {
+      throw new Error(`${where} sets \`tool.${name}\`, which is not a tool option — \`tool\` accepts ${Object.keys(TOOL_OPTION_KEYS).join(", ")}`);
+    }
+  }
+}
+function assertNoToolOptions(where, ep) {
+  if ("tool" in ep && ep.tool !== undefined) {
+    throw new Error(`${where} cannot set tool options — it never reaches a tool transport`);
+  }
+}
+function assertHeadEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": HEAD endpoint "${key}"`;
+  if (!ep.rawResponse)
+    throw new Error(`${where} must declare rawResponse: true`);
+  if (ep.input)
+    throw new Error(`${where} cannot declare an input schema`);
+  if (ep.multipart)
+    throw new Error(`${where} cannot be multipart`);
+  if (ep.rawBody)
+    throw new Error(`${where} cannot retain a raw body`);
+}
+function assertRawBodyEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": rawBody endpoint "${key}"`;
+  if (!ep.input)
+    throw new Error(`${where} must declare an input schema`);
+  if (ep.multipart)
+    throw new Error(`${where} cannot be multipart`);
+  if (ep.method !== "POST" && ep.method !== "PUT" && ep.method !== "PATCH") {
+    throw new Error(`${where} must use POST, PUT or PATCH`);
+  }
+  assertNoToolOptions(where, ep);
+  const nonHttp = (ep.expose ?? []).filter((transport) => transport !== "HTTP");
+  if (nonHttp.length > 0) {
+    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
+  }
+}
+function assertSafelistedBodyEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": safelistedBody endpoint "${key}"`;
+  if (ep.method !== "POST")
+    throw new Error(`${where} must use POST`);
+  if (!ep.input)
+    throw new Error(`${where} must declare an input schema`);
+  if (ep.multipart)
+    throw new Error(`${where} cannot be multipart`);
+  if ("stream" in ep && ep.stream)
+    throw new Error(`${where} cannot be a streaming response`);
+}
+function assertResponseMetaEndpoint(prefix, key, ep) {
+  const where = `Contract "${prefix}": responseMeta endpoint "${key}"`;
+  if (!ep.responseMeta || typeof ep.responseMeta !== "object") {
+    throw new Error(`${where} must declare responseMeta as an object`);
+  }
+  const status = ep.responseMeta.status;
+  if (status !== undefined && (!Number.isSafeInteger(status) || status < 200 || status > 299)) {
+    throw new Error(`${where} status must be a successful 2xx integer, received ${status}`);
+  }
+  if (ep.output && (status === 204 || status === 205)) {
+    throw new Error(`${where} cannot combine output with bodyless status ${status}`);
+  }
+  if (ep.rawResponse)
+    throw new Error(`${where} cannot also be a rawResponse endpoint`);
+  assertNoToolOptions(where, ep);
+  const nonHttp = (ep.expose ?? []).filter((transport) => transport !== "HTTP");
+  if (nonHttp.length > 0) {
+    throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
+  }
+}
+
+// src/contract/define.ts
+var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT", "CLI"];
+var TOOL_TRANSPORTS = ["MCP", "AGENT", "CLI"];
+function defineContract(meta, endpoints) {
+  const materializedEndpoints = {};
+  for (const [key, endpoint] of Object.entries(endpoints)) {
+    const params = resolveRouteParamsSchema(endpoint.path, endpoint.params);
+    materializedEndpoints[key] = params === endpoint.params ? endpoint : { ...endpoint, params };
+  }
+  const toolTransports = new Map;
+  for (const [key, ep] of Object.entries(materializedEndpoints)) {
+    if (ep.desc.trim() === "") {
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" has an empty desc`);
+    }
+    if (ep.maxJsonBodyBytes !== undefined && (!Number.isSafeInteger(ep.maxJsonBodyBytes) || ep.maxJsonBodyBytes <= 0)) {
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" maxJsonBodyBytes must be a positive safe integer, received ${ep.maxJsonBodyBytes}`);
+    }
+    if (ep.multipart)
+      assertMultipartEndpoint(meta.prefix, key, ep);
+    if (ep.rawResponse)
+      assertRawEndpoint(meta.prefix, key, ep);
+    if ("stream" in ep)
+      assertStreamingResponseEndpoint(meta.prefix, key, ep);
+    if (ep.method === "HEAD")
+      assertHeadEndpoint(meta.prefix, key, ep);
+    if (ep.rawBody)
+      assertRawBodyEndpoint(meta.prefix, key, ep);
+    if (ep.safelistedBody)
+      assertSafelistedBodyEndpoint(meta.prefix, key, ep);
+    if ("responseMeta" in ep)
+      assertResponseMetaEndpoint(meta.prefix, key, ep);
+    assertNoUngroupedToolOptions(meta.prefix, key, ep);
+    const tool = "tool" in ep ? ep.tool : undefined;
+    if (tool === undefined)
+      continue;
+    if (typeof tool !== "object" || tool === null) {
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" tool must be an object`);
+    }
+    const transports = new Set(ep.expose ? ep.expose.filter((t) => t !== "HTTP") : ["MCP", "AGENT"]);
+    if (transports.size === 0) {
+      throw new Error(`Contract "${meta.prefix}": endpoint "${key}" sets tool options but is not exposed on any tool transport (${TOOL_TRANSPORTS.join(" / ")}) — a contract factory with toolExposure 'explicit' makes an omitted expose HTTP-only`);
+    }
+    if (tool.view !== undefined)
+      assertToolView(meta.prefix, key, ep);
+    if (!tool.name)
+      continue;
+    const existing = toolTransports.get(tool.name);
+    if (existing) {
+      for (const t of transports) {
+        if (existing.transports.has(t)) {
+          throw new Error(`Contract "${meta.prefix}": duplicate tool name "${tool.name}" on transport "${t}" (endpoints: "${existing.key}" and "${key}")`);
+        }
+        existing.transports.add(t);
+      }
+    } else {
+      toolTransports.set(tool.name, { key, transports });
+    }
+  }
+  return { meta, endpoints: materializedEndpoints };
+}
+
+export { withToolView, ALL_TRANSPORTS, TOOL_TRANSPORTS, defineContract };

package/dist/index-k5hsfc3j.js

@@ -0,0 +1,31 @@
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/internal/canonical-json.ts
+function compareCodeUnits(left, right) {
+  if (left < right)
+    return -1;
+  if (left > right)
+    return 1;
+  return 0;
+}
+function canonicalText(value) {
+  if (Array.isArray(value)) {
+    return `[${Array.from(value, (item) => canonicalText(item) ?? "null").join(",")}]`;
+  }
+  if (!isRecord(value))
+    return JSON.stringify(value);
+  const members = [];
+  for (const key of Object.keys(value).sort(compareCodeUnits)) {
+    const text = canonicalText(value[key]);
+    if (text !== undefined)
+      members.push(`${JSON.stringify(key)}:${text}`);
+  }
+  return `{${members.join(",")}}`;
+}
+function serializeCanonicalJson(value) {
+  return canonicalText(value) ?? "undefined";
+}
+
+export { compareCodeUnits, serializeCanonicalJson };

package/dist/index-khtgb21r.js

@@ -0,0 +1,92 @@
+import {
+  executeToolMethod,
+  toolErrorFromResult
+} from "./index-55hkhm67.js";
+import {
+  assertToolExtensionCompatible,
+  mergeSchemas,
+  projectToolSurface,
+  rebuildObject
+} from "./index-np4m8hd3.js";
+import {
+  isRetryableStatus
+} from "./index-2vtcmrj9.js";
+
+// src/tools/mount.ts
+import { z } from "zod";
+function applyExtend(base, extra) {
+  if (base instanceof z.ZodObject) {
+    assertToolExtensionCompatible(base, extra);
+    return rebuildObject(base, { ...extra, ...base.shape });
+  }
+  return z.intersection(z.object(extra), base);
+}
+function contractToolMountable(projected, extend) {
+  const method = projected.source;
+  const baseArgumentSchema = mergeSchemas(method.paramsSchema, method.inputSchema);
+  const argumentSchema = projected.shouldExtend && extend ? applyExtend(baseArgumentSchema, extend.schema) : baseArgumentSchema;
+  return {
+    method,
+    name: projected.name,
+    argumentSchema,
+    presentationSchema: projected.presentationSchema,
+    shouldExtend: projected.shouldExtend
+  };
+}
+function collectTools(service, transport, config = {}) {
+  const { extend, flattenUnionInput = false, assertNames = true } = config;
+  const tools = [];
+  for (const projected of projectToolSurface({ services: [service] }, transport === "HTTP" ? "AGENT" : transport, {
+    extend,
+    flattenUnionInput,
+    assertNames,
+    assertUniqueNames: false
+  })) {
+    if (projected.kind !== "contract")
+      continue;
+    tools.push(contractToolMountable(projected, extend));
+  }
+  return tools;
+}
+function createToolRunner(config) {
+  const extension = config.extend ? {
+    schema: z.object(config.extend.schema),
+    resolve: config.extend.resolve
+  } : undefined;
+  return async function runOneToolCall(tool, rawArgs, context, call) {
+    return executeToolMethod(tool.method, {
+      toolName: tool.name,
+      rawArgs,
+      context: { ...config.context, ...context, source: config.source }
+    }, {
+      hooks: config.hooks,
+      lifecycle: config.lifecycle,
+      coerceJson: config.coerceJsonArgs ?? true,
+      onOutputStrip: config.onOutputStrip ? (paths) => config.onOutputStrip?.(tool.name, paths) : undefined,
+      extension: tool.shouldExtend ? extension : undefined,
+      toolSurface: config.toolSurface ?? false,
+      finalizeOutput: call?.finalizeOutput
+    });
+  };
+}
+function formatToolError(result, toolName, errorHint) {
+  const err = {
+    error: result.code,
+    retryable: result.retryable ?? isRetryableStatus(toolErrorFromResult(result).status)
+  };
+  if (result.details)
+    err.details = result.details;
+  const hints = [];
+  if (result.hint)
+    hints.push(result.hint);
+  if (errorHint && toolName) {
+    const global = errorHint(toolName, result.code);
+    if (global)
+      hints.push(global);
+  }
+  if (hints.length > 0)
+    err._hint = hints.join(" ");
+  return err;
+}
+
+export { contractToolMountable, collectTools, createToolRunner, formatToolError };

package/dist/index-m9zn6cpq.js

@@ -0,0 +1,51 @@
+// src/tools/operations/async-operation-contract.ts
+import { z } from "zod";
+var AsyncOperationCancelResultSchema = z.discriminatedUnion("outcome", [
+  z.object({ outcome: z.literal("accepted") }),
+  z.object({ outcome: z.literal("already_terminal") }),
+  z.object({ outcome: z.literal("rejected"), reason: z.string().min(1) })
+]);
+function createAsyncOperationSnapshotSchema(config) {
+  const progress = config.progress ? { progress: config.progress.optional() } : {};
+  return z.discriminatedUnion("phase", [
+    z.object({ phase: z.literal("pending"), ...progress }),
+    z.object({ phase: z.literal("running"), ...progress }),
+    z.object({ phase: z.literal("succeeded"), ...progress }),
+    z.object({ phase: z.literal("failed"), failure: config.failure, ...progress }),
+    z.object({ phase: z.literal("cancelled"), ...progress })
+  ]);
+}
+// src/tools/transfer/view-file-contract.ts
+import { z as z2 } from "zod";
+var MAX_VIEW_FILES = 20;
+var McpAnnotationsSchema = z2.object({
+  audience: z2.array(z2.enum(["user", "assistant"])).optional(),
+  priority: z2.number().optional()
+});
+var McpMediaContentSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("text"), text: z2.string() }),
+  z2.object({
+    type: z2.literal("image"),
+    data: z2.string(),
+    mimeType: z2.string(),
+    annotations: McpAnnotationsSchema.optional()
+  }),
+  z2.object({
+    type: z2.literal("audio"),
+    data: z2.string(),
+    mimeType: z2.string(),
+    annotations: McpAnnotationsSchema.optional()
+  })
+]);
+var ViewFileErrorSchema = z2.object({
+  path: z2.string(),
+  message: z2.string()
+});
+var ViewFileOutputSchema = z2.object({
+  content: z2.array(McpMediaContentSchema),
+  errors: z2.array(ViewFileErrorSchema)
+});
+var ViewFileInputSchema = z2.object({
+  paths: z2.union([z2.string(), z2.array(z2.string()).max(MAX_VIEW_FILES)]).describe("Media URL(s) or file path(s) to view")
+});
+export { AsyncOperationCancelResultSchema, createAsyncOperationSnapshotSchema, McpAnnotationsSchema, McpMediaContentSchema, ViewFileErrorSchema, ViewFileOutputSchema, ViewFileInputSchema };