stitchkit 0.104.1 → 0.105.0

package/dist/index-3h0ztg0z.js

@@ -0,0 +1,285 @@
+import {
+  raceAbort
+} from "./index-b0kddvzw.js";
+
+// src/internal/secure-fetch.ts
+import { lookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+var NUMERIC_HOST = /^(0x[0-9a-f]+|[0-9.]+)$/i;
+var MAX_REDIRECTS = 5;
+function assertHttpUrl(url) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`refusing to fetch a non-http(s) URL (${url.protocol})`);
+  }
+}
+function mappedIpv4FromIpv6(ip) {
+  const rest = ip.startsWith("::ffff:") ? ip.slice("::ffff:".length) : ip.startsWith("0:0:0:0:0:ffff:") ? ip.slice("0:0:0:0:0:ffff:".length) : null;
+  if (rest === null)
+    return null;
+  if (isIP(rest) === 4)
+    return rest;
+  const [hiRaw, loRaw, extra] = rest.split(":");
+  if (hiRaw === undefined || loRaw === undefined || extra !== undefined)
+    return null;
+  if (!/^[0-9a-f]{1,4}$/i.test(hiRaw) || !/^[0-9a-f]{1,4}$/i.test(loRaw))
+    return null;
+  const hi = Number.parseInt(hiRaw, 16);
+  const lo = Number.parseInt(loRaw, 16);
+  return [hi >> 8, hi & 255, lo >> 8, lo & 255].join(".");
+}
+function ipv6Words(ip) {
+  const halves = ip.toLowerCase().split("::");
+  if (halves.length > 2)
+    return null;
+  const head = halves[0] ? halves[0].split(":") : [];
+  const tail = halves[1] ? halves[1].split(":") : [];
+  const missing = 8 - head.length - tail.length;
+  if (halves.length === 1 && missing !== 0 || missing < 0)
+    return null;
+  const parts = halves.length === 2 ? [...head, ...Array(missing).fill("0"), ...tail] : head;
+  if (parts.length !== 8)
+    return null;
+  const words = [];
+  for (const part of parts) {
+    if (!/^[0-9a-f]{1,4}$/i.test(part))
+      return null;
+    words.push(Number.parseInt(part, 16));
+  }
+  return words;
+}
+function isPrivateIp(ip) {
+  const normalized = ip.replace(/^\[|\]$/g, "");
+  const family = isIP(normalized);
+  if (family === 4) {
+    const [a, b] = normalized.split(".").map(Number);
+    if (a === undefined || b === undefined)
+      return true;
+    const value = normalized.split(".").map(Number).reduce((total, octet) => total * 256 + octet, 0);
+    const inCidr = (base, prefix) => {
+      const baseValue = base.split(".").map(Number).reduce((total, octet) => total * 256 + octet, 0);
+      const size = 2 ** (32 - prefix);
+      return value >= baseValue && value < baseValue + size;
+    };
+    const blockedRanges = [
+      ["0.0.0.0", 8],
+      ["10.0.0.0", 8],
+      ["100.64.0.0", 10],
+      ["127.0.0.0", 8],
+      ["169.254.0.0", 16],
+      ["172.16.0.0", 12],
+      ["192.0.0.0", 24],
+      ["192.0.2.0", 24],
+      ["192.31.196.0", 24],
+      ["192.52.193.0", 24],
+      ["192.88.99.0", 24],
+      ["192.168.0.0", 16],
+      ["192.175.48.0", 24],
+      ["198.18.0.0", 15],
+      ["198.51.100.0", 24],
+      ["203.0.113.0", 24],
+      ["224.0.0.0", 4],
+      ["240.0.0.0", 4]
+    ];
+    return blockedRanges.some(([base, prefix]) => inCidr(base, prefix));
+  }
+  if (family === 6) {
+    const lower = normalized.toLowerCase();
+    const mapped = mappedIpv4FromIpv6(lower);
+    if (mapped)
+      return isPrivateIp(mapped);
+    const words = ipv6Words(lower);
+    if (!words)
+      return true;
+    const [first, second, third] = words;
+    if (first === undefined || second === undefined || third === undefined)
+      return true;
+    return first === 0 || first === 100 && second === 65435 && third === 1 || first === 256 && second === 0 || first === 8193 && (second <= 511 || second === 3512) || first === 8194 || first === 16383 || first === 24320 || (first & 65024) === 64512 || (first & 65472) === 65152 || (first & 65280) === 65280;
+  }
+  return false;
+}
+async function assertPublicUrl(url, signal) {
+  await resolvePublicAddress(url, signal);
+}
+async function fetchGuarded(start, allowPrivate, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 15000;
+  const bodyTimeoutMs = options.bodyTimeoutMs ?? 120000;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("timeoutMs must be positive");
+  }
+  if (!Number.isFinite(bodyTimeoutMs) || bodyTimeoutMs <= 0) {
+    throw new Error("bodyTimeoutMs must be positive");
+  }
+  const controller = new AbortController;
+  const signal = options.signal ? AbortSignal.any([options.signal, controller.signal]) : controller.signal;
+  const headerTimer = setTimeout(() => {
+    controller.abort(new Error(`fetch did not produce response headers within ${timeoutMs}ms`));
+  }, timeoutMs);
+  headerTimer.unref?.();
+  let settled = false;
+  try {
+    let url = start;
+    for (let hop = 0;hop <= MAX_REDIRECTS; hop++) {
+      if (allowPrivate)
+        assertHttpUrl(url);
+      else
+        await assertPublicUrl(url, signal);
+      const res = await fetch(url, { redirect: "manual", signal });
+      const location = res.status >= 300 && res.status < 400 ? res.headers.get("location") : null;
+      if (location === null) {
+        settled = true;
+        clearTimeout(headerTimer);
+        const bodyTimer = setTimeout(() => {
+          controller.abort(new Error(`fetch body was not consumed within ${bodyTimeoutMs}ms`));
+        }, bodyTimeoutMs);
+        bodyTimer.unref?.();
+        return res;
+      }
+      await res.body?.cancel();
+      url = new URL(location, url);
+    }
+    throw new Error("too many redirects");
+  } finally {
+    if (!settled)
+      clearTimeout(headerTimer);
+  }
+}
+
+class PrivateAddressRefusal extends Error {
+  name = "PrivateAddressRefusal";
+}
+async function resolvePublicAddress(url, signal) {
+  assertHttpUrl(url);
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (!host)
+    throw new Error("refusing to fetch a URL with no host");
+  const ipFamily = isIP(host);
+  if (ipFamily) {
+    if (isPrivateIp(host))
+      throw new PrivateAddressRefusal("refusing to fetch a private address");
+    return { address: host, family: ipFamily === 6 ? 6 : 4 };
+  }
+  if (NUMERIC_HOST.test(host)) {
+    throw new PrivateAddressRefusal("refusing to fetch a non-canonical numeric host");
+  }
+  if (host === "localhost" || host.endsWith(".local") || host.endsWith(".internal")) {
+    throw new PrivateAddressRefusal("refusing to fetch an internal host");
+  }
+  const pending = lookup(host, { all: true });
+  const records = signal ? await raceAbort(pending, signal) : await pending;
+  for (const record of records) {
+    if (isPrivateIp(record.address)) {
+      throw new PrivateAddressRefusal("refusing to fetch a host that resolves to a private address");
+    }
+  }
+  const record = records[0];
+  if (!record)
+    throw new Error("public hostname resolved to no addresses");
+  return { address: record.address, family: record.family === 6 ? 6 : 4 };
+}
+async function fetchPinnedDocument(start, options) {
+  if (!Number.isInteger(options.maxBytes) || options.maxBytes < 1) {
+    throw new Error("maxBytes must be a positive integer");
+  }
+  if (!Number.isFinite(options.timeoutMs) || options.timeoutMs <= 0) {
+    throw new Error("timeoutMs must be positive");
+  }
+  let url = start;
+  const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
+  if (!Number.isInteger(maxRedirects) || maxRedirects < 0) {
+    throw new Error("maxRedirects must be a non-negative integer");
+  }
+  const signal = AbortSignal.timeout(options.timeoutMs);
+  for (let hop = 0;hop <= maxRedirects; hop++) {
+    if (options.requireHttps && url.protocol !== "https:") {
+      throw new Error("document URL and every redirect must use https");
+    }
+    if (url.username || url.password) {
+      throw new Error("document URL cannot contain credentials");
+    }
+    const resolved = await resolvePublicAddress(url, signal);
+    const transport = url.protocol === "https:" ? httpsRequest : httpRequest;
+    const response = await new Promise((resolve, reject) => {
+      const request = transport({
+        protocol: url.protocol,
+        hostname: resolved.address,
+        family: resolved.family,
+        port: url.port || undefined,
+        path: `${url.pathname}${url.search}`,
+        method: "GET",
+        signal,
+        servername: url.hostname,
+        headers: {
+          host: url.host,
+          accept: "application/json",
+          ...options.headers
+        }
+      }, (incoming) => {
+        const headers = new Headers;
+        for (const [name, value] of Object.entries(incoming.headers)) {
+          if (Array.isArray(value)) {
+            for (const item of value)
+              headers.append(name, item);
+          } else if (value !== undefined) {
+            headers.set(name, value);
+          }
+        }
+        const chunks = [];
+        let total = 0;
+        incoming.on("data", (chunk) => {
+          total += chunk.byteLength;
+          if (total > options.maxBytes) {
+            incoming.destroy(new Error("response body exceeds configured byte limit"));
+            return;
+          }
+          chunks.push(chunk);
+        });
+        incoming.once("error", reject);
+        incoming.once("end", () => {
+          const body = new Uint8Array(total);
+          let offset = 0;
+          for (const chunk of chunks) {
+            body.set(chunk, offset);
+            offset += chunk.byteLength;
+          }
+          resolve({ status: incoming.statusCode ?? 0, headers, body, url });
+        });
+      });
+      request.once("error", reject);
+      request.end();
+    });
+    if (response.status < 300 || response.status >= 400)
+      return response;
+    const location = response.headers.get("location");
+    if (!location)
+      return response;
+    url = new URL(location, url);
+  }
+  throw new Error("too many redirects");
+}
+async function readCapped(res, max) {
+  const reader = res.body?.getReader();
+  if (!reader)
+    return Buffer.alloc(0);
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      total += value.length;
+      if (total > max) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks);
+}
+
+export { fetchGuarded, PrivateAddressRefusal, fetchPinnedDocument, readCapped };

package/dist/{index-g95fk660.js → index-4vsby8n8.js}

@@ -1,6 +1,9 @@
 import {
   attemptExclusiveLock
-} from "./index-za6j7nwy.js";
+} from "./index-dsnjzb62.js";
+import {
+  sleep
+} from "./index-eemvahkc.js";
 
 // src/internal/with-exclusive-lock.ts
 class ExclusiveLockError2 extends Error {
@@ -16,7 +19,6 @@ class ExclusiveLockError2 extends Error {
   }
 }
 var DEFAULT_TIMEOUT_MS = 1e4;
-var DEFAULT_OWNERLESS_GRACE_MS = 5000;
 var FIRST_RETRY_MS = 10;
 var MAX_RETRY_MS = 100;
 function nonNegative(name, value, fallback) {
@@ -39,21 +41,10 @@ function describeEvidence(diagnosis) {
   const identity = diagnosis.identity === undefined ? "" : `, identity ${diagnosis.identity}`;
   return ` (${diagnosis.attribution}, liveness ${diagnosis.liveness}${identity})`;
 }
-function pause(ms, signal) {
-  return new Promise((resolve) => {
-    const done = () => {
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", done);
-      resolve();
-    };
-    const timer = setTimeout(done, ms);
-    signal?.addEventListener("abort", done, { once: true });
-  });
-}
 async function withExclusiveLock2(path, run, options = {}) {
   const label = options.label ?? path;
   const timeoutMs = nonNegative("timeoutMs", options.timeoutMs, DEFAULT_TIMEOUT_MS);
-  const ownerlessGraceMs = options.ownerlessGraceMs === null ? null : nonNegative("ownerlessGraceMs", options.ownerlessGraceMs, DEFAULT_OWNERLESS_GRACE_MS);
+  const ownerlessGraceMs = options.ownerlessGraceMs === undefined || options.ownerlessGraceMs === null ? options.ownerlessGraceMs : nonNegative("ownerlessGraceMs", options.ownerlessGraceMs, 0);
   const mode = options.mode ?? 384;
   if (!Number.isInteger(mode) || mode < 0 || mode > 511)
     throw new RangeError("[stitchkit] withExclusiveLock: mode must be permission bits from 0000 to 0777");
@@ -108,7 +99,9 @@ async function withExclusiveLock2(path, run, options = {}) {
       const holder = attempt.diagnosis?.owner ?? null;
       throw new ExclusiveLockError2("LOCK_TIMEOUT", label, holder, `[stitchkit] the lock on "${label}" is held by ${describeHolder(holder)}${describeEvidence(attempt.diagnosis)}; gave up after ${timeoutMs} ms`, { cause: attempt.diagnosis?.cause ?? attempt.error });
     }
-    await pause(Math.min(delay * (0.5 + Math.random() / 2), remaining), signal);
+    await sleep(Math.min(delay * (0.5 + Math.random() / 2), remaining), signal).catch(() => {
+      return;
+    });
     delay = Math.min(delay * 2, MAX_RETRY_MS);
   }
 }

package/dist/index-556g5hsh.js

@@ -0,0 +1,17 @@
+import {
+  AppError2
+} from "./index-j9gxbztg.js";
+
+// src/tools/internal/tool-error-projection.ts
+var TOOL_ERROR_PROJECTION = Symbol.for("stitchkit.toolErrorProjection");
+function projectedToolError(error) {
+  if (typeof error !== "object" || error === null)
+    return;
+  const project = Reflect.get(error, TOOL_ERROR_PROJECTION);
+  if (typeof project !== "function")
+    return;
+  const projected = Reflect.apply(project, error, []);
+  return AppError2.is(projected) ? projected : undefined;
+}
+
+export { TOOL_ERROR_PROJECTION, projectedToolError };

package/dist/{index-adhgd4pe.js → index-5p55xreg.js}

@@ -2,7 +2,7 @@ import {
   AgentStoreEventEnvelopeSchema2,
   AgentStoreEventPageSchema2,
   AgentRecoverablePageSchema2
-} from "./index-r5hsgkz5.js";
+} from "./index-0gs4ymfj.js";
 import {
   AgentRecordIdSchema2,
   AgentMessageSchema2
@@ -16,7 +16,7 @@ import {
   isActiveRunState,
   replaceMessage,
   createAgentRuntimeStore2
-} from "./index-ssmd41kh.js";
+} from "./index-d2h99n7d.js";
 
 // src/agent-runtime/store-memory.ts
 import { z } from "zod";

package/dist/index-5w6t91ze.js

@@ -0,0 +1,47 @@
+import {
+  jsonDataRefusal
+} from "./index-m6w6jtda.js";
+import {
+  serializeCanonicalJson
+} from "./index-zsvzhjtk.js";
+
+// src/primitives/canonical-json.ts
+import { z } from "zod";
+var CanonicalJsonOptionsSchema = z.strictObject({
+  maxDepth: z.number().int().min(0).max(100).default(100),
+  maxNodes: z.number().int().positive().default(1e5),
+  maxBytes: z.number().int().positive().default(1024 * 1024)
+});
+var MESSAGES = {
+  cycle: "Value contains a cycle",
+  "negative-zero": "Value contains -0, which JSON cannot carry",
+  depth: "Value is nested deeper than maxDepth",
+  nodes: "Value has more nodes than maxNodes",
+  bytes: "Value is longer than maxBytes in UTF-8",
+  "not-json": "Expected bounded plain JSON: dense arrays, finite numbers, plain objects, no accessors"
+};
+
+class CanonicalJsonError2 extends TypeError {
+  reason;
+  constructor(reason) {
+    super(MESSAGES[reason]);
+    this.reason = reason;
+    this.name = "CanonicalJsonError";
+  }
+}
+function canonicalJson2(value, options = {}) {
+  return serialize(value, options, false);
+}
+function canonicalZodJson(value, options = {}) {
+  return serialize(value, options, true);
+}
+function serialize(value, options, zodJson) {
+  const limits = CanonicalJsonOptionsSchema.parse(options);
+  const snapshot = {};
+  const refusal = jsonDataRefusal(value, { ...limits, omitObjectUndefined: true, zodJson }, snapshot);
+  if (refusal !== undefined)
+    throw new CanonicalJsonError2(refusal);
+  return serializeCanonicalJson(snapshot.value);
+}
+
+export { CanonicalJsonError2, canonicalJson2, canonicalZodJson };

package/dist/{index-9pw0a51a.js → index-6yxhe58g.js}

@@ -34,6 +34,28 @@ function acceptsRawString(schema) {
   }
   return false;
 }
+function arrayMembers(schema) {
+  if (schema instanceof z.ZodArray)
+    return [schema];
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return arrayMembers(schema.unwrap());
+  }
+  if (schema instanceof z.ZodUnion) {
+    return schema.def.options.flatMap((option) => arrayMembers(option));
+  }
+  return [];
+}
+function writtenAsList(text, schema) {
+  if (!text.trimStart().startsWith("["))
+    return false;
+  let parsed;
+  try {
+    parsed = safeJsonParse(text);
+  } catch {
+    return false;
+  }
+  return Array.isArray(parsed) && arrayMembers(schema).some((m) => m.safeParse(parsed).success);
+}
 function matchingVariant(union, value) {
   const disc = union.def.discriminator;
   const tag = value[disc];
@@ -48,16 +70,27 @@ function matchingVariant(union, value) {
   }
   return;
 }
-function coerceValue(value, schema) {
+function coerceValue(value, schema, path) {
   if (!schema)
     return value;
   if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
-    return coerceValue(value, schema.unwrap());
+    return coerceValue(value, schema.unwrap(), path);
   }
   let current = value;
   if (typeof current === "string" && needsJsonCoercion(schema)) {
-    if (acceptsRawString(schema))
+    if (acceptsRawString(schema)) {
+      if (writtenAsList(current, schema)) {
+        throw new z.ZodError([
+          {
+            code: "custom",
+            path: [...path],
+            message: `${path.join(".")} is a list written as text — pass the array itself, not JSON written as text`,
+            input: current
+          }
+        ]);
+      }
       return current;
+    }
     try {
       current = safeJsonParse(current);
     } catch {
@@ -68,21 +101,21 @@ function coerceValue(value, schema) {
     const shape = schema.shape;
     const out = {};
     for (const [key, item] of Object.entries(current)) {
-      out[key] = coerceValue(item, shape[key]);
+      out[key] = coerceValue(item, shape[key], [...path, key]);
     }
     return out;
   }
   if (schema instanceof z.ZodArray && Array.isArray(current)) {
-    return current.map((item) => coerceValue(item, schema.element));
+    return current.map((item, index) => coerceValue(item, schema.element, [...path, index]));
   }
   if (schema instanceof z.ZodDiscriminatedUnion && isRecord(current)) {
     const variant = matchingVariant(schema, current);
-    return variant ? coerceValue(current, variant) : current;
+    return variant ? coerceValue(current, variant, path) : current;
   }
   return current;
 }
 function coerceJsonArgs2(args, schema) {
-  const coerced = coerceValue(args, schema);
+  const coerced = coerceValue(args, schema, []);
   return isRecord(coerced) ? coerced : args;
 }
 

package/dist/{index-6d9xaxw1.js → index-8ks9b85e.js}

@@ -1,7 +1,7 @@
 import {
   AppError2,
   STITCH_ERROR_STATUS2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 
 // src/agent-runtime/sandbox.ts
 import { z } from "zod";
@@ -21,16 +21,38 @@ var AgentSandboxGradeSchema2 = z.discriminatedUnion("grade", [
   z.object({ grade: z.literal("unavailable"), reason: z.string().min(1) }).strict()
 ]);
 var probes = new WeakMap;
-function probeAgentProcessSandbox2(sandbox, options = {}) {
+var PROBE_FAILED = "sandbox probe failed";
+var PROBE_INVALID = "sandbox probe returned no valid grade";
+async function runProbe(sandbox) {
+  let value;
+  try {
+    value = await sandbox.probe();
+  } catch (cause) {
+    return { grade: { grade: "unavailable", reason: PROBE_FAILED }, cause };
+  }
+  const parsed = AgentSandboxGradeSchema2.safeParse(value);
+  if (parsed.success)
+    return { grade: parsed.data };
+  return { grade: { grade: "unavailable", reason: PROBE_INVALID }, cause: parsed.error };
+}
+function probeAgentProcessSandboxOutcome(sandbox, options = {}) {
   if (options.refresh)
     probes.delete(sandbox);
   const present = probes.get(sandbox);
   if (present)
     return present;
-  const pending = Promise.resolve(sandbox.probe()).then((grade) => AgentSandboxGradeSchema2.parse(grade));
+  const pending = runProbe(sandbox);
   probes.set(sandbox, pending);
   return pending;
 }
+async function probeAgentProcessSandbox2(sandbox, options = {}) {
+  const fresh = options.refresh === true || !probes.has(sandbox);
+  const outcome = await probeAgentProcessSandboxOutcome(sandbox, options);
+  if (fresh && outcome.cause !== undefined) {
+    process.emitWarning(new Error("Sandbox probe failed", { cause: outcome.cause }));
+  }
+  return outcome.grade;
+}
 function missingSandboxRestrictions2(grade, required) {
   if (grade.grade === "unavailable")
     return required;
@@ -54,7 +76,13 @@ async function recordAgentSandboxProbe2(input) {
 
 // src/agent-runtime/coding-tool-refusals.ts
 function codingRefusal(code, message, options = {}) {
-  throw new AppError2(code, message, STITCH_ERROR_STATUS2[code], { message, ...options.details }, options.hint);
+  throw new AppError2(code, {
+    message,
+    status: STITCH_ERROR_STATUS2[code],
+    details: { message, ...options.details },
+    hint: options.hint,
+    ..."cause" in options && { cause: options.cause }
+  });
 }
 function codingPathRefusal(code, message, path, options = {}) {
   codingRefusal(code, message, {
@@ -98,4 +126,4 @@ function refuseUnknownSpillReference(reference) {
   });
 }
 
-export { AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, codingPathRefusal, refuseMissingCodingPath, refuseUnknownSpillReference };
+export { AgentSandboxRestrictionSchema2, AgentSandboxGradeSchema2, probeAgentProcessSandboxOutcome, probeAgentProcessSandbox2, missingSandboxRestrictions2, recordAgentSandboxProbe2, codingRefusal, codingPathRefusal, refuseMissingCodingPath, refuseUnknownSpillReference };

package/dist/{index-bhb950qs.js → index-916yh4e2.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-ct75c3at.js";
 import {
   AppError2
-} from "./index-x928baz2.js";
+} from "./index-j9gxbztg.js";
 import {
   resolvePropagationContext2
 } from "./index-yex7eg1v.js";
@@ -14,20 +14,23 @@ import {
   validateResolvedInputRounds,
   presentationMetadata,
   prepareProjectedMcpTools
-} from "./index-77nxk6ay.js";
+} from "./index-r393tnfp.js";
 import {
   parseToolCallArguments,
   toolResultFromError,
   observed
-} from "./index-2vnh05w4.js";
+} from "./index-2k91mewf.js";
 import {
   collectTools2,
   createToolRunner,
   formatToolError
-} from "./index-2hyavjjj.js";
+} from "./index-wbhdzxar.js";
 import {
   redact2
 } from "./index-e6c2spsd.js";
+import {
+  collectToolSurface
+} from "./index-pz3y6b6g.js";
 import {
   DEFAULT_CORS_ALLOW_HEADERS2,
   DEFAULT_PROCESS_SIGNALS,
@@ -35,9 +38,6 @@ import {
   reportSignalError,
   guardSignalCallback
 } from "./index-yk4g8805.js";
-import {
-  collectToolSurface
-} from "./index-a0zzh8ak.js";
 import {
   argumentsDigest
 } from "./index-r7a7r7ha.js";
@@ -374,7 +374,7 @@ async function runRoundFailure(tool, rawArgs, runTool, context, code, message) {
       ...tool.method,
       outputSchema: undefined,
       handler: () => {
-        throw new AppError2(code, message, 400);
+        throw new AppError2(code, { message, status: 400 });
       }
     }
   }, rawArgs, context);
@@ -653,15 +653,24 @@ function registerMcpTool(server, presentation, descriptor, config) {
         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);
+            throw new AppError2("INTERNAL_SERVER_ERROR", {
+              message: "Runtime MCP presenter did not return a result",
+              status: 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);
+            throw new AppError2("INTERNAL_SERVER_ERROR", {
+              message: "Runtime MCP presenter cannot set framework-owned structuredContent or isError",
+              status: 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);
+            throw new AppError2("INTERNAL_SERVER_ERROR", {
+              message: "Runtime MCP presenter returned an invalid CallToolResult",
+              status: 500
+            });
           }
           return response;
         }
@@ -700,6 +709,9 @@ function registerMcpTool(server, presentation, descriptor, config) {
 }
 
 // src/tools/mcp/runtime-tools.ts
+function isMcpPresenter(value) {
+  return typeof value === "function";
+}
 function mountPreparedRuntimeMcp(server, tools, config) {
   const runTool = createToolRunner({
     source: "mcp",
@@ -711,7 +723,8 @@ function mountPreparedRuntimeMcp(server, tools, config) {
     onOutputStrip: config.onOutputStrip
   });
   for (const { definition, descriptor } of tools) {
-    const present = definition.present?.mcp;
+    const { present: presenters } = definition;
+    const present = isRecord(presenters) && isMcpPresenter(presenters.mcp) ? presenters.mcp : undefined;
     registerMcpTool(server, {
       name: definition.name,
       description: definition.description,