stitchkit 0.92.0 → 0.94.0

package/dist/{index-0a349c33.js → index-gyr48nzg.js}

@@ -1,23 +1,75 @@
-import {
-  base64UrlToBytes,
-  bytesToBase64Url
-} from "./index-rxfy4cq7.js";
-import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  isStitchErrorCode
-} from "./index-2vtcmrj9.js";
 import {
   isUnsafeKey
 } from "./index-kzfs85xp.js";
 import {
-  mapObjectTypeBoundary,
-  transportResult,
-  typedEntries
-} from "./index-77fekveh.js";
+  isRecord
+} from "./index-hffjpmq9.js";
 
-// src/internal/route-pattern.ts
+// 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`);
+  }
+  if (output === undefined && project === undefined) {
+    throw new Error(`${where} declares neither output nor project — it would change nothing`);
+  }
+  const defaults = view.defaults;
+  if (defaults === undefined)
+    return;
+  if (!isRecord(defaults))
+    throw new Error(`${where}.defaults must be an object`);
+  const entries = Object.entries(defaults);
+  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/internal/route-pattern.ts
+import { z as z2 } from "zod";
 var PARAM_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function joinRoutePath(...parts) {
   const joined = parts.filter((part) => Boolean(part)).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
@@ -65,10 +117,10 @@ function resolveRouteParamsSchema(path, schema) {
   if (!schema) {
     const shape = {};
     for (const parameter of parameters)
-      shape[parameter.name] = z.string();
-    return z.object(shape);
+      shape[parameter.name] = z2.string();
+    return z2.object(shape);
   }
-  const jsonSchema = z.toJSONSchema(schema, { io: "input", unrepresentable: "any" });
+  const jsonSchema = z2.toJSONSchema(schema, { io: "input", unrepresentable: "any" });
   const properties = jsonSchema.properties;
   if (!properties) {
     throw new Error(`Route params schema for path "${path}" must be an object schema with a property per path field`);
@@ -95,6 +147,7 @@ function parseTrailingWildcard(path) {
 
 // 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)) {
@@ -123,22 +176,31 @@ function defineContract(meta, endpoints) {
       assertSafelistedBodyEndpoint(meta.prefix, key, ep);
     if ("responseMeta" in ep)
       assertResponseMetaEndpoint(meta.prefix, key, ep);
-    if (!("toolName" in ep) || !ep.toolName)
+    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 toolName "${ep.toolName}" but is not exposed on any tool transport (MCP / AGENT)`);
+      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`);
     }
-    const existing = toolTransports.get(ep.toolName);
+    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 toolName "${ep.toolName}" on transport "${t}" (endpoints: "${existing.key}" and "${key}")`);
+          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(ep.toolName, { key, transports });
+      toolTransports.set(tool.name, { key, transports });
     }
   }
   return { meta, endpoints: materializedEndpoints };
@@ -186,13 +248,7 @@ function assertRawEndpoint(prefix, key, ep) {
   const where = `Contract "${prefix}": raw endpoint "${key}"`;
   if (ep.output)
     throw new Error(`${where} cannot declare an output schema`);
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
-  if ("ui" in ep && ep.ui)
-    throw new Error(`${where} cannot set MCP ui metadata`);
-  if ("annotations" in ep && ep.annotations) {
-    throw new Error(`${where} cannot set MCP annotations`);
-  }
+  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`);
@@ -232,13 +288,47 @@ function assertStreamingResponseEndpoint(prefix, key, ep) {
     throw new Error(`${where} cannot also be rawResponse`);
   if (ep.multipart)
     throw new Error(`${where} cannot be multipart`);
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
+  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)
@@ -259,13 +349,7 @@ function assertRawBodyEndpoint(prefix, key, ep) {
   if (ep.method !== "POST" && ep.method !== "PUT" && ep.method !== "PATCH") {
     throw new Error(`${where} must use POST, PUT or PATCH`);
   }
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
-  if ("ui" in ep && ep.ui)
-    throw new Error(`${where} cannot set MCP ui metadata`);
-  if ("annotations" in ep && ep.annotations) {
-    throw new Error(`${where} cannot set MCP annotations`);
-  }
+  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`);
@@ -296,13 +380,7 @@ function assertResponseMetaEndpoint(prefix, key, ep) {
   }
   if (ep.rawResponse)
     throw new Error(`${where} cannot also be a rawResponse endpoint`);
-  if ("toolName" in ep && ep.toolName)
-    throw new Error(`${where} cannot set a toolName`);
-  if ("ui" in ep && ep.ui)
-    throw new Error(`${where} cannot set MCP ui metadata`);
-  if ("annotations" in ep && ep.annotations) {
-    throw new Error(`${where} cannot set MCP annotations`);
-  }
+  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`);
@@ -315,156 +393,5 @@ function mergeMeta(contractMeta, endpointMeta) {
     return { ...contractMeta };
   return { ...contractMeta, ...endpointMeta };
 }
-// src/contract/errors-factory.ts
-import { z as z2 } from "zod";
-function isErrorDetailsSchema(value) {
-  return value instanceof z2.ZodObject || value instanceof z2.ZodOptional && value.unwrap() instanceof z2.ZodObject;
-}
-function validateDefinition(code, definition) {
-  if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
-    throw new Error(`[stitchkit] Error "${code}" must declare an integer HTTP status from 400 to 599`);
-  }
-  if (definition.details !== undefined && !isErrorDetailsSchema(definition.details)) {
-    throw new Error(`[stitchkit] Error "${code}" details must be a Zod object or optional Zod object`);
-  }
-  if (definition.message !== undefined && (typeof definition.message !== "string" || definition.message.trim() === "")) {
-    throw new Error(`[stitchkit] Error "${code}" message must be a non-empty string`);
-  }
-}
-function defineErrors(source, mapping) {
-  const definitions = mapObjectTypeBoundary(source, (code, definition) => {
-    const name = String(code);
-    validateDefinition(name, definition);
-    return Object.freeze({ ...definition });
-  });
-  Object.freeze(definitions);
-  const errors = mapObjectTypeBoundary(definitions, (code, definition) => {
-    const name = String(code);
-    return (options = {}) => {
-      const message = options.message ?? definition.message;
-      if (definition.details === undefined) {
-        if ("details" in options) {
-          throw new Error(`[stitchkit] Error "${name}" does not declare details`);
-        }
-        return new AppError(name, message, definition.status, undefined, options.hint, undefined, definition.retryable);
-      }
-      const details = definition.details.parse(options.details);
-      return new AppError(name, message, definition.status, details, options.hint, undefined, definition.retryable);
-    };
-  });
-  Object.freeze(errors);
-  const codes = mapObjectTypeBoundary(definitions, (code) => String(code));
-  Object.freeze(codes);
-  const known = new Set(Object.keys(definitions));
-  for (const [code, target] of Object.entries(mapping?.map ?? {})) {
-    if (!isStitchErrorCode(code)) {
-      throw new Error(`[stitchkit] Error vocabulary contains unknown framework code "${code}"`);
-    }
-    if (typeof target !== "string" || !known.has(target)) {
-      throw new Error(`[stitchkit] Error vocabulary maps "${code}" to undeclared code "${String(target)}"`);
-    }
-    const status = STITCH_ERROR_STATUS[code];
-    if (definitions[target]?.status !== status) {
-      throw new Error(`[stitchkit] Error vocabulary maps "${code}" (${status}) to "${target}", declared with status ${String(definitions[target]?.status)}`);
-    }
-  }
-  for (const [statusText, target] of Object.entries(mapping?.fallback ?? {})) {
-    const status = Number(statusText);
-    if (!Number.isInteger(status) || status < 400 || status > 599) {
-      throw new Error(`[stitchkit] Error vocabulary fallback status "${statusText}" must be an integer from 400 to 599`);
-    }
-    if (typeof target !== "string" || !known.has(target)) {
-      throw new Error(`[stitchkit] Error vocabulary fallback ${status} names undeclared code "${String(target)}"`);
-    }
-    if (definitions[target]?.status !== status) {
-      throw new Error(`[stitchkit] Error vocabulary fallback ${status} must name a code with status ${status}`);
-    }
-  }
-  if (mapping?.exhaustive === true) {
-    for (const code of Object.keys(STITCH_ERROR_STATUS)) {
-      if (!Object.hasOwn(mapping.map, code)) {
-        throw new Error(`[stitchkit] Exhaustive error vocabulary is missing "${code}"`);
-      }
-    }
-  }
-  const codeMap = {};
-  for (const [stitchCode, status] of typedEntries(STITCH_ERROR_STATUS)) {
-    const code = mapping?.map?.[stitchCode] ?? mapping?.fallback?.[status];
-    if (code === undefined)
-      continue;
-    if (!known.has(code)) {
-      throw new Error(`[stitchkit] Error vocabulary maps "${stitchCode}" to undeclared code "${code}"`);
-    }
-    codeMap[stitchCode] = code;
-  }
-  Object.freeze(codeMap);
-  const vocabularyCodeMap = transportResult(codeMap);
-  return Object.freeze({
-    errors,
-    codes,
-    definitions,
-    isCode: (code) => known.has(code),
-    codeMap: vocabularyCodeMap
-  });
-}
-// src/contract/factory.ts
-function createContractFactory(config) {
-  const scoped = (meta, endpoints) => {
-    const validated = defineContract({ prefix: meta.prefix }, endpoints);
-    return {
-      endpoints: validated.endpoints,
-      meta: { ...meta, prefix: meta.prefix, scope: meta.scope }
-    };
-  };
-  if (config?.toolExposure !== "explicit")
-    return { defineContract: scoped };
-  const explicit = (meta, endpoints) => {
-    const materialized = mapObjectTypeBoundary(endpoints, (_key, endpoint) => endpoint.expose ? endpoint : { ...endpoint, expose: ["HTTP"] });
-    return scoped(meta, materialized);
-  };
-  return { defineContract: explicit };
-}
-// src/contract/pagination.ts
-import { z as z3 } from "zod";
-function paginatedSchema(itemSchema) {
-  return z3.object({
-    items: z3.array(itemSchema),
-    nextCursor: z3.string().nullable()
-  });
-}
-function toBase64Url(str) {
-  return bytesToBase64Url(new TextEncoder().encode(str));
-}
-function fromBase64Url(value) {
-  return new TextDecoder().decode(base64UrlToBytes(value));
-}
-function encodeCursor(value) {
-  return toBase64Url(JSON.stringify(value));
-}
-function decodeCursor(cursor, schema) {
-  if (!cursor)
-    return null;
-  try {
-    const parsed = schema.safeParse(JSON.parse(fromBase64Url(cursor)));
-    return parsed.success ? parsed.data : null;
-  } catch {
-    return null;
-  }
-}
-// src/contract/stream.ts
-import { z as z4 } from "zod";
-var DEFAULT_CONTRACT_STREAM_FRAME_BYTES = 256 * 1024;
-var ContractStreamFrameSchema = z4.discriminatedUnion("type", [
-  z4.object({ type: z4.literal("data"), data: z4.unknown() }).strict(),
-  z4.object({
-    type: z4.literal("error"),
-    error: z4.object({
-      code: z4.string(),
-      message: z4.string().optional(),
-      details: z4.unknown().optional(),
-      hint: z4.string().optional()
-    }).strict()
-  }).strict(),
-  z4.object({ type: z4.literal("end") }).strict()
-]);
-export { joinRoutePath, resolveRouteParamsSchema, parseTrailingWildcard, ALL_TRANSPORTS, defineContract, mergeMeta, defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor, DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };
+
+export { joinRoutePath, resolveRouteParamsSchema, parseTrailingWildcard, withToolView, ALL_TRANSPORTS, TOOL_TRANSPORTS, defineContract, mergeMeta };

package/dist/{index-wnfk50r0.js → index-h6eeys1v.js}

@@ -56,7 +56,7 @@ function aggregateObservabilityStatus(surfaces, closed) {
   return ObservabilitySinkStatusSchema.parse({ ...totals, closed });
 }
 
-// src/internal/observability-sink.ts
+// src/observability/bounded-sink.ts
 function assertDrainBound(bound) {
   const timeoutMs = bound?.timeoutMs;
   if (timeoutMs === undefined)

package/dist/{index-77fekveh.js → index-hffjpmq9.js}

@@ -11,20 +11,6 @@ function callRuntimeHandler(handler, context) {
   }
   return Reflect.apply(handler, undefined, [context]);
 }
-function executableAgentRuntimeTools(tools) {
-  for (const tool of tools) {
-    if (typeof tool.handler !== "function") {
-      throw new TypeError(`Runtime tool "${tool.name}" must provide a handler`);
-    }
-    if (tool.present?.agent !== undefined && typeof tool.present.agent !== "function") {
-      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter must be a function`);
-    }
-    if (tool.present?.agent !== undefined && tool.output === undefined) {
-      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter requires an output schema`);
-    }
-  }
-  return tools;
-}
 function transportResult(value) {
   return value;
 }
@@ -41,4 +27,4 @@ function mapObjectTypeBoundary(source, mapper) {
   return mapObject(source, (key, value) => mapper(key, value));
 }
 
-export { typedEntries, isRecord, callRuntimeHandler, executableAgentRuntimeTools, transportResult, mapObject, mapObjectTypeBoundary };
+export { typedEntries, isRecord, callRuntimeHandler, transportResult, mapObject, mapObjectTypeBoundary };

package/dist/{index-yn8remb1.js → index-j05z5gn4.js}

@@ -1,18 +1,22 @@
 import {
   getRequestContext,
   runWithRequestContext
-} from "./index-tmwcrptx.js";
+} from "./index-zfrhfn82.js";
+import {
+  coerceJsonArgs
+} from "./index-1zbbzgfh.js";
+import {
+  applyToolViewDefaults,
+  objectShapeKeys,
+  projectToolView
+} from "./index-dydjcp8z.js";
 import {
-  formatZodError,
   normalizeError,
   validateDeclaredOutput
-} from "./index-e0znv5gn.js";
-import {
-  coerceJsonArgs
-} from "./index-7zbps32p.js";
+} from "./index-znfs20ss.js";
 import {
-  objectShapeKeys
-} from "./index-h9etkkyk.js";
+  formatZodError
+} from "./index-p5r7qpdd.js";
 import {
   AppError,
   STITCH_ERROR_STATUS,
@@ -24,7 +28,7 @@ import {
 } from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
 // src/tools/execute.ts
 class ToolExecutionControlError extends Error {
@@ -45,7 +49,10 @@ function isToolExecutionControlError(value) {
   return value instanceof ToolExecutionControlError;
 }
 var normalizedToolErrors = new WeakMap;
-function parseToolCallArguments(method, callArgs, coerceJson) {
+function parseToolCallArguments(method, callArgs, {
+  coerceJson = false,
+  toolSurface = false
+} = {}) {
   const paramKeys = new Set(objectShapeKeys(method.paramsSchema));
   let paramArgs = {};
   let inputArgs = {};
@@ -61,6 +68,8 @@ function parseToolCallArguments(method, callArgs, coerceJson) {
     paramArgs = coerceJsonArgs(paramArgs, method.paramsSchema);
     inputArgs = coerceJsonArgs(inputArgs, method.inputSchema);
   }
+  if (toolSurface)
+    inputArgs = applyToolViewDefaults(inputArgs, method.toolView?.defaults);
   let params;
   if (method.paramsSchema) {
     let result;
@@ -116,8 +125,9 @@ function toolErrorFromResult(result) {
 function toolCauseFromResult(result) {
   return normalizedToolErrors.get(result)?.cause;
 }
-async function executeToolMethod(method, toolName, rawArgs, context, hooks, lifecycle, coerceJson = false, onOutputStrip, extension, finalizeOutput) {
-  return inToolCallContext({ source: context.source, toolName, method }, () => runToolMethod(method, toolName, rawArgs, context, hooks, lifecycle, coerceJson, onOutputStrip, extension, finalizeOutput));
+async function executeToolMethod(method, call, options = {}) {
+  const { toolName, context } = call;
+  return inToolCallContext({ source: context.source, toolName, method }, () => runToolMethod(method, call, options));
 }
 function inToolCallContext(call, body) {
   const parent = getRequestContext();
@@ -135,7 +145,15 @@ function inToolCallContext(call, body) {
     action: call.method.key
   }, body);
 }
-async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycle, coerceJson, onOutputStrip, extension, finalizeOutput) {
+async function runToolMethod(method, { toolName, rawArgs, context }, {
+  hooks,
+  lifecycle,
+  coerceJson = false,
+  onOutputStrip,
+  extension,
+  finalizeOutput,
+  toolSurface = false
+}) {
   const startedAt = Date.now();
   let hookContext = context;
   const finish = async (result, thrown) => {
@@ -245,7 +263,7 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
     callArgs = extensionKeys ? Object.fromEntries(Object.entries(rewrittenArgs).filter(([key]) => !extensionKeys.has(key))) : rewrittenArgs;
     rewrittenArgsApplied = true;
   }
-  const parsed = parseToolCallArguments(method, callArgs, coerceJson);
+  const parsed = parseToolCallArguments(method, callArgs, { coerceJson, toolSurface });
   if (!parsed.ok) {
     return parsed.thrown !== undefined ? finishThrown(parsed.thrown) : finish({ ok: false, code: "VALIDATION_ERROR", details: { message: parsed.message } });
   }
@@ -276,6 +294,24 @@ async function runToolMethod(method, toolName, rawArgs, context, hooks, lifecycl
       });
     }
     data = checked.data;
+    if (toolSurface && method.toolView && method.outputSchema) {
+      const viewed = projectToolView({
+        view: method.toolView,
+        fullSchema: method.outputSchema,
+        full: data,
+        call: { input, source: context.source },
+        operation: `${method.serviceName}.${method.key}`,
+        onStripped: onOutputStrip
+      });
+      if (!viewed.ok) {
+        return finish({
+          ok: false,
+          code: "INTERNAL_SERVER_ERROR",
+          details: { message: viewed.message }
+        });
+      }
+      data = viewed.data;
+    }
     if (finalizeOutput)
       data = await finalizeOutput(data);
     const output = (data === undefined || data === null) && !method.outputSchema ? { status: "ok" } : data;

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-fq77yfzc.js → index-kj2wbeta.js}

@@ -20,7 +20,7 @@ import {
 } from "./index-qmy6zq75.js";
 import {
   defineRuntimeTool
-} from "./index-vjpvjqpn.js";
+} from "./index-v38qyerb.js";
 import {
   conflict,
   forbidden

package/dist/index-kvj7f4hq.js

@@ -0,0 +1,39 @@
+import {
+  mergeMeta,
+  resolveRouteParamsSchema
+} from "./index-gyr48nzg.js";
+
+// src/server/contract-method.ts
+var HTTP_ONLY = Object.freeze(["HTTP"]);
+function contractMethodFields(contract, key, endpoint) {
+  const groupScope = contract.meta.scope ?? "public";
+  return {
+    method: endpoint.method,
+    path: endpoint.path,
+    desc: endpoint.desc,
+    serviceName: contract.meta.prefix,
+    key,
+    toolName: endpoint.tool?.name,
+    expose: endpoint.rawResponse || endpoint.rawBody || endpoint.responseMeta || "stream" in endpoint && endpoint.stream ? HTTP_ONLY : endpoint.expose,
+    scope: endpoint.scope ?? groupScope,
+    paramsSchema: resolveRouteParamsSchema(endpoint.path, endpoint.params),
+    inputSchema: endpoint.input,
+    outputSchema: endpoint.output,
+    toolView: endpoint.tool?.view,
+    stream: "stream" in endpoint ? endpoint.stream : undefined,
+    multipart: endpoint.multipart,
+    maxJsonBodyBytes: endpoint.maxJsonBodyBytes,
+    idempotent: endpoint.idempotent,
+    ui: endpoint.tool?.ui,
+    annotations: endpoint.tool?.annotations,
+    mcp: endpoint.tool?.mcp,
+    meta: mergeMeta(contract.meta.meta, endpoint.meta),
+    rawResponse: endpoint.rawResponse,
+    rawBody: endpoint.rawBody,
+    safelistedBody: endpoint.safelistedBody,
+    responseMeta: endpoint.responseMeta,
+    contentType: "contentType" in endpoint ? endpoint.contentType : undefined
+  };
+}
+
+export { contractMethodFields };

package/dist/{index-4fpa9dy2.js → index-m9zn6cpq.js}

@@ -1,4 +1,4 @@
-// src/tools/async-operation-contract.ts
+// src/tools/operations/async-operation-contract.ts
 import { z } from "zod";
 var AsyncOperationCancelResultSchema = z.discriminatedUnion("outcome", [
   z.object({ outcome: z.literal("accepted") }),
@@ -15,7 +15,7 @@ function createAsyncOperationSnapshotSchema(config) {
     z.object({ phase: z.literal("cancelled"), ...progress })
   ]);
 }
-// src/tools/view-file-contract.ts
+// src/tools/transfer/view-file-contract.ts
 import { z as z2 } from "zod";
 var MAX_VIEW_FILES = 20;
 var McpAnnotationsSchema = z2.object({