agentfootprint 12.0.1 → 12.1.0

package/CAPABILITIES.md

@@ -22,6 +22,7 @@ not in this table, search `src/index.ts` for the nearest noun before writing cod
 |---|---|---|---|
 | moving files in and out of a code sandbox exactly and bounded, and running shell commands in it — staging text as text and bytes as bytes (AgentCore: one `writeFiles` call, `blob` for bytes, refused over the 100 MB per-call limit, `AF_STAGED_INPUTS` filled as the local runner fills it); reading ONE file back whole or not at all (paired to its path by the returned URI, a missing or different one refused; text or bytes by the field the backend filled, never the extension; over `maxBytes` refused, never cut); a shell command with bounded output, the cut stated, a checkpoint read before the cut, and an exit status only when the backend reported one — off unless the runner opts in; one path rule for both runners; a gone AgentCore session as one typed error; an outcome nobody reported kept unknown (`CodeResult.ok` absent, never success), and a failed program (`exitCode`) told apart from an unconfirmed run (`serviceError`) and a stopped process (`terminatedBy`) in the result and in the `tools.code_run` record | `CodeSession.readFile` + `CodeSession.runCommand` (runner option `commands: true`) + `canReadCodeFiles` / `canRunCodeCommands` + `CodeSandboxError` + `SessionExpiredError` + `sandboxPath` (`agentfootprint`); `agentCoreCodeRunner` / `localCodeRunner` (`agentfootprint/providers`) | `src/adapters/code/` | 12.0.0 |
 | tuning how an MCP call waits before asking again — the first wait, how it grows, jitter, a cap on the scheduled wait, a deadline for the whole call — and keeping a 429 retry and AgentCore Runtime's session-busy retry from multiplying requests: each call is ONE footprintjs `attempt()` series, the 429 rule JOINS a transport's own series instead of wrapping it (one attempt count, one waiting total, one deadline), a `Retry-After` is waited whole (never cut by the cap), and `onRetry` reports the refusal's `kind` but never arguments or answers | `retryOnThrottle` / `agentCoreRuntimeMcpTransport({ retry })` / `retryingFetch(fetch, options)`: `baseDelayMs`, `multiplier`, `jitter` (none, equal or full), `maxDelayMs`, `maxElapsedMs` beside `maxAttempts`, `maxWaitMs`, `onRetry` (`agentfootprint/providers`); AgentCore default 500 ms doubling, 5 attempts = 3.75–7.5 s of waiting | `src/mcp/throttleRetry.ts` | 11.2.0 |
+| reading an MCP server's whole tool list when it pages (`nextCursor`) — every page, at most 100 `tools/list` requests; a list that does not end (`'page-limit'`) or loops (`'cursor-repeated'`) is refused with what was listed on the error, never returned cut short; the signal checked before each request and after each answer; and every listed tool keeps the SDK `Client`'s call checks whatever `mcpClient` lists later (required task refused before sending, `structuredContent` required by and matched against `outputSchema`, the same error class or shape; left to the SDK only for a one-page list still its latest answer, so a paged list, a failed or successful `refresh()`, a held tool and a call during a listing all stay checked), with `McpOutputUncheckedError` (`sent: false`, or `sent: true` when a list was read while the call was out) only where no JSON Schema validator is reachable — ONLY while discovery runs through `tools()`/`refresh()` (any `mcpClient` over the client): a `listTools` call of your own, the SDK client's automatic refresh (`listChanged.tools`, `autoRefresh` on by default) or any other unseen cache replacement can bypass both the output and the required-task checks, validator or not, so on a `connection` set `autoRefresh: false` and route `onChanged` to `refresh()`, or give `mcpClient` its own connection | `mcpClient(...).tools()` / `.refresh()` + `McpToolListIncompleteError`, `jsonSchemaValidator` (`McpJsonSchemaValidator`) and `McpOutputUncheckedError` (`agentfootprint/providers`) | `src/mcp/` | 12.1.0 |
 | deciding which MCP tool calls are sent again after a 429 or a lost connection — permission declared by the APP per (server, tool) at registration, never by the model, a tool description or server annotations (`readOnlyHint`); a generic 429 is not proof nothing ran, so `'app-authorized'` (opt-in) sends a call again only on the kinds its entry names (`throttle`, `network`) and otherwise returns the refusal (`not-permitted`); today's default stays as the NAMED `'compatibility'` policy, every retry recording its assumption (`permission: { by: 'compatibility', assumes: 'refused-before-execution' }`); the adapter you chose retries its own refusal (AgentCore session-busy) as its POLICY, recording `permission: { by: 'adapter', assumes: 'refused-before-execution' }` — never proof: a busy-shaped reply can come from a server that ran the call, so every attempt sent that did not complete is `unknown` and `none` is only a request never sent; `retryOnThrottle: false` turns off the 429 rule only — a declared `network` repeat keeps its series, budget and record; the side-effect guard — a tool declared `changes: true` is never sent again unless the server is declared to deduplicate by a key the call carries (`changes-without-key`); each attempt records failure, effect (`none`/`unknown`/`applied`, footprintjs's law) and permission apart, plus `durationMs`; the end counts the requests sent and keeps uncertainty (a later refusal or success never resolves an earlier `unknown`; `applied` = the call completed, never proof of a write); under `'app-authorized'` a received refusal or error (429, 503, JSON-RPC or tool error — or a chain of them) keeps the server's error, effect `unknown`, while a call that genuinely lacked an answer (an attempt with no response, or a request accepted over HTTP — 202, a stream — whose JSON-RPC answer never came: the ledger watches it by id) and then fails, fails as "may have run" (footprintjs `UnknownEffectError`, its final error the cause, `mayHaveRun: true`); `'compatibility'` keeps today's errors; `'app-authorized'` never silently weakens: it needs each request matched to its call (a library-private `_meta` marker, stripped before sending, so a copying SDK still matches) and each answer seen (checked when the `initialize` answer passes the observer), or the call is refused BEFORE it is sent with `McpReplayUnavailableError` (`sent: false`, `reason`: `answers-unobserved` for an SDK whose `connect` replaces `onmessage`, as 1.10's does; `request-unmatched` for one that drops `_meta`; `requests-unwatched` for stdio); an answer's watch ends by request id (answer, SDK cancellation, call settled, client closed), never with the HTTP send alone; a repeat re-sends the same arguments, server, session and identity | `mcpClient({ replay: { policy, tools: { [name]: { on, changes } }, deduplicates: { argument } } })` + `McpReplayOptions` + `McpReplayUnavailableError` (`agentfootprint/providers`); `effect` / `permission` / `durationMs` on `agentfootprint.tools.request_attempts` rows; `attempts` / `effect` / `mayHaveRun` on its `end` | `src/mcp/replay.ts` | 11.5.0 |
 | saving what an MCP call's retries did into the run that made the call — every attempt, why the series went on or stopped after it, each wait and any stated `Retry-After`, and how the request ended, a cancellation DURING A WAIT included — so a saved and re-read recording gives it back; concurrent calls and runs on one connection never mix; past 100 attempts the rest are counted (`omitted`), never dropped; a 503 received is `answered` with its status, never success and never retried; allow-listed metadata only (a thrown error is a fixed sentence and its category; the endpoint is the declared `endpointLabel`, else its origin; a filing is read as plain data). Every request sent is a row or counted; one cut in flight is `cut`, `remote: 'unknown'` (never recorded as not run), and only a request never sent has no row. Filed ONCE per request by the call's own footprintjs `attempt()` series (no second loop) through an internal per-dispatch port (`REQUEST_EVIDENCE`, not public API) and a per-connection ledger: the call's private `_meta` marker (taken out before sending) → JSON-RPC id → series. An MCP tool call honours its `ctx.signal` (the SDK request is cancelled, `notifications/cancelled` sent), its series stops with it, a wait included, filed the moment it lands, and a call that settles first cuts its series inside the call — never filed after its run, nothing re-sent | `agentfootprint.tools.request_attempts` / `SeriesEvidence` + `RequestLedger` | `src/mcp/` | 11.3.0 |
 | refusing invalid memory list and search request sizes uniformly before backend reads or empty-result shortcuts, while keeping optional defaults, adapter upper caps and list continuation intact | `ListOptions` + `SearchOptions` | `src/memory/store/types.ts` | 10.8.1 |

package/dist/esm/mcp/callChecks.d.ts

@@ -0,0 +1,160 @@
+/**
+ * callChecks — a listing never makes a callable tool lose its checks.
+ *
+ * Pattern: the SDK's three per-tool call checks, carried by every tool the
+ *          library hands out, plus one typed refusal.
+ * Role:    The MCP SDK's `Client` runs three checks inside `callTool`, and it
+ *          keeps them only for the tools of its most recent `tools/list`
+ *          answer (1.32: `cacheToolMetadata` replaces them on every answer):
+ *
+ *   1. a tool with `execution.taskSupport: 'required'` is refused before a
+ *      plain `tools/call` is sent;
+ *   2. a tool with an `outputSchema` must answer with `structuredContent`,
+ *      unless the answer is an error;
+ *   3. that `structuredContent` must match the schema.
+ *
+ * So a tool that declares any of them carries them itself, as the listing it
+ * came from declared them. The library leaves them to the SDK only for a tool
+ * of a ONE-page list whose answer is still the latest, with no list request
+ * out (`listingGenerations.ts`), both when the call starts and when its answer
+ * comes in: the one-page normal case, which runs exactly as it always did.
+ * Every other call runs the tool's own checks, at the SDK's moments — the first
+ * before sending, the other two once the answer is in, before anything reads it
+ * — and raises the SDK's error: its own `McpError` where this arm loaded the
+ * SDK, otherwise an error with the same name, code and message. Those calls
+ * are to a tool of a paged list, a tool whose list a later answer replaced (a
+ * refresh that failed or succeeded; a reference held across it), and any call
+ * made while a list is being read.
+ *
+ * All of this covers the lists the library reads (`tools()`, `refresh()`); a
+ * listing it does not send — the SDK client's own automatic refresh, a
+ * `listTools` call of the caller's — is not seen (`listingGenerations.ts`).
+ *
+ * The output checks need a JSON Schema validator equal to the client's: the
+ * SDK's default (`AjvJsonSchemaValidator`, loaded with the SDK on the Node
+ * loader arm), or the caller's `jsonSchemaValidator`. Where neither exists — an
+ * `sdk` or `connection` arm given none — an answer under these rules is never
+ * returned unchecked (`McpOutputUncheckedError`):
+ *
+ *   - a call under the tool's own checks from the start, to a tool that
+ *     declares an `outputSchema`, is refused before it is sent (`sent: false`);
+ *   - a call that started under the SDK's checks is refused once its answer is
+ *     in, unread, when the library sent a `tools/list` request while the call
+ *     was out (`sent: true`): the SDK may have checked it against another list.
+ *
+ * A schema is compiled when a tool's own checks first need it, never before:
+ * the one-page normal case compiles nothing twice.
+ */
+import type { McpCallToolResult, McpJsonSchemaValidator, McpListedTool } from './types.js';
+import type { ListingGenerations } from './listingGenerations.js';
+/** The SDK's `McpError` constructor, as `@modelcontextprotocol/sdk/types.js` exports it. */
+export type McpErrorClass = new (code: number, message: string, data?: unknown) => Error;
+/** A compiled output check, as the SDK's validator returns one. */
+type Validate = (input: unknown) => {
+    readonly valid: boolean;
+    readonly errorMessage?: string;
+};
+/**
+ * What one connection checks its tools' calls with: a validator equal to its
+ * client's, the SDK's own error class where the library loaded the SDK, and
+ * which `tools/list` answer the SDK holds its checks for.
+ */
+export interface CallCheckKit {
+    /** The client's name, as its refusals name it. */
+    readonly server: string;
+    /** The validator; created on first use. `undefined` when none is reachable. */
+    validator(): McpJsonSchemaValidator | undefined;
+    /** The SDK's own `McpError`, when this arm loaded the SDK. */
+    readonly McpError?: McpErrorClass;
+    /** This connection's list requests, counted (`listingGenerations.ts` · `listingsOf`). */
+    readonly listings: ListingGenerations;
+}
+/**
+ * The kit for one connection, named `server`, whose list requests `listings`
+ * counts (`listingsOf(connection)`, shared by every client over it). `given` is
+ * the caller's `jsonSchemaValidator`; `loaded` holds what the library loaded
+ * with the SDK on the Node loader arm — the SDK's default validator class and
+ * its `McpError` — each `undefined` where it is not a constructor (another arm,
+ * or an SDK without it).
+ */
+export declare function callCheckKit(server: string, listings: ListingGenerations, given: McpJsonSchemaValidator | undefined, loaded?: {
+    readonly Validator?: unknown;
+    readonly McpError?: unknown;
+}): CallCheckKit;
+/**
+ * `value` as a validator, or `undefined` when it was not given. Refused by name
+ * when it is something else, before anything connects.
+ */
+export declare function validatorOption(value: unknown, at: string): McpJsonSchemaValidator | undefined;
+/** The checks one listed tool carries, as the listing it came from declared them. */
+export interface CallChecks {
+    readonly server: string;
+    readonly tool: string;
+    /** `execution.taskSupport: 'required'`: only ever run as a task. */
+    readonly taskRequired: boolean;
+    /** The tool declares an `outputSchema`. */
+    readonly outputDeclared: boolean;
+    /**
+     * True while the SDK's `Client` holds this tool's checks: the tool came from
+     * a one-page list whose answer is still the latest, and no list request is
+     * out. Then the SDK checks the call, and nothing here runs.
+     */
+    heldBySdk(): boolean;
+    /**
+     * The compiled output check, compiled from the declared schema on first use.
+     * `undefined` when no output is declared or no validator is reachable.
+     */
+    validate(): Validate | undefined;
+    /** Raise an SDK error, as this arm can: the SDK's class, or its exact shape. */
+    fail(code: number, message: string): Error;
+}
+/**
+ * The checks `listed` carries — `undefined` when it declares none. `generation`
+ * is the one answer its list was read in, when it was read in one
+ * (`toolList.ts` · `ToolListing`); a paged list's tools have none, so the SDK
+ * never holds all of them.
+ */
+export declare function checksFor(listed: McpListedTool, kit: CallCheckKit, generation: number | undefined): CallChecks | undefined;
+/**
+ * True when this call's output cannot be checked here: it runs under the
+ * tool's own checks, the tool declares an `outputSchema`, no validator is
+ * reachable, and it is not refused as a required task anyway (that refusal is
+ * the SDK's, and comes first). The call is then refused before it is sent.
+ */
+export declare function outputUnchecked(checks: CallChecks): boolean;
+/** The SDK's task refusal, word for word, before anything is sent. */
+export declare function refuseRequiredTask(checks: CallChecks): void;
+/**
+ * The SDK's two output checks, in its order and with its sentences, once the
+ * answer is in and before anything reads it. An answer no validator here can
+ * check is never returned: it is refused, unread, as sent.
+ */
+export declare function checkOutput(checks: CallChecks, result: McpCallToolResult): void;
+/**
+ * A tool call whose output this connection cannot check, refused. The tool
+ * declares an `outputSchema`, the MCP SDK no longer holds the checks of the
+ * tool list it came from, and this connection has no JSON Schema validator to
+ * check it with — so its answer is never returned:
+ *
+ *   - `sent: false` — refused before it was sent: nothing reached the server.
+ *     The tool came from a paged list, from a list a later answer replaced, or
+ *     the call was made while a list was being read.
+ *   - `sent: true` — the call was sent, and a `tools/list` request went out
+ *     before its answer came in: the SDK may have checked that answer against
+ *     the other list, so it is refused unread. The tool may have run.
+ *
+ * Pass `jsonSchemaValidator` — the validator your client uses — to `mcpClient`.
+ * Names the server and the tool, never an argument or an answer.
+ */
+export declare class McpOutputUncheckedError extends Error {
+    readonly server: string;
+    readonly tool: string;
+    /** Whether the request left the client: `false` when the refusal came before it. */
+    readonly sent: boolean;
+    readonly code: "ERR_MCP_OUTPUT_UNCHECKED";
+    readonly reason: "output-unchecked";
+    constructor(server: string, tool: string, 
+    /** Whether the request left the client: `false` when the refusal came before it. */
+    sent: boolean);
+}
+export {};

package/dist/esm/mcp/callChecks.js

@@ -0,0 +1,237 @@
+/**
+ * callChecks — a listing never makes a callable tool lose its checks.
+ *
+ * Pattern: the SDK's three per-tool call checks, carried by every tool the
+ *          library hands out, plus one typed refusal.
+ * Role:    The MCP SDK's `Client` runs three checks inside `callTool`, and it
+ *          keeps them only for the tools of its most recent `tools/list`
+ *          answer (1.32: `cacheToolMetadata` replaces them on every answer):
+ *
+ *   1. a tool with `execution.taskSupport: 'required'` is refused before a
+ *      plain `tools/call` is sent;
+ *   2. a tool with an `outputSchema` must answer with `structuredContent`,
+ *      unless the answer is an error;
+ *   3. that `structuredContent` must match the schema.
+ *
+ * So a tool that declares any of them carries them itself, as the listing it
+ * came from declared them. The library leaves them to the SDK only for a tool
+ * of a ONE-page list whose answer is still the latest, with no list request
+ * out (`listingGenerations.ts`), both when the call starts and when its answer
+ * comes in: the one-page normal case, which runs exactly as it always did.
+ * Every other call runs the tool's own checks, at the SDK's moments — the first
+ * before sending, the other two once the answer is in, before anything reads it
+ * — and raises the SDK's error: its own `McpError` where this arm loaded the
+ * SDK, otherwise an error with the same name, code and message. Those calls
+ * are to a tool of a paged list, a tool whose list a later answer replaced (a
+ * refresh that failed or succeeded; a reference held across it), and any call
+ * made while a list is being read.
+ *
+ * All of this covers the lists the library reads (`tools()`, `refresh()`); a
+ * listing it does not send — the SDK client's own automatic refresh, a
+ * `listTools` call of the caller's — is not seen (`listingGenerations.ts`).
+ *
+ * The output checks need a JSON Schema validator equal to the client's: the
+ * SDK's default (`AjvJsonSchemaValidator`, loaded with the SDK on the Node
+ * loader arm), or the caller's `jsonSchemaValidator`. Where neither exists — an
+ * `sdk` or `connection` arm given none — an answer under these rules is never
+ * returned unchecked (`McpOutputUncheckedError`):
+ *
+ *   - a call under the tool's own checks from the start, to a tool that
+ *     declares an `outputSchema`, is refused before it is sent (`sent: false`);
+ *   - a call that started under the SDK's checks is refused once its answer is
+ *     in, unread, when the library sent a `tools/list` request while the call
+ *     was out (`sent: true`): the SDK may have checked it against another list.
+ *
+ * A schema is compiled when a tool's own checks first need it, never before:
+ * the one-page normal case compiles nothing twice.
+ */
+/** JSON-RPC's codes for the two errors the SDK raises here. */
+const INVALID_REQUEST = -32600;
+const INVALID_PARAMS = -32602;
+/**
+ * The kit for one connection, named `server`, whose list requests `listings`
+ * counts (`listingsOf(connection)`, shared by every client over it). `given` is
+ * the caller's `jsonSchemaValidator`; `loaded` holds what the library loaded
+ * with the SDK on the Node loader arm — the SDK's default validator class and
+ * its `McpError` — each `undefined` where it is not a constructor (another arm,
+ * or an SDK without it).
+ */
+export function callCheckKit(server, listings, given, loaded = {}) {
+    const Default = typeof loaded.Validator === 'function' ? loaded.Validator : undefined;
+    let created;
+    return {
+        server,
+        validator: () => {
+            if (given !== undefined)
+                return given;
+            if (Default === undefined)
+                return undefined;
+            created ??= new Default();
+            return created;
+        },
+        ...(typeof loaded.McpError === 'function' && { McpError: loaded.McpError }),
+        listings,
+    };
+}
+/**
+ * `value` as a validator, or `undefined` when it was not given. Refused by name
+ * when it is something else, before anything connects.
+ */
+export function validatorOption(value, at) {
+    if (value === undefined)
+        return undefined;
+    const getValidator = value !== null && (typeof value === 'object' || typeof value === 'function')
+        ? value.getValidator
+        : undefined;
+    if (typeof getValidator === 'function')
+        return value;
+    throw new TypeError(`${at}: \`jsonSchemaValidator\` has no \`getValidator\` method. Pass a JSON Schema ` +
+        "validator as the MCP SDK's `Client` takes one: `new AjvJsonSchemaValidator()` from " +
+        "'@modelcontextprotocol/sdk/validation/ajv', or the one your client uses.");
+}
+/**
+ * The checks `listed` carries — `undefined` when it declares none. `generation`
+ * is the one answer its list was read in, when it was read in one
+ * (`toolList.ts` · `ToolListing`); a paged list's tools have none, so the SDK
+ * never holds all of them.
+ */
+export function checksFor(listed, kit, generation) {
+    const schema = ownObject(listed, 'outputSchema');
+    const taskRequired = ownValue(ownObject(listed, 'execution'), 'taskSupport') === 'required';
+    if (schema === undefined && !taskRequired)
+        return undefined;
+    let compiled;
+    return {
+        server: kit.server,
+        tool: listed.name,
+        taskRequired,
+        outputDeclared: schema !== undefined,
+        heldBySdk: () => generation !== undefined && kit.listings.isLatest(generation),
+        validate: () => {
+            if (schema !== undefined)
+                compiled ??= kit.validator()?.getValidator(schema);
+            return compiled;
+        },
+        fail: (code, message) => kit.McpError !== undefined
+            ? new kit.McpError(code, message)
+            : new McpErrorShape(code, message),
+    };
+}
+/**
+ * True when this call's output cannot be checked here: it runs under the
+ * tool's own checks, the tool declares an `outputSchema`, no validator is
+ * reachable, and it is not refused as a required task anyway (that refusal is
+ * the SDK's, and comes first). The call is then refused before it is sent.
+ */
+export function outputUnchecked(checks) {
+    return checks.outputDeclared && !checks.taskRequired && checks.validate() === undefined;
+}
+/** The SDK's task refusal, word for word, before anything is sent. */
+export function refuseRequiredTask(checks) {
+    if (!checks.taskRequired)
+        return;
+    throw checks.fail(INVALID_REQUEST, `Tool "${checks.tool}" requires task-based execution. ` +
+        'Use client.experimental.tasks.callToolStream() instead.');
+}
+/**
+ * The SDK's two output checks, in its order and with its sentences, once the
+ * answer is in and before anything reads it. An answer no validator here can
+ * check is never returned: it is refused, unread, as sent.
+ */
+export function checkOutput(checks, result) {
+    if (!checks.outputDeclared)
+        return;
+    const validate = checks.validate();
+    if (validate === undefined)
+        throw new McpOutputUncheckedError(checks.server, checks.tool, true);
+    const structured = ownValue(result, 'structuredContent');
+    if (!structured && !ownValue(result, 'isError')) {
+        throw checks.fail(INVALID_REQUEST, `Tool ${checks.tool} has an output schema but did not return structured content`);
+    }
+    if (!structured)
+        return;
+    let mismatch;
+    try {
+        const verdict = validate(structured);
+        if (!verdict.valid) {
+            mismatch = `Structured content does not match the tool's output schema: ${verdict.errorMessage}`;
+        }
+    }
+    catch (error) {
+        throw checks.fail(INVALID_PARAMS, `Failed to validate structured content: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (mismatch !== undefined)
+        throw checks.fail(INVALID_PARAMS, mismatch);
+}
+/**
+ * The SDK's `McpError`, for an arm that cannot reach the class itself (`sdk`,
+ * `connection`): the same name, `code`, `data` and message, so a caller that
+ * branches on those handles it as it handles the SDK's.
+ */
+class McpErrorShape extends Error {
+    code;
+    data;
+    constructor(code, message) {
+        super(`MCP error ${code}: ${message}`);
+        this.code = code;
+        this.data = undefined;
+        this.name = 'McpError';
+    }
+}
+/** What the refusal says happened, refused before sending. */
+const NOT_SENT = 'was not sent. The tool declares an outputSchema, the MCP SDK no longer holds the checks of ' +
+    'the tool list it came from (that list was paged, a later list replaced it, or a list is ' +
+    'being read)';
+/** What the refusal says happened, refused once the answer was in. */
+const SENT_UNREAD = 'was sent, and its answer is not returned. The tool declares an outputSchema, a tool list ' +
+    'was read while the call was out (so the MCP SDK may not have checked the answer against ' +
+    "this tool's schema)";
+/**
+ * A tool call whose output this connection cannot check, refused. The tool
+ * declares an `outputSchema`, the MCP SDK no longer holds the checks of the
+ * tool list it came from, and this connection has no JSON Schema validator to
+ * check it with — so its answer is never returned:
+ *
+ *   - `sent: false` — refused before it was sent: nothing reached the server.
+ *     The tool came from a paged list, from a list a later answer replaced, or
+ *     the call was made while a list was being read.
+ *   - `sent: true` — the call was sent, and a `tools/list` request went out
+ *     before its answer came in: the SDK may have checked that answer against
+ *     the other list, so it is refused unread. The tool may have run.
+ *
+ * Pass `jsonSchemaValidator` — the validator your client uses — to `mcpClient`.
+ * Names the server and the tool, never an argument or an answer.
+ */
+export class McpOutputUncheckedError extends Error {
+    server;
+    tool;
+    sent;
+    code = 'ERR_MCP_OUTPUT_UNCHECKED';
+    reason = 'output-unchecked';
+    constructor(server, tool, 
+    /** Whether the request left the client: `false` when the refusal came before it. */
+    sent) {
+        super(`mcpClient[${server}]: the call to '${tool}' ${sent ? SENT_UNREAD : NOT_SENT}, and this ` +
+            'connection has no JSON Schema validator to check its output with. Pass ' +
+            '`jsonSchemaValidator` to mcpClient: the validator your client uses.');
+        this.server = server;
+        this.tool = tool;
+        this.sent = sent;
+        this.name = 'McpOutputUncheckedError';
+    }
+}
+/** An own data property, never an accessor's result; `undefined` otherwise. */
+function ownValue(value, key) {
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined && 'value' in descriptor ? descriptor.value : undefined;
+}
+/** An own data property that is a plain object (not an array); `undefined` otherwise. */
+function ownObject(value, key) {
+    const found = ownValue(value, key);
+    return found !== null && typeof found === 'object' && !Array.isArray(found)
+        ? found
+        : undefined;
+}
+//# sourceMappingURL=callChecks.js.map

package/dist/esm/mcp/callChecks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"callChecks.js","sourceRoot":"","sources":["../../../src/mcp/callChecks.ts"],"names":[],"mappings":"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"}

package/dist/esm/mcp/index.d.ts

@@ -13,4 +13,6 @@ export { retryingFetch } from './throttleRetry.js';
 export type { RetryOnThrottle, ThrottleFetch, ThrottleRetryInfo, ThrottleRetryOptions, } from './throttleRetry.js';
 export type { McpReplayDeduplication, McpReplayKind, McpReplayOptions, McpReplayPolicy, McpReplayTool, } from './replay.js';
 export { McpReplayUnavailableError, type McpReplayUnavailableReason } from './replayUnavailable.js';
-export type { McpCallToolResult, McpClient, McpClientOptions, McpConnection, McpConnectionOptions, McpSdk, McpGatewayTransport, McpHttpTransport, McpStdioTransport, McpTransport, McpSdkClient, McpServeOptions, McpServeHandle, McpServeTransport, McpHttpServeTransport, McpStdioServeTransport, McpSdkServer, } from './types.js';
+export { McpToolListIncompleteError, type McpToolListIncompleteReason } from './toolList.js';
+export { McpOutputUncheckedError } from './callChecks.js';
+export type { McpCallToolResult, McpClient, McpClientOptions, McpConnection, McpConnectionOptions, McpJsonSchemaValidator, McpSdk, McpGatewayTransport, McpHttpTransport, McpStdioTransport, McpTransport, McpSdkClient, McpServeOptions, McpServeHandle, McpServeTransport, McpHttpServeTransport, McpStdioServeTransport, McpSdkServer, } from './types.js';

package/dist/esm/mcp/index.js

@@ -18,4 +18,11 @@ export { retryingFetch } from './throttleRetry.js';
 // A call under 'app-authorized' that a connection cannot honour is refused
 // before it is sent, with a typed reason.
 export { McpReplayUnavailableError } from './replayUnavailable.js';
+// A tool list that could not be read to its end (past 100 requests, or a cursor
+// sent twice) is refused with this error and a typed reason, never cut short.
+export { McpToolListIncompleteError } from './toolList.js';
+// A tool whose list the SDK no longer holds, and whose output this connection
+// cannot check — no JSON Schema validator reachable — is refused, never answered
+// unchecked.
+export { McpOutputUncheckedError } from './callChecks.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/mcp/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,8EAA8E;AAC9E,0EAA0E;AAC1E,OAAO,EAAE,mBAAmB,EAAsB,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,aAAa,EAA+C,MAAM,oBAAoB,CAAC;AAChG,OAAO,EACL,gBAAgB,EAChB,iCAAiC,GAElC,MAAM,uBAAuB,CAAC;AAC/B,6EAA6E;AAC7E,4EAA4E;AAC5E,sEAAsE;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAgBnD,2EAA2E;AAC3E,0CAA0C;AAC1C,OAAO,EAAE,yBAAyB,EAAmC,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,8EAA8E;AAC9E,0EAA0E;AAC1E,OAAO,EAAE,mBAAmB,EAAsB,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,aAAa,EAA+C,MAAM,oBAAoB,CAAC;AAChG,OAAO,EACL,gBAAgB,EAChB,iCAAiC,GAElC,MAAM,uBAAuB,CAAC;AAC/B,6EAA6E;AAC7E,4EAA4E;AAC5E,sEAAsE;AACtE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAgBnD,2EAA2E;AAC3E,0CAA0C;AAC1C,OAAO,EAAE,yBAAyB,EAAmC,MAAM,wBAAwB,CAAC;AACpG,gFAAgF;AAChF,8EAA8E;AAC9E,OAAO,EAAE,0BAA0B,EAAoC,MAAM,eAAe,CAAC;AAC7F,8EAA8E;AAC9E,iFAAiF;AACjF,aAAa;AACb,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/esm/mcp/listingGenerations.d.ts

@@ -0,0 +1,54 @@
+/**
+ * listingGenerations — which `tools/list` answer the MCP SDK's `Client` holds
+ * its per-tool call checks for, as far as one connection can tell.
+ *
+ * Pattern: a count of the list requests one connection sent and settled.
+ * Role:    The SDK's `Client` keeps its per-tool call checks (`callChecks.ts`)
+ *          for the tools of the last `tools/list` answer it received: every
+ *          answer replaces them. A request that FAILED can replace them too: the
+ *          SDK caches an answer before it returns it, and caching can throw after
+ *          the old checks are cleared (1.32: an `outputSchema` its validator
+ *          cannot compile). The library cannot see inside the SDK, but it sends
+ *          every list request it makes. So it counts them:
+ *
+ *   - a request is OUT from the moment it is sent until it settles, because the
+ *     SDK replaces its checks before the library sees the answer;
+ *   - each request that settles, answered or failed, starts a new GENERATION.
+ *
+ * The SDK holds the checks of a listing's one answer only while the generation
+ * that answer settled at is the latest and no request is out. The SDK keeps one
+ * set of checks per client, so there is one count per connection object: every
+ * `mcpClient` over the same client shares it (`listingsOf`). A `tools/list`
+ * request the library did not send — your own code calling `listTools` on a
+ * client passed as `connection`, or that client's own automatic refresh
+ * (`listChanged.tools` with `autoRefresh`) — is not counted: the library cannot
+ * see it, and a tool it handed out goes on leaving its checks to an SDK that no
+ * longer holds them. That limit is documented, and pinned by
+ * `test/mcp/listingKeepsChecks.limits.test.ts`.
+ */
+/** One settled `tools/list` request's answer, and the generation it settled at. */
+export interface SettledListing<T> {
+    readonly answer: T;
+    readonly generation: number;
+}
+/** The `tools/list` requests one connection has out, and the generations they settled at. */
+export declare class ListingGenerations {
+    private settled;
+    private out;
+    /**
+     * Send one `tools/list` request with `send`, counted as out from the moment it
+     * is sent until it settles. Settling starts a new generation, answered or not.
+     *
+     * @throws whatever `send` rejects with, as it rejected
+     */
+    ask<T>(send: () => Promise<T>): Promise<SettledListing<T>>;
+    /** True while `generation` is the latest settled one and no request is out. */
+    isLatest(generation: number): boolean;
+    private settle;
+}
+/**
+ * The count for `connection`: the same one for every `mcpClient` that adapts
+ * the same client, because the SDK keeps one set of checks per client and a
+ * listing by any of them replaces it.
+ */
+export declare function listingsOf(connection: object): ListingGenerations;

package/dist/esm/mcp/listingGenerations.js

@@ -0,0 +1,75 @@
+/**
+ * listingGenerations — which `tools/list` answer the MCP SDK's `Client` holds
+ * its per-tool call checks for, as far as one connection can tell.
+ *
+ * Pattern: a count of the list requests one connection sent and settled.
+ * Role:    The SDK's `Client` keeps its per-tool call checks (`callChecks.ts`)
+ *          for the tools of the last `tools/list` answer it received: every
+ *          answer replaces them. A request that FAILED can replace them too: the
+ *          SDK caches an answer before it returns it, and caching can throw after
+ *          the old checks are cleared (1.32: an `outputSchema` its validator
+ *          cannot compile). The library cannot see inside the SDK, but it sends
+ *          every list request it makes. So it counts them:
+ *
+ *   - a request is OUT from the moment it is sent until it settles, because the
+ *     SDK replaces its checks before the library sees the answer;
+ *   - each request that settles, answered or failed, starts a new GENERATION.
+ *
+ * The SDK holds the checks of a listing's one answer only while the generation
+ * that answer settled at is the latest and no request is out. The SDK keeps one
+ * set of checks per client, so there is one count per connection object: every
+ * `mcpClient` over the same client shares it (`listingsOf`). A `tools/list`
+ * request the library did not send — your own code calling `listTools` on a
+ * client passed as `connection`, or that client's own automatic refresh
+ * (`listChanged.tools` with `autoRefresh`) — is not counted: the library cannot
+ * see it, and a tool it handed out goes on leaving its checks to an SDK that no
+ * longer holds them. That limit is documented, and pinned by
+ * `test/mcp/listingKeepsChecks.limits.test.ts`.
+ */
+/** The `tools/list` requests one connection has out, and the generations they settled at. */
+export class ListingGenerations {
+    settled = 0;
+    out = 0;
+    /**
+     * Send one `tools/list` request with `send`, counted as out from the moment it
+     * is sent until it settles. Settling starts a new generation, answered or not.
+     *
+     * @throws whatever `send` rejects with, as it rejected
+     */
+    async ask(send) {
+        this.out += 1;
+        try {
+            const answer = await send();
+            return { answer, generation: this.settle() };
+        }
+        catch (error) {
+            this.settle();
+            throw error;
+        }
+    }
+    /** True while `generation` is the latest settled one and no request is out. */
+    isLatest(generation) {
+        return this.out === 0 && this.settled === generation;
+    }
+    settle() {
+        this.out -= 1;
+        this.settled += 1;
+        return this.settled;
+    }
+}
+/** One count per connection object, held only as long as the connection is. */
+const BY_CONNECTION = new WeakMap();
+/**
+ * The count for `connection`: the same one for every `mcpClient` that adapts
+ * the same client, because the SDK keeps one set of checks per client and a
+ * listing by any of them replaces it.
+ */
+export function listingsOf(connection) {
+    let listings = BY_CONNECTION.get(connection);
+    if (listings === undefined) {
+        listings = new ListingGenerations();
+        BY_CONNECTION.set(connection, listings);
+    }
+    return listings;
+}
+//# sourceMappingURL=listingGenerations.js.map

package/dist/esm/mcp/listingGenerations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listingGenerations.js","sourceRoot":"","sources":["../../../src/mcp/listingGenerations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAQH,6FAA6F;AAC7F,MAAM,OAAO,kBAAkB;IACrB,OAAO,GAAG,CAAC,CAAC;IACZ,GAAG,GAAG,CAAC,CAAC;IAEhB;;;;;OAKG;IACH,KAAK,CAAC,GAAG,CAAI,IAAsB;QACjC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACd,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YAC5B,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;QAC/C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED,+EAA+E;IAC/E,QAAQ,CAAC,UAAkB;QACzB,OAAO,IAAI,CAAC,GAAG,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO,KAAK,UAAU,CAAC;IACvD,CAAC;IAEO,MAAM;QACZ,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACd,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF;AAED,+EAA+E;AAC/E,MAAM,aAAa,GAAG,IAAI,OAAO,EAA8B,CAAC;AAEhE;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,UAAkB;IAC3C,IAAI,QAAQ,GAAG,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC7C,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;QACpC,aAAa,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}