@nylorun/runtime 0.25.0-beta → 0.27.0-beta

package/dist/mcp/connect.d.ts

@@ -2,9 +2,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { McpServerManifest } from "@nylorun/core/define";
 import { type OutboundPolicy } from "../tenant/outbound.js";
 import type { AuthorizeResult } from "../vault/service.js";
-import { type McpDiagnostic, type McpRenamedTool, type McpToolRecord } from "./snapshot.js";
-/** How much of a failed answer's body the model sees. */
-export declare const MCP_ERROR_BODY_CHARS = 2000;
+import type { McpDiagnostic, McpToolRecord } from "./snapshot.js";
 /** Options of one MCP request. */
 export interface McpRequestOptions {
     readonly signal?: AbortSignal;
@@ -22,6 +20,17 @@ export interface McpCallOptions extends McpRequestOptions {
      * it from the call's journal row.
      */
     readonly traceparent?: string;
+    /**
+     * How much of a failed call's answer its error quotes: the Tenant's Runtime limit
+     * `errorExcerptChars`, read for the call. Default the connection's (`openMcpServer`).
+     */
+    readonly errorExcerptChars?: number;
+    /**
+     * The largest answer kept, in bytes: the Tenant's Runtime limit `toolAnswerBytes` (R2b C11).
+     * A larger one is `mcp.too-large`. Required where this process holds the connection; a client
+     * of the gates service leaves it out, since the gate reads the limit itself.
+     */
+    readonly maxResultBytes?: number;
 }
 /** A page of `tools/list`, as the MCP SDK returns it. */
 export interface McpToolPage {
@@ -63,7 +72,7 @@ export interface McpClient {
 }
 export interface LiveConnection {
     readonly client: McpClient;
-    /** The server's instructions from `initialize`, cut (`serverInstructions`); absent when none. */
+    /** The server's instructions from `initialize`, scrubbed (`serverInstructions`); absent when none. */
     readonly instructions?: string;
     /**
      * The server's `serverInfo` from `initialize` (name, version, title), without a credential
@@ -100,15 +109,10 @@ export type McpToolOutcome = {
  * - `mcp.status`: the server answered another HTTP error status, without a JSON-RPC error.
  * - `mcp.lost`: sent, and the answer was lost, so the tool may have run. The model sees it, and
  *   decides whether to call again (R5; it replaced R2b's read-only and idempotent exception).
- * - `mcp.too-large`: the answer passed `MCP_RESULT_MAX_BYTES` (R2b C11), as an HTTP tool's
- *   answer is `http.too-large`. The tool ran; its answer was not kept.
+ * - `mcp.too-large`: the answer passed the Tenant's Runtime limit `toolAnswerBytes` (R2b C11),
+ *   as an HTTP tool's answer is `http.too-large`. The tool ran; its answer was not kept.
  */
 export type McpFailureCode = "mcp.unreachable" | "credential_rejected" | "mcp.forbidden" | "mcp.error" | "mcp.status" | "mcp.lost" | "mcp.too-large";
-/**
- * The largest `tools/call` answer the gate holds (R2b C11): 8 MiB, an HTTP tool's cap. Core
- * stores what does not fit a tool result as an artifact (`tenant/tool-results.ts`).
- */
-export declare const MCP_RESULT_MAX_BYTES: number;
 export interface McpCallFailure {
     readonly code: McpFailureCode;
     readonly message: string;
@@ -164,8 +168,12 @@ export declare class CredentialRejected extends McpCallFailed {
 export declare class McpConnectionStale extends McpCallFailed {
     constructor(server: string, reason: string);
 }
-/** A tool call that never reached its server: its connection could not be opened. */
-export declare function unreachable(server: string, error: unknown): McpCallFailed;
+/**
+ * A tool call that never reached its server: its connection could not be opened. Where the
+ * opening reached the server, `chars` is how much of what it said the error quotes (the Tenant's
+ * `errorExcerptChars`); without it, the message is this process's own and stays whole.
+ */
+export declare function unreachable(server: string, error: unknown, chars?: number): McpCallFailed;
 /**
  * Where a `tools/call` carries its key (R5.5): MCP has no standard key field, and `_meta` is the
  * spec's place for extra request data. The key is the call's effect id, the same on every send,
@@ -177,7 +185,7 @@ export declare const IDEMPOTENCY_META_KEY = "nylorun/idempotency-key";
  * with them (R2b C8), and a failed call is an `McpCallFailed` (C7). A keyed call sends its key in
  * `_meta` (R5.5).
  */
-export declare function sdkClient(client: Client, serverName: string): McpClient;
+export declare function sdkClient(client: Client, serverName: string, errorChars: number): McpClient;
 export declare function openMcpServer(input: {
     server: McpServerManifest;
     authorize: (url: string) => Promise<AuthorizeResult>;
@@ -189,31 +197,32 @@ export declare function openMcpServer(input: {
     policy?: OutboundPolicy;
     /** Ends `initialize` (a tool preview's timeout, R2b C12). */
     signal?: AbortSignal;
+    /**
+     * How much of a failed answer an error quotes: the Tenant's Runtime limit `errorExcerptChars`
+     * when the connection opens; a call may pass the one in force then.
+     */
+    errorExcerptChars: number;
 }): Promise<LiveConnection>;
 /**
- * What a server's `initialize` said to do with its tools, for the note on its deferred tools
- * (R2b C10): cut to `SERVER_INSTRUCTIONS_MAX_CHARS`, without a credential value sent (C8).
+ * What a server's `initialize` said to do with its tools, as it said it, without a credential
+ * value sent (C8). The harness decides how much of it the model reads.
  */
 export declare function serverInstructions(text: unknown, secrets: readonly string[]): string | undefined;
 /**
- * Lists a server's tools under the names the model knows them by (R2b C6): `server__tool` where
- * that is a name every provider accepts, else `normalizeToolName`'s, listed in `renamed`. A name
- * taken by a declared tool or an earlier server's tool omits the tool; a renamed tool that
- * collides gets the hash suffix first.
+ * Lists a server's tools as it names them (protocol 15): every tool whose input schema is a JSON
+ * object, the ones its `tools` settings disable included, since a turn's manifest decides
+ * `enabled` (`mcpFactsOf`). The harness names them for the model. A tool with no input schema
+ * object is in `omitted`; `disabled` counts the tools the declaration's settings disable, and
+ * `unknownTools` the settings' keys that name no listed tool.
  */
 export declare function listMcpTools(client: McpClient, input: {
     serverName: string;
-    taken: Set<string>;
     signal?: AbortSignal;
-    /**
-     * The server's declaration: a tool its `tools` settings disable is left out before it takes
-     * a name (R2b C9), and a key that names no listed tool is in `unknownTools`.
-     */
+    /** The server's declaration, whose `tools` settings the diagnostics count against. */
     server?: McpServerManifest;
 }): Promise<{
     tools: McpToolRecord[];
     omitted: string[];
-    renamed: McpRenamedTool[];
     disabled: number;
     unknownTools: string[];
 }>;

package/dist/mcp/connect.js

@@ -3,18 +3,11 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
-import { MCP_TOOL_DEFAULTS, SERVER_INSTRUCTIONS_MAX_CHARS, mcpToolSettings, schemaFromJSON, } from "@nylorun/core/define";
+import { MCP_TOOL_DEFAULTS, mcpToolSettings } from "@nylorun/core/define";
 import { scrub, scrubValues } from "../redact.js";
-import { guardedFetch, MAX_RESPONSE_BYTES, OutboundFailed, OutboundRefused, } from "../tenant/outbound.js";
+import { guardedFetch, OutboundFailed, OutboundRefused, } from "../tenant/outbound.js";
 import { credentialSecrets } from "../vault/headers.js";
-import { normalizeToolName, } from "./snapshot.js";
-/** How much of a failed answer's body the model sees. */
-export const MCP_ERROR_BODY_CHARS = 2_000;
-/**
- * The largest `tools/call` answer the gate holds (R2b C11): 8 MiB, an HTTP tool's cap. Core
- * stores what does not fit a tool result as an artifact (`tenant/tool-results.ts`).
- */
-export const MCP_RESULT_MAX_BYTES = MAX_RESPONSE_BYTES;
+import { hostTuning } from "../tuning.js";
 /** A tool call that failed with a code the model can act on (R2b C7). */
 export class McpCallFailed extends Error {
     failure;
@@ -96,21 +89,29 @@ export class McpConnectionStale extends McpCallFailed {
         this.name = "McpConnectionStale";
     }
 }
-/** A tool call that never reached its server: its connection could not be opened. */
-export function unreachable(server, error) {
+/**
+ * A tool call that never reached its server: its connection could not be opened. Where the
+ * opening reached the server, `chars` is how much of what it said the error quotes (the Tenant's
+ * `errorExcerptChars`); without it, the message is this process's own and stays whole.
+ */
+export function unreachable(server, error, chars) {
     if (error instanceof McpCallFailed)
         return error;
-    return unreachableFailure(server, error instanceof Error ? error.message : String(error));
+    const detail = error instanceof Error ? error.message : String(error);
+    return unreachableFailure(server, detail, chars ?? detail.length);
 }
 /** The operation a request of the transport's fetch belongs to. */
 const tracking = new AsyncLocalStorage();
-function tracked(call, run, traceparent) {
+function tracked(call, run, options) {
+    const { traceparent, maxResultBytes, errorChars } = options;
     const tracker = {
         secrets: new Set(),
         sent: false,
         settled: false,
+        errorChars,
         ...(call ? { calling: new AbortController() } : {}),
         ...(traceparent ? { traceparent } : {}),
+        ...(maxResultBytes === undefined ? {} : { maxResultBytes }),
     };
     return tracking.run(tracker, () => run(tracker));
 }
@@ -125,7 +126,7 @@ export const IDEMPOTENCY_META_KEY = "nylorun/idempotency-key";
  * with them (R2b C8), and a failed call is an `McpCallFailed` (C7). A keyed call sends its key in
  * `_meta` (R5.5).
  */
-export function sdkClient(client, serverName) {
+export function sdkClient(client, serverName, errorChars) {
     return {
         listTools: (params, options) => tracked(false, async (tracker) => {
             try {
@@ -135,35 +136,41 @@ export function sdkClient(client, serverName) {
             catch (error) {
                 throw scrubError(error, tracker);
             }
-        }),
-        callTool: (params, options) => tracked(true, async (tracker) => {
-            const lost = tracker.calling.signal;
-            try {
-                const keyed = options?.key === undefined
-                    ? params
-                    : { ...params, _meta: { [IDEMPOTENCY_META_KEY]: options.key } };
-                const result = (await client.callTool(keyed, undefined, {
-                    signal: options?.signal ? AbortSignal.any([options.signal, lost]) : lost,
-                }));
-                // An answer the stream did not count (an `sse` server answers on its event stream).
-                if (Buffer.byteLength(JSON.stringify(result)) > MCP_RESULT_MAX_BYTES)
-                    throw tooLargeFailure(serverName);
-                const answer = scrubValues(result, [...tracker.secrets]);
-                return { result: answer.value, ...(answer.redacted > 0 ? { redacted: answer.redacted } : {}) };
-            }
-            catch (error) {
-                // A cancel or a shutdown: the caller decides what it means.
-                if (options?.signal?.aborted)
-                    throw error;
-                throw scrubError(failureOf(serverName, error, tracker), tracker);
-            }
-            finally {
-                tracker.settled = true;
-            }
-        }, options?.traceparent),
+        }, { errorChars }),
+        callTool: (params, options) => {
+            const maxResultBytes = options?.maxResultBytes;
+            if (maxResultBytes === undefined)
+                return Promise.reject(new Error("A tool call on a connection this process holds needs maxResultBytes"));
+            return tracked(true, async (tracker) => {
+                const lost = tracker.calling.signal;
+                try {
+                    const keyed = options?.key === undefined
+                        ? params
+                        : { ...params, _meta: { [IDEMPOTENCY_META_KEY]: options.key } };
+                    const result = (await client.callTool(keyed, undefined, {
+                        signal: options?.signal ? AbortSignal.any([options.signal, lost]) : lost,
+                    }));
+                    // An answer the stream did not count (an `sse` server answers on its event stream).
+                    if (Buffer.byteLength(JSON.stringify(result)) > maxResultBytes)
+                        throw tooLargeFailure(serverName, maxResultBytes);
+                    const answer = scrubValues(result, [...tracker.secrets]);
+                    return { result: answer.value, ...(answer.redacted > 0 ? { redacted: answer.redacted } : {}) };
+                }
+                catch (error) {
+                    // A cancel or a shutdown: the caller decides what it means.
+                    if (options?.signal?.aborted)
+                        throw error;
+                    throw scrubError(failureOf(serverName, error, tracker), tracker);
+                }
+                finally {
+                    tracker.settled = true;
+                }
+            }, { traceparent: options?.traceparent, maxResultBytes, errorChars: options?.errorExcerptChars ?? errorChars });
+        },
     };
 }
 export async function openMcpServer(input) {
+    const errorChars = input.errorExcerptChars;
     const authorize = input.authorize;
     const initial = await authorize(input.server.url);
     if (initial.status === "refused") {
@@ -175,7 +182,7 @@ export async function openMcpServer(input) {
     // A credential with `via` sends the server's requests there (R2b C2); the manifest's URL still
     // names the server for its credential, its tools and its diagnostics.
     const url = new URL(endpointOf(input.server, initial));
-    const fetchImpl = authorizedFetch(input.server, url, authorize, input.policy ?? {});
+    const fetchImpl = authorizedFetch(input.server, url, authorize, input.policy ?? {}, errorChars);
     const transport = input.server.type === "sse"
         ? new SSEClientTransport(url, { fetch: fetchImpl })
         : new StreamableHTTPClientTransport(url, { fetch: fetchImpl });
@@ -194,33 +201,35 @@ export async function openMcpServer(input) {
             instructions: serverInstructions(client.getInstructions(), [...tracker.secrets]),
             serverInfo: info ? scrubbed({ ...info }, tracker) : undefined,
         };
-    });
+    }, { errorChars });
     return {
-        client: sdkClient(client, input.server.name),
+        client: sdkClient(client, input.server.name, errorChars),
         ...(instructions === undefined ? {} : { instructions }),
         ...(serverInfo === undefined ? {} : { serverInfo }),
         close: () => client.close(),
     };
 }
 /**
- * What a server's `initialize` said to do with its tools, for the note on its deferred tools
- * (R2b C10): cut to `SERVER_INSTRUCTIONS_MAX_CHARS`, without a credential value sent (C8).
+ * What a server's `initialize` said to do with its tools, as it said it, without a credential
+ * value sent (C8). The harness decides how much of it the model reads.
  */
 export function serverInstructions(text, secrets) {
     if (typeof text !== "string" || text.trim().length === 0)
         return undefined;
-    return scrubValues(text.trim().slice(0, SERVER_INSTRUCTIONS_MAX_CHARS), secrets).value;
+    return scrubValues(text.trim(), secrets).value;
 }
 /**
- * Lists a server's tools under the names the model knows them by (R2b C6): `server__tool` where
- * that is a name every provider accepts, else `normalizeToolName`'s, listed in `renamed`. A name
- * taken by a declared tool or an earlier server's tool omits the tool; a renamed tool that
- * collides gets the hash suffix first.
+ * Lists a server's tools as it names them (protocol 15): every tool whose input schema is a JSON
+ * object, the ones its `tools` settings disable included, since a turn's manifest decides
+ * `enabled` (`mcpFactsOf`). The harness names them for the model. A tool with no input schema
+ * object is in `omitted`; `disabled` counts the tools the declaration's settings disable, and
+ * `unknownTools` the settings' keys that name no listed tool.
  */
 export async function listMcpTools(client, input) {
     const listed = [];
     let cursor;
-    for (let page = 0; page < 100; page += 1) {
+    const pages = hostTuning().harness.mcpListPages;
+    for (let page = 0; page < pages; page += 1) {
         const answer = await client.listTools(cursor ? { cursor } : undefined, input.signal ? { signal: input.signal } : undefined);
         listed.push(...answer.tools);
         cursor = answer.nextCursor;
@@ -233,69 +242,32 @@ export async function listMcpTools(client, input) {
     const unknownTools = Object.keys(server?.tools ?? {}).filter((key) => key !== MCP_TOOL_DEFAULTS && !listedNames.has(key));
     let disabled = 0;
     const omitted = [];
-    const candidates = [];
+    const tools = [];
+    const seen = new Set();
     for (const tool of listed) {
-        if (typeof tool.name !== "string" || tool.name.length === 0)
+        if (typeof tool.name !== "string" || tool.name.length === 0 || seen.has(tool.name))
             continue;
-        if (server && !mcpToolSettings(server, tool.name).enabled) {
+        seen.add(tool.name);
+        if (server && !mcpToolSettings(server, tool.name).enabled)
             disabled += 1;
+        const inputSchema = jsonObjectOf(tool.inputSchema);
+        if (!inputSchema) {
+            omitted.push(tool.name);
             continue;
         }
-        const inputSchema = usableSchema(tool.inputSchema);
-        if (inputSchema)
-            candidates.push({ tool, inputSchema });
-        else
-            omitted.push(normalizeToolName(input.serverName, tool.name));
-    }
-    // Names that need no change first, so a renamed tool never takes the name of another of the
-    // server's tools.
-    const names = new Map();
-    const renamed = [];
-    for (const candidate of candidates) {
-        const name = normalizeToolName(input.serverName, candidate.tool.name);
-        if (name !== `${input.serverName}__${candidate.tool.name}`)
-            continue;
-        if (input.taken.has(name))
-            omitted.push(name);
-        else {
-            input.taken.add(name);
-            names.set(candidate, name);
-        }
-    }
-    for (const candidate of candidates) {
-        const raw = `${input.serverName}__${candidate.tool.name}`;
-        let name = normalizeToolName(input.serverName, candidate.tool.name);
-        if (name === raw)
-            continue;
-        if (input.taken.has(name))
-            name = normalizeToolName(input.serverName, candidate.tool.name, { suffixed: true });
-        if (input.taken.has(name)) {
-            omitted.push(name);
-            continue;
-        }
-        input.taken.add(name);
-        names.set(candidate, name);
-        renamed.push({ serverToolName: candidate.tool.name, name });
-    }
-    const tools = [];
-    for (const candidate of candidates) {
-        const name = names.get(candidate);
-        if (name === undefined)
-            continue;
-        const { tool, inputSchema } = candidate;
-        const outputSchema = tool.outputSchema ? usableSchema(tool.outputSchema) : undefined;
+        const outputSchema = jsonObjectOf(tool.outputSchema);
+        const annotations = jsonObjectOf(tool.annotations);
         tools.push({
-            serverName: input.serverName,
-            serverToolName: tool.name,
-            name,
+            name: tool.name,
             ...(typeof tool.description === "string" && tool.description.length > 0
                 ? { description: tool.description }
                 : {}),
             inputSchema,
             ...(outputSchema === undefined ? {} : { outputSchema }),
+            ...(annotations === undefined || Object.keys(annotations).length === 0 ? {} : { annotations }),
         });
     }
-    return { tools, omitted, renamed, disabled, unknownTools };
+    return { tools, omitted, disabled, unknownTools };
 }
 /**
  * One tool call and what it came to. Rejects with `McpConnectionStale` when the connection must
@@ -314,6 +286,7 @@ export async function callMcpTool(client, serverToolName, args, options = {}) {
             ...(options.key === undefined ? {} : { key: options.key }),
             ...(options.signal ? { signal: options.signal } : {}),
             ...(options.traceparent === undefined ? {} : { traceparent: options.traceparent }),
+            ...(options.maxResultBytes === undefined ? {} : { maxResultBytes: options.maxResultBytes }),
         });
     }
     catch (error) {
@@ -337,8 +310,8 @@ export async function callMcpTool(client, serverToolName, args, options = {}) {
     }
     if ("structuredContent" in result && result.structuredContent !== undefined)
         return { kind: "completed", output: result.structuredContent, ...redacted };
-    // Text alone is the text. With an image, audio or a resource in it, every part stays, and core
-    // stores the bytes as artifacts before anything records them (R2b C11, `tenant/tool-results.ts`).
+    // Text alone is the text. With an image, audio or a resource in it, every part stays, and the
+    // harness stores the bytes as artifacts before it reports the outcome (R2b C11).
     const text = "content" in result && onlyText(result.content) ? textContent(result.content) : undefined;
     if (text !== undefined)
         return { kind: "completed", output: text, ...redacted };
@@ -377,7 +350,7 @@ export function diagnosticFromError(serverName, error) {
         message: unauthorized
             ? "MCP server returned 401"
             : error instanceof Error
-                ? error.message.slice(0, 500)
+                ? error.message.slice(0, hostTuning().harness.mcpDiagnosticChars)
                 : "MCP server connection failed",
     };
 }
@@ -394,7 +367,7 @@ function endpointOf(server, result) {
  * `McpCallFailed`. Under a tracked operation it records the credential values it sends, whether
  * a POST was sent, and a tool call's answer lost after it was.
  */
-function authorizedFetch(server, endpoint, authorize, policy) {
+function authorizedFetch(server, endpoint, authorize, policy, errorChars) {
     const send = guardedFetch(policy, { stream: true });
     return async (url, init) => {
         const target = typeof url === "string" ? url : url.href;
@@ -448,19 +421,21 @@ function authorizedFetch(server, endpoint, authorize, policy) {
             throw new McpConnectionStale(server.name, "ended the connection's session (HTTP 404)");
         }
         // A GET's error status (405: no event stream) is the SDK's to read.
-        if (post && !response.ok)
-            throw statusFailure(server.name, response.status, await bodyText(response));
+        if (post && !response.ok) {
+            const chars = tracker?.errorChars ?? errorChars;
+            throw statusFailure(server.name, response.status, await bodyText(response, chars), chars);
+        }
         return tracker?.calling && post && response.body ? watched(response, tracker) : response;
     };
 }
 /** Error statuses after which the same request may work. */
 const RETRYABLE_STATUSES = new Set([408, 429, 502, 503, 504]);
 /** A POST the server answered with an error status: its JSON-RPC error, or the status. */
-function statusFailure(server, status, body) {
+function statusFailure(server, status, body, chars) {
     const rpc = rpcErrorOf(body);
     if (status !== 403 && rpc)
-        return rpcFailure(server, `MCP error ${rpc.code}: ${rpc.message}`);
-    const text = body.length > MCP_ERROR_BODY_CHARS ? `${body.slice(0, MCP_ERROR_BODY_CHARS)}…` : body;
+        return rpcFailure(server, `MCP error ${rpc.code}: ${rpc.message}`, chars);
+    const text = body.length > chars ? `${body.slice(0, chars)}…` : body;
     return new McpCallFailed({
         code: status === 403 ? "mcp.forbidden" : "mcp.status",
         message: `The MCP server '${server}' answered HTTP ${status}${text ? `: ${text}` : ""}`,
@@ -468,34 +443,34 @@ function statusFailure(server, status, body) {
         retryable: RETRYABLE_STATUSES.has(status),
     });
 }
-function rpcFailure(server, message) {
+function rpcFailure(server, message, chars) {
     return new McpCallFailed({
         code: "mcp.error",
-        message: `The MCP server '${server}' answered an error: ${message.slice(0, MCP_ERROR_BODY_CHARS)}`,
+        message: `The MCP server '${server}' answered an error: ${message.slice(0, chars)}`,
         sent: true,
         retryable: false,
     });
 }
-function unreachableFailure(server, detail) {
+function unreachableFailure(server, detail, chars) {
     return new McpCallFailed({
         code: "mcp.unreachable",
-        message: `The MCP server '${server}' could not be reached, and the call was not sent: ${detail.slice(0, MCP_ERROR_BODY_CHARS)}`,
+        message: `The MCP server '${server}' could not be reached, and the call was not sent: ${detail.slice(0, chars)}`,
         sent: false,
         retryable: true,
     });
 }
-function lostFailure(server, detail) {
+function lostFailure(server, detail, chars) {
     return new McpCallFailed({
         code: "mcp.lost",
-        message: `The connection to the MCP server '${server}' was lost after the call was sent, so it may have run: ${detail.slice(0, MCP_ERROR_BODY_CHARS)}`,
+        message: `The connection to the MCP server '${server}' was lost after the call was sent, so it may have run: ${detail.slice(0, chars)}`,
         sent: true,
         retryable: true,
     });
 }
-function tooLargeFailure(server) {
+function tooLargeFailure(server, maxResultBytes) {
     return new McpCallFailed({
         code: "mcp.too-large",
-        message: `The MCP server '${server}' answered more than ${MCP_RESULT_MAX_BYTES} bytes, the most a tool result may hold, so the answer was not kept`,
+        message: `The MCP server '${server}' answered more than ${maxResultBytes} bytes, the most a tool result may hold (the Runtime limit toolAnswerBytes), so the answer was not kept`,
         sent: true,
         retryable: false,
     });
@@ -505,24 +480,25 @@ function failureOf(server, error, tracker) {
     if (error instanceof McpCallFailed)
         return error;
     if (tracker.tooLarge)
-        return tooLargeFailure(server);
+        return tooLargeFailure(server, tracker.maxResultBytes ?? 0);
     const detail = error instanceof Error ? error.message : String(error);
+    const chars = tracker.errorChars;
     if (tracker.lost !== undefined)
-        return lostFailure(server, tracker.lost);
+        return lostFailure(server, tracker.lost, chars);
     if (error instanceof OutboundRefused)
-        return unreachableFailure(server, detail);
+        return unreachableFailure(server, detail, chars);
     if (error instanceof OutboundFailed)
-        return error.sent ? lostFailure(server, detail) : unreachableFailure(server, detail);
+        return error.sent ? lostFailure(server, detail, chars) : unreachableFailure(server, detail, chars);
     if (error instanceof McpError) {
         // Sent, and no answer came in time.
         if (error.code === ErrorCode.RequestTimeout)
-            return lostFailure(server, detail);
+            return lostFailure(server, detail, chars);
         if (error.code === ErrorCode.ConnectionClosed)
-            return tracker.sent ? lostFailure(server, detail) : unreachableFailure(server, detail);
-        return rpcFailure(server, detail);
+            return tracker.sent ? lostFailure(server, detail, chars) : unreachableFailure(server, detail, chars);
+        return rpcFailure(server, detail, chars);
     }
     // An answer that could not be read leaves the call's fate unknown, as a lost one does.
-    return tracker.sent ? lostFailure(server, detail) : unreachableFailure(server, detail);
+    return tracker.sent ? lostFailure(server, detail, chars) : unreachableFailure(server, detail, chars);
 }
 /** `value` with the operation's credential values replaced (R2b C8). */
 function scrubbed(value, tracker) {
@@ -549,7 +525,7 @@ function scrubError(error, tracker) {
 /**
  * A tool call's answer whose body reports its loss (R2b C7): a stream that breaks after the
  * request was sent ends the call as lost, now, instead of at the SDK's request timeout. One that
- * passes `MCP_RESULT_MAX_BYTES` ends it as `mcp.too-large` (C11), before more of it is read.
+ * passes the call's `maxResultBytes` ends it as `mcp.too-large` (C11), before more of it is read.
  */
 function watched(response, tracker) {
     const source = response.body.getReader();
@@ -571,9 +547,9 @@ function watched(response, tracker) {
             if (next.done)
                 return controller.close();
             received += next.value.byteLength;
-            if (received > MCP_RESULT_MAX_BYTES) {
+            if (tracker.maxResultBytes !== undefined && received > tracker.maxResultBytes) {
                 tracker.tooLarge = true;
-                const error = new Error(`The answer passed ${MCP_RESULT_MAX_BYTES} bytes`);
+                const error = new Error(`The answer passed ${tracker.maxResultBytes} bytes`);
                 tracker.calling?.abort(error);
                 controller.error(error);
                 void source.cancel(error).catch(() => undefined);
@@ -590,14 +566,15 @@ function watched(response, tracker) {
     });
 }
 /** The start of an error answer's body. */
-async function bodyText(response) {
+async function bodyText(response, chars) {
     if (!response.body)
         return "";
     const reader = response.body.getReader();
     const chunks = [];
     let size = 0;
     try {
-        while (size < 4 * MCP_ERROR_BODY_CHARS) {
+        // A character takes at most 4 bytes of UTF-8: enough bytes for `chars` of them.
+        while (size < 4 * chars) {
             const next = await reader.read();
             if (next.done)
                 break;
@@ -634,17 +611,11 @@ function sameOrigin(requestUrl, serverUrl) {
         return false;
     }
 }
-function usableSchema(value) {
+/** `value` as a JSON object (a copy), or undefined when it is not one. */
+function jsonObjectOf(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return undefined;
-    const schema = JSON.parse(JSON.stringify(value));
-    try {
-        schemaFromJSON(schema);
-    }
-    catch {
-        return undefined;
-    }
-    return schema;
+    return JSON.parse(JSON.stringify(value));
 }
 function textContent(content) {
     if (!Array.isArray(content))