agentfootprint 12.0.1 → 12.1.0

package/dist/esm/tool-providers/index.d.ts

@@ -51,7 +51,7 @@ export { staticTools } from './staticTools.js';
 export { gatedTools } from './gatedTools.js';
 export { skillScopedTools, skillScopedToolsTarget, SKILL_SCOPED_TOOLS_ID_PREFIX, } from '../tools/skillScopedTools.js';
 export type { ToolProvider, ToolDispatchContext, ToolGatePredicate, } from '../tools/toolProvider.js';
-export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizationRequiredError, McpReplayUnavailableError, MCP_TOOL_EXTRAS_KEY, retryingFetch, } from '../mcp/index.js';
+export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizationRequiredError, McpReplayUnavailableError, McpToolListIncompleteError, McpOutputUncheckedError, MCP_TOOL_EXTRAS_KEY, retryingFetch, } from '../mcp/index.js';
 export { agentCoreGatewayTransport, agentCoreGatewayUrl, gatewaySearchTool, hasGatewaySearch, AGENTCORE_GATEWAY_SEARCH_TOOL, AGENTCORE_POLICY_SESSION_HEADER, AGENTCORE_SIGV4_SERVICE, } from '../adapters/mcp/agentcore.js';
 export type { AgentCoreGatewayTransportOptions, AgentCoreGatewayUrlOptions, } from '../adapters/mcp/agentcore.js';
 export { agentCoreRuntimeMcpTransport, agentCoreRuntimeUrl, } from '../adapters/mcp/agentcoreRuntime/transport.js';
@@ -59,4 +59,4 @@ export { AGENTCORE_RUNTIME_SESSION_HEADER } from '../adapters/mcp/agentcoreRunti
 export type { AgentCoreRuntimeAuth, AgentCoreRuntimeBearerAuth, AgentCoreRuntimeMcpTransportOptions, AgentCoreRuntimeRetryOptions, AgentCoreRuntimeUrlOptions, } from '../adapters/mcp/agentcoreRuntime/transport.js';
 export type { AgentCoreRuntimeSession } from '../adapters/mcp/agentcoreRuntime/session.js';
 export type { AgentCoreRuntimeSdkClient, BedrockAgentCoreRuntimeSdkModule, } from '../adapters/mcp/agentcoreRuntime/invoke.js';
-export type { GatewayTransportOptions, McpCallToolResult, McpClient, McpClientOptions, McpReplayDeduplication, McpReplayKind, McpReplayOptions, McpReplayPolicy, McpReplayTool, McpReplayUnavailableReason, McpConnection, McpConnectionOptions, McpSdk, McpSdkClient, ThrottleFetch, McpTransport, McpStdioTransport, McpHttpTransport, McpGatewayTransport, MockMcpClientOptions, MockMcpTool, McpServeOptions, McpServeHandle, McpServeTransport, McpStdioServeTransport, McpHttpServeTransport, McpSdkServer, McpToolExtras, } from '../mcp/index.js';
+export type { GatewayTransportOptions, McpCallToolResult, McpClient, McpClientOptions, McpReplayDeduplication, McpReplayKind, McpReplayOptions, McpReplayPolicy, McpReplayTool, McpReplayUnavailableReason, McpToolListIncompleteReason, McpConnection, McpConnectionOptions, McpJsonSchemaValidator, McpSdk, McpSdkClient, ThrottleFetch, McpTransport, McpStdioTransport, McpHttpTransport, McpGatewayTransport, MockMcpClientOptions, MockMcpTool, McpServeOptions, McpServeHandle, McpServeTransport, McpStdioServeTransport, McpHttpServeTransport, McpSdkServer, McpToolExtras, } from '../mcp/index.js';

package/dist/esm/tool-providers/index.js

@@ -61,6 +61,14 @@ export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizat
 // cannot honour (its requests unmatched, or its answers unseen) is refused
 // before it is sent, with this error and a typed reason.
 McpReplayUnavailableError, 
+// A server's tool list that could not be read to its end — past 100 requests,
+// or a cursor it already sent — is refused with this error and a typed
+// reason; what was listed travels on it, never as a list cut short.
+McpToolListIncompleteError, 
+// 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.
+McpOutputUncheckedError, 
 // The `_meta` key agentfootprint's tool declarations travel under, in both
 // directions (9.71.0). Public so a server this library did not write can
 // speak it, and so a client can read a bag it received.

package/dist/esm/tool-providers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tool-providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,gBAAgB;AAChB,kFAAkF;AAClF,kFAAkF;AAClF,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,8BAA8B,CAAC;AAOtC,uEAAuE;AACvE,wEAAwE;AACxE,0CAA0C;AAC1C,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC;AACjC,0EAA0E;AAC1E,2EAA2E;AAC3E,yDAAyD;AACzD,yBAAyB;AACzB,2EAA2E;AAC3E,yEAAyE;AACzE,wDAAwD;AACxD,mBAAmB;AACnB,4EAA4E;AAC5E,8EAA8E;AAC9E,2EAA2E;AAC3E,iCAAiC;AACjC,aAAa,GACd,MAAM,iBAAiB,CAAC;AACzB,yEAAyE;AACzE,8EAA8E;AAC9E,8EAA8E;AAC9E,yCAAyC;AACzC,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,GACxB,MAAM,8BAA8B,CAAC;AAKtC,8EAA8E;AAC9E,4EAA4E;AAC5E,iFAAiF;AACjF,mCAAmC;AACnC,OAAO,EACL,4BAA4B,EAC5B,mBAAmB,GACpB,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tool-providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,gBAAgB;AAChB,kFAAkF;AAClF,kFAAkF;AAClF,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,8BAA8B,CAAC;AAOtC,uEAAuE;AACvE,wEAAwE;AACxE,0CAA0C;AAC1C,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC;AACjC,0EAA0E;AAC1E,2EAA2E;AAC3E,yDAAyD;AACzD,yBAAyB;AACzB,8EAA8E;AAC9E,uEAAuE;AACvE,oEAAoE;AACpE,0BAA0B;AAC1B,8EAA8E;AAC9E,uEAAuE;AACvE,sBAAsB;AACtB,uBAAuB;AACvB,2EAA2E;AAC3E,yEAAyE;AACzE,wDAAwD;AACxD,mBAAmB;AACnB,4EAA4E;AAC5E,8EAA8E;AAC9E,2EAA2E;AAC3E,iCAAiC;AACjC,aAAa,GACd,MAAM,iBAAiB,CAAC;AACzB,yEAAyE;AACzE,8EAA8E;AAC9E,8EAA8E;AAC9E,yCAAyC;AACzC,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,GACxB,MAAM,8BAA8B,CAAC;AAKtC,8EAA8E;AAC9E,4EAA4E;AAC5E,iFAAiF;AACjF,mCAAmC;AACnC,OAAO,EACL,4BAA4B,EAC5B,mBAAmB,GACpB,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC"}

package/dist/mcp/callChecks.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpOutputUncheckedError = exports.checkOutput = exports.refuseRequiredTask = exports.outputUnchecked = exports.checksFor = exports.validatorOption = exports.callCheckKit = void 0;
+/** 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).
+ */
+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,
+    };
+}
+exports.callCheckKit = callCheckKit;
+/**
+ * `value` as a validator, or `undefined` when it was not given. Refused by name
+ * when it is something else, before anything connects.
+ */
+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.");
+}
+exports.validatorOption = validatorOption;
+/**
+ * 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.
+ */
+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),
+    };
+}
+exports.checksFor = checksFor;
+/**
+ * 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.
+ */
+function outputUnchecked(checks) {
+    return checks.outputDeclared && !checks.taskRequired && checks.validate() === undefined;
+}
+exports.outputUnchecked = outputUnchecked;
+/** The SDK's task refusal, word for word, before anything is sent. */
+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.');
+}
+exports.refuseRequiredTask = refuseRequiredTask;
+/**
+ * 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.
+ */
+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);
+}
+exports.checkOutput = checkOutput;
+/**
+ * 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.
+ */
+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';
+    }
+}
+exports.McpOutputUncheckedError = 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/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/mcp/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.McpReplayUnavailableError = exports.retryingFetch = exports.GatewayAuthorizationRequiredError = exports.gatewayTransport = exports.mockMcpClient = exports.MCP_TOOL_EXTRAS_KEY = exports.mcpServe = exports.mcpClient = void 0;
+exports.McpOutputUncheckedError = exports.McpToolListIncompleteError = exports.McpReplayUnavailableError = exports.retryingFetch = exports.GatewayAuthorizationRequiredError = exports.gatewayTransport = exports.mockMcpClient = exports.MCP_TOOL_EXTRAS_KEY = exports.mcpServe = exports.mcpClient = void 0;
 /**
  * MCP — Model Context Protocol, both directions. `mcpClient` connects to
  * someone else's MCP server and registers its tools on your Agent;
@@ -29,4 +29,13 @@ Object.defineProperty(exports, "retryingFetch", { enumerable: true, get: functio
 // before it is sent, with a typed reason.
 var replayUnavailable_js_1 = require("./replayUnavailable.js");
 Object.defineProperty(exports, "McpReplayUnavailableError", { enumerable: true, get: function () { return replayUnavailable_js_1.McpReplayUnavailableError; } });
+// 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.
+var toolList_js_1 = require("./toolList.js");
+Object.defineProperty(exports, "McpToolListIncompleteError", { enumerable: true, get: function () { return toolList_js_1.McpToolListIncompleteError; } });
+// 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.
+var callChecks_js_1 = require("./callChecks.js");
+Object.defineProperty(exports, "McpOutputUncheckedError", { enumerable: true, get: function () { return callChecks_js_1.McpOutputUncheckedError; } });
 //# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAClB,6CAAyC;AAAhC,uGAAA,QAAQ,OAAA;AACjB,8EAA8E;AAC9E,0EAA0E;AAC1E,iDAA0E;AAAjE,oHAAA,mBAAmB,OAAA;AAC5B,uDAAgG;AAAvF,iHAAA,aAAa,OAAA;AACtB,6DAI+B;AAH7B,uHAAA,gBAAgB,OAAA;AAChB,wIAAA,iCAAiC,OAAA;AAGnC,6EAA6E;AAC7E,4EAA4E;AAC5E,sEAAsE;AACtE,uDAAmD;AAA1C,iHAAA,aAAa,OAAA;AAgBtB,2EAA2E;AAC3E,0CAA0C;AAC1C,+DAAoG;AAA3F,iIAAA,yBAAyB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,+CAA2C;AAAlC,yGAAA,SAAS,OAAA;AAClB,6CAAyC;AAAhC,uGAAA,QAAQ,OAAA;AACjB,8EAA8E;AAC9E,0EAA0E;AAC1E,iDAA0E;AAAjE,oHAAA,mBAAmB,OAAA;AAC5B,uDAAgG;AAAvF,iHAAA,aAAa,OAAA;AACtB,6DAI+B;AAH7B,uHAAA,gBAAgB,OAAA;AAChB,wIAAA,iCAAiC,OAAA;AAGnC,6EAA6E;AAC7E,4EAA4E;AAC5E,sEAAsE;AACtE,uDAAmD;AAA1C,iHAAA,aAAa,OAAA;AAgBtB,2EAA2E;AAC3E,0CAA0C;AAC1C,+DAAoG;AAA3F,iIAAA,yBAAyB,OAAA;AAClC,gFAAgF;AAChF,8EAA8E;AAC9E,6CAA6F;AAApF,yHAAA,0BAA0B,OAAA;AACnC,8EAA8E;AAC9E,iFAAiF;AACjF,aAAa;AACb,iDAA0D;AAAjD,wHAAA,uBAAuB,OAAA"}

package/dist/mcp/listingGenerations.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * 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`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listingsOf = exports.ListingGenerations = void 0;
+/** The `tools/list` requests one connection has out, and the generations they settled at. */
+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;
+    }
+}
+exports.ListingGenerations = ListingGenerations;
+/** 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.
+ */
+function listingsOf(connection) {
+    let listings = BY_CONNECTION.get(connection);
+    if (listings === undefined) {
+        listings = new ListingGenerations();
+        BY_CONNECTION.set(connection, listings);
+    }
+    return listings;
+}
+exports.listingsOf = listingsOf;
+//# sourceMappingURL=listingGenerations.js.map

package/dist/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,MAAa,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;AA/BD,gDA+BC;AAED,+EAA+E;AAC/E,MAAM,aAAa,GAAG,IAAI,OAAO,EAA8B,CAAC;AAEhE;;;;GAIG;AACH,SAAgB,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;AAPD,gCAOC"}

package/dist/mcp/mcpClient.js

@@ -48,6 +48,9 @@ exports.mcpClient = void 0;
 const footprintjs_1 = require("footprintjs");
 const toolExtras_js_1 = require("./toolExtras.js");
 const toolResult_js_1 = require("./toolResult.js");
+const toolList_js_1 = require("./toolList.js");
+const listingGenerations_js_1 = require("./listingGenerations.js");
+const callChecks_js_1 = require("./callChecks.js");
 const gatewayTransport_js_1 = require("./gatewayTransport.js");
 const throttleRetry_js_1 = require("./throttleRetry.js");
 const requestLedger_js_1 = require("./requestLedger.js");
@@ -97,7 +100,10 @@ async function mcpClient(opts) {
     // checked once, here, before anything connects (`replay.ts`).
     const replay = (0, replay_js_1.replayDeclarationOf)(opts.replay, `mcpClient[${name}]`);
     const strict = replay.policy === 'app-authorized';
-    const { connection, ledger } = await openConnection(opts, replay, name);
+    // The validator a tool's own output checks use (`callChecks.ts`), refused by
+    // name now when it is not one.
+    const validator = (0, callChecks_js_1.validatorOption)(opts.jsonSchemaValidator, `mcpClient[${name}]`);
+    const { connection, ledger, kit } = await openConnection(opts, replay, name, validator);
     const unlisted = new Set();
     // Tool cache so consumers calling `.tools()` more than once don't
     // hammer the server. `.refresh()` invalidates it.
@@ -109,13 +115,24 @@ async function mcpClient(opts) {
         }
     };
     const buildTools = async () => {
-        // `signal` rides in the SDK's THIRD argument (RequestOptions), not in
-        // the request params — see `wrapMcpTool`.
-        const listed = opts.signal
-            ? await connection.listTools(undefined, { signal: opts.signal })
-            : await connection.listTools();
-        noteUnlisted(replay, listed.tools, name, unlisted);
-        return listed.tools.map((t) => wrapMcpTool(name, connection, t, opts.signal, resultMode, ledger, strict));
+        // Every page of the server's list (`toolList.ts`). `signal` rides each
+        // page in the SDK's trailing options argument, never in the params — see
+        // `wrapMcpTool`.
+        // Each page request is counted in this connection's listings, whatever it
+        // settles to (`listingGenerations.ts`).
+        const listing = await (0, toolList_js_1.listEveryPage)(connection, opts.signal, kit.listings);
+        // A list that did not end cannot say which entries name nothing.
+        if (listing.incomplete === undefined)
+            noteUnlisted(replay, listing.tools, name, unlisted);
+        // Every tool carries the checks of the list it came from (`callChecks.ts`):
+        // the SDK's `Client` holds them only while a one-page list's answer is its
+        // latest, and only then are they left to it.
+        const tools = listing.tools.map((t) => wrapMcpTool(name, connection, t, opts.signal, resultMode, ledger, strict, (0, callChecks_js_1.checksFor)(t, kit, listing.generation)));
+        // Never a list cut short: what was listed travels on the refusal instead.
+        if (listing.incomplete !== undefined) {
+            throw new toolList_js_1.McpToolListIncompleteError(listing.incomplete, name, listing.pages, tools);
+        }
+        return tools;
     };
     return {
         name,
@@ -155,31 +172,79 @@ exports.mcpClient = mcpClient;
  * A call with neither `connection` nor `sdk` reaches `resolveClient` with two
  * `undefined` arguments and takes the identical path it always took.
  */
-async function openConnection(opts, replay, name) {
-    if (opts.connection !== undefined)
-        return { connection: opts.connection };
-    if (opts._client !== undefined)
-        return { connection: opts._client };
+async function openConnection(opts, replay, name, validator) {
+    // A client built elsewhere: the library loads nothing, so only the caller's
+    // validator can check a tool's output itself, and errors take the SDK's shape.
+    // Its list requests are counted per client: every mcpClient over it shares one
+    // count, as they share the SDK's one set of checks (`listingGenerations.ts`).
+    if (opts.connection !== undefined) {
+        const kit = (0, callChecks_js_1.callCheckKit)(name, (0, listingGenerations_js_1.listingsOf)(opts.connection), validator);
+        return { connection: opts.connection, kit };
+    }
+    if (opts._client !== undefined) {
+        return {
+            connection: opts._client,
+            kit: (0, callChecks_js_1.callCheckKit)(name, (0, listingGenerations_js_1.listingsOf)(opts._client), validator),
+        };
+    }
     // `refuseConflictingOptions` has already refused the case where this is
     // absent, so the assertion documents that guarantee rather than assuming it.
     const transport = opts.transport;
-    return resolveClient(transport, opts.clientInfo, opts.signal, opts.retryOnThrottle, opts.sdk, replay, name);
+    return resolveClient(transport, opts.clientInfo, opts.signal, opts.retryOnThrottle, opts.sdk, replay, name, validator);
 }
 // ─── SDK construction (lazy require, unless the caller supplied it) ─
-async function resolveClient(transport, clientInfo, signal, retryOnThrottle, sdk, replay, name = 'mcp') {
+async function resolveClient(transport, clientInfo, signal, retryOnThrottle, sdk, replay, name = 'mcp', validator) {
     if (sdk !== undefined)
         assertSdk(sdk, transport.transport);
     const mod = sdk ?? loadClientModule();
-    const client = new mod.Client(clientInfo ?? DEFAULT_CLIENT_INFO, {
-        capabilities: {},
-    });
+    // A caller's validator is the client's too, so one validator checks every
+    // page; without one, the options are exactly what they always were.
+    const options = validator === undefined
+        ? { capabilities: {} }
+        : { capabilities: {}, jsonSchemaValidator: validator };
+    const client = new mod.Client(clientInfo ?? DEFAULT_CLIENT_INFO, options);
     const built = await buildTransport(transport, retryOnThrottle, sdk, replay, name);
+    // With the SDK loaded here, so is what a tool's own checks run with: its
+    // default validator and its own error class. With `sdk`, the loader is never
+    // touched (`callChecks.ts`).
+    const kit = sdk === undefined
+        ? (0, callChecks_js_1.callCheckKit)(name, (0, listingGenerations_js_1.listingsOf)(client), validator, loadCheckModules(validator))
+        : (0, callChecks_js_1.callCheckKit)(name, (0, listingGenerations_js_1.listingsOf)(client), validator);
     // Same rule as callTool: options ride beside the transport, never inside it.
     if (signal)
         await client.connect(built.transport, { signal });
     else
         await client.connect(built.transport);
-    return { connection: client, ...(built.ledger !== undefined && { ledger: built.ledger }) };
+    return {
+        connection: client,
+        kit,
+        ...(built.ledger !== undefined && { ledger: built.ledger }),
+    };
+}
+/**
+ * What the SDK's `Client` checks a tool's call with, loaded with the SDK on the
+ * Node loader path (the bundling law: when the client is built, never at a
+ * later tool call): its own `McpError`, and — unless the caller gave a
+ * validator — its default validator, `AjvJsonSchemaValidator`. Both modules are
+ * the ones `client/index.js` already loaded. An SDK without one of them (older
+ * than its public validator subpath) leaves that slot empty: errors then take
+ * the SDK's shape, and an output no validator here can check is never returned.
+ */
+function loadCheckModules(validator) {
+    const McpError = loadOptional(() => (0, lazyRequire_js_1.lazyRequire)('@modelcontextprotocol/sdk/types.js'))?.McpError;
+    const Validator = validator === undefined
+        ? loadOptional(() => (0, lazyRequire_js_1.lazyRequire)('@modelcontextprotocol/sdk/validation/ajv'))?.AjvJsonSchemaValidator
+        : undefined;
+    return { McpError, Validator };
+}
+/** A module this SDK may not have: `undefined` when it cannot be loaded. */
+function loadOptional(load) {
+    try {
+        return load();
+    }
+    catch {
+        return undefined;
+    }
 }
 /**
  * An injected `sdk` is checked before anything is built, so a wrong import (a
@@ -358,7 +423,7 @@ function noteUnlisted(replay, listed, server, noted) {
     }
 }
 // ─── Tool wrapping ─────────────────────────────────────────────────
-function wrapMcpTool(serverName, connection, mcp, signal, resultMode, ledger, strict = false) {
+function wrapMcpTool(serverName, connection, mcp, signal, resultMode, ledger, strict = false, checks) {
     const tool = {
         schema: {
             name: mcp.name,
@@ -420,12 +485,32 @@ function wrapMcpTool(serverName, connection, mcp, signal, resultMode, ledger, st
             if (unavailable !== undefined) {
                 throw new replayUnavailable_js_1.McpReplayUnavailableError(unavailable, serverName, mcp.name);
             }
+            // Whose checks this call runs under, decided before anything is sent
+            // (`callChecks.ts`): the SDK's `Client` holds them while this tool's
+            // one-page list is still its latest answer and no list request is out;
+            // otherwise the tool's own checks run. An output they cannot check is
+            // refused here, unsent.
+            const own = checks !== undefined && !checks.heldBySdk();
+            if (own && (0, callChecks_js_1.outputUnchecked)(checks)) {
+                throw new callChecks_js_1.McpOutputUncheckedError(serverName, mcp.name, false);
+            }
             const call = (0, callLifetime_js_1.openCall)(params, ctx, signal, ledger, serverName);
             let verdict = 'failed';
             try {
-                const result = call.signal
-                    ? await connection.callTool(call.params, undefined, { signal: call.signal })
-                    : await connection.callTool(call.params);
+                const send = () => call.signal
+                    ? connection.callTool(call.params, undefined, { signal: call.signal })
+                    : connection.callTool(call.params);
+                // The tool's own checks run where the SDK's `callTool` runs them, so a
+                // call fails as it would with the SDK holding them: the task refusal
+                // before sending, the output checks once the answer is in.
+                if (own)
+                    (0, callChecks_js_1.refuseRequiredTask)(checks);
+                const result = await send();
+                // A list request that went out while the call was out may have replaced
+                // the SDK's checks before it read the answer, so the tool's own checks
+                // read it too.
+                if (checks !== undefined && (own || !checks.heldBySdk()))
+                    (0, callChecks_js_1.checkOutput)(checks, result);
                 verdict = (0, toolResult_js_1.isToolError)(result) ? 'tool-error' : 'completed';
                 return (0, toolResult_js_1.readToolResult)(result, mcp.name, serverName, resultMode);
             }