agentfootprint 9.66.0 → 9.67.0

package/dist/adapters/mcp/agentcore.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * adapters/mcp/agentcore — reaching an AWS Bedrock **AgentCore Gateway**.
+ *
+ * ── What lives here, and why it is one file ──────────────────────────────────
+ * A Gateway is an MCP server, and `mcpClient` + `gatewayTransport` already know
+ * how to talk to one of those. Neither knows — and neither should learn — the
+ * handful of facts that are AgentCore's alone: the hostname its endpoints take,
+ * the name of the tool that searches its catalogue, the header that groups a
+ * caller's requests into one policy session, and the service name a SigV4
+ * signature is computed against. Those four facts are this file, and this file
+ * is the only place in the library that holds them.
+ *
+ * `gatewayTransport` says of itself: *"Nothing here is vendor-specific."* That
+ * stays true precisely because this exists next to it.
+ *
+ * ── What it does NOT do ──────────────────────────────────────────────────────
+ * It does not manage a Gateway. Creating one, adding targets, attaching a
+ * policy engine, enabling semantic search — all control-plane operations on
+ * `bedrock-agentcore-control`, all things an operator does once with the
+ * console, the CLI or their IaC. This is the CLIENT side: an agent using a
+ * gateway somebody already stood up.
+ *
+ * @example  An agent whose tools come from a Gateway
+ *   import { mcpClient } from 'agentfootprint/providers';
+ *   import { agentCoreGatewayTransport } from 'agentfootprint/providers';
+ *   import { agentCoreIdentity } from 'agentfootprint/security';
+ *
+ *   const gateway = await mcpClient({
+ *     name: 'gateway',
+ *     transport: agentCoreGatewayTransport({
+ *       gatewayId: 'my-gateway-a1b2c3d4e5',
+ *       region: 'us-east-1',
+ *       credentials: agentCoreIdentity({ region: 'us-east-1' }),
+ *     }),
+ *   });
+ *   const tools = await gateway.tools();
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasGatewaySearch = exports.gatewaySearchTool = exports.agentCoreGatewayTransport = exports.agentCoreGatewayUrl = exports.AGENTCORE_SIGV4_SERVICE = exports.AGENTCORE_POLICY_SESSION_HEADER = exports.AGENTCORE_GATEWAY_SEARCH_TOOL = void 0;
+const gatewayTransport_js_1 = require("../../lib/mcp/gatewayTransport.js");
+/**
+ * The Gateway's built-in semantic tool search, by its exact wire name.
+ *
+ * It is an ordinary MCP tool — `tools/call` with `{ query }` — that returns the
+ * catalogue entries closest to a natural-language description. It matters at
+ * the scale where listing every tool into a prompt stops being sensible.
+ *
+ * **It can only be enabled when the Gateway is CREATED**, never afterwards, so
+ * its absence from a catalogue is a fact about that gateway rather than a
+ * transient condition to retry.
+ */
+exports.AGENTCORE_GATEWAY_SEARCH_TOOL = 'x_amz_bedrock_agentcore_search';
+/**
+ * The header that groups a caller's requests into ONE policy session.
+ *
+ * AgentCore's temporal policies decide on SEQUENCES of actions — "not after
+ * three refunds", "only once this was approved" — and a sequence needs a
+ * boundary. This header is that boundary, and without it every request is its
+ * own history of one, which quietly makes every sequence rule unenforceable.
+ */
+exports.AGENTCORE_POLICY_SESSION_HEADER = 'x-amzn-bedrock-agentcore-policy-session-id';
+/** The service name a SigV4 signature for a Gateway is computed against. */
+exports.AGENTCORE_SIGV4_SERVICE = 'bedrock-agentcore';
+/**
+ * The MCP endpoint of a Gateway.
+ *
+ * `https://{gatewayId}.gateway.bedrock-agentcore.{region}.amazonaws.com/mcp` —
+ * a shape nobody remembers correctly, which is the entire reason it is a
+ * function and not a line in a README.
+ */
+function agentCoreGatewayUrl(options) {
+    const { gatewayId, region } = options;
+    if (!gatewayId || !region) {
+        throw new TypeError('agentCoreGatewayUrl: both `gatewayId` and `region` are required — the endpoint hostname ' +
+            'is built from the two.');
+    }
+    return `https://${gatewayId}.gateway.bedrock-agentcore.${region}.amazonaws.com/mcp`;
+}
+exports.agentCoreGatewayUrl = agentCoreGatewayUrl;
+/**
+ * An MCP transport pointed at an AgentCore Gateway.
+ *
+ * A configuration of {@link gatewayTransport}: the endpoint built from your
+ * gateway's id and region, and — when you name one — the policy session header
+ * stamped on every request. Token vending, the once-and-dropped secrecy rule
+ * and the rotation behaviour are all the neutral transport's, unchanged.
+ */
+function agentCoreGatewayTransport(options) {
+    const { policySessionId, fetch: innerFetch } = options;
+    // The header is stamped in the `fetch` seam rather than in `headers` because
+    // the seam runs per request. That is what lets the session id come from a
+    // function, which is what keeps two people on one transport in two sessions.
+    const stampPolicySession = policySessionId === undefined
+        ? innerFetch
+        : async (input, init) => {
+            const id = typeof policySessionId === 'function' ? policySessionId() : policySessionId;
+            const next = id === undefined || id === ''
+                ? init
+                : {
+                    ...init,
+                    headers: {
+                        ...init?.headers,
+                        [exports.AGENTCORE_POLICY_SESSION_HEADER]: id,
+                    },
+                };
+            return innerFetch ? innerFetch(input, next) : globalThis.fetch(input, next);
+        };
+    return (0, gatewayTransport_js_1.gatewayTransport)({
+        url: agentCoreGatewayUrl(options),
+        credentials: options.credentials,
+        ...(options.service !== undefined && { service: options.service }),
+        ...(options.scopes !== undefined && { scopes: options.scopes }),
+        ...(options.mode !== undefined && { mode: options.mode }),
+        ...(options.headers !== undefined && { headers: options.headers }),
+        ...(stampPolicySession !== undefined && { fetch: stampPolicySession }),
+    });
+}
+exports.agentCoreGatewayTransport = agentCoreGatewayTransport;
+/**
+ * The Gateway's semantic search tool, if this gateway has one.
+ *
+ * Returns `undefined` rather than throwing, because absence is a legitimate and
+ * PERMANENT answer: semantic search is enabled when a Gateway is created and
+ * cannot be turned on afterwards, so there is nothing to retry.
+ *
+ * ── Why this finds the tool instead of calling it ────────────────────────────
+ * The obvious convenience would be `search(gateway, 'refund an order')`, and it
+ * is deliberately not here. Executing a tool needs a `ToolExecutionContext` —
+ * the call id, the iteration, the credential seam, the artifact store — and
+ * that object belongs to the agent loop. A helper would have to invent one,
+ * and a call made on an invented context is a call that appears in no trace:
+ * the model would be handed a shortlist nobody can later explain the origin of,
+ * which is the opposite of what this library is for.
+ *
+ * So the search tool is registered like any other tool, the model calls it when
+ * the catalogue is too large to reason about, and that call is an ordinary
+ * tool call in the trace — visible, attributable, and replayable.
+ *
+ * @example  Give the model the catalogue's own search
+ *   const tools = await gateway.tools();
+ *   const search = gatewaySearchTool(tools);
+ *   Agent.create({ provider, model })
+ *     .tools(search ? [search] : tools)   // search it, or list it
+ *     .build();
+ */
+function gatewaySearchTool(tools) {
+    return tools.find((t) => t.schema.name === exports.AGENTCORE_GATEWAY_SEARCH_TOOL);
+}
+exports.gatewaySearchTool = gatewaySearchTool;
+/** Whether this gateway's catalogue can be searched rather than listed. */
+function hasGatewaySearch(tools) {
+    return gatewaySearchTool(tools) !== undefined;
+}
+exports.hasGatewaySearch = hasGatewaySearch;
+//# sourceMappingURL=agentcore.js.map

package/dist/adapters/mcp/agentcore.js.map

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

package/dist/esm/adapters/mcp/agentcore.d.ts

@@ -0,0 +1,143 @@
+/**
+ * adapters/mcp/agentcore — reaching an AWS Bedrock **AgentCore Gateway**.
+ *
+ * ── What lives here, and why it is one file ──────────────────────────────────
+ * A Gateway is an MCP server, and `mcpClient` + `gatewayTransport` already know
+ * how to talk to one of those. Neither knows — and neither should learn — the
+ * handful of facts that are AgentCore's alone: the hostname its endpoints take,
+ * the name of the tool that searches its catalogue, the header that groups a
+ * caller's requests into one policy session, and the service name a SigV4
+ * signature is computed against. Those four facts are this file, and this file
+ * is the only place in the library that holds them.
+ *
+ * `gatewayTransport` says of itself: *"Nothing here is vendor-specific."* That
+ * stays true precisely because this exists next to it.
+ *
+ * ── What it does NOT do ──────────────────────────────────────────────────────
+ * It does not manage a Gateway. Creating one, adding targets, attaching a
+ * policy engine, enabling semantic search — all control-plane operations on
+ * `bedrock-agentcore-control`, all things an operator does once with the
+ * console, the CLI or their IaC. This is the CLIENT side: an agent using a
+ * gateway somebody already stood up.
+ *
+ * @example  An agent whose tools come from a Gateway
+ *   import { mcpClient } from 'agentfootprint/providers';
+ *   import { agentCoreGatewayTransport } from 'agentfootprint/providers';
+ *   import { agentCoreIdentity } from 'agentfootprint/security';
+ *
+ *   const gateway = await mcpClient({
+ *     name: 'gateway',
+ *     transport: agentCoreGatewayTransport({
+ *       gatewayId: 'my-gateway-a1b2c3d4e5',
+ *       region: 'us-east-1',
+ *       credentials: agentCoreIdentity({ region: 'us-east-1' }),
+ *     }),
+ *   });
+ *   const tools = await gateway.tools();
+ */
+import { type FetchLike } from '../../lib/mcp/gatewayTransport.js';
+import type { McpGatewayTransport } from '../../lib/mcp/types.js';
+import type { CredentialProvider } from '../../identity/types.js';
+import type { Tool } from '../../core/tools.js';
+/**
+ * The Gateway's built-in semantic tool search, by its exact wire name.
+ *
+ * It is an ordinary MCP tool — `tools/call` with `{ query }` — that returns the
+ * catalogue entries closest to a natural-language description. It matters at
+ * the scale where listing every tool into a prompt stops being sensible.
+ *
+ * **It can only be enabled when the Gateway is CREATED**, never afterwards, so
+ * its absence from a catalogue is a fact about that gateway rather than a
+ * transient condition to retry.
+ */
+export declare const AGENTCORE_GATEWAY_SEARCH_TOOL = "x_amz_bedrock_agentcore_search";
+/**
+ * The header that groups a caller's requests into ONE policy session.
+ *
+ * AgentCore's temporal policies decide on SEQUENCES of actions — "not after
+ * three refunds", "only once this was approved" — and a sequence needs a
+ * boundary. This header is that boundary, and without it every request is its
+ * own history of one, which quietly makes every sequence rule unenforceable.
+ */
+export declare const AGENTCORE_POLICY_SESSION_HEADER = "x-amzn-bedrock-agentcore-policy-session-id";
+/** The service name a SigV4 signature for a Gateway is computed against. */
+export declare const AGENTCORE_SIGV4_SERVICE = "bedrock-agentcore";
+export interface AgentCoreGatewayUrlOptions {
+    /** The gateway's id, as the console and `CreateGateway`'s response give it. */
+    readonly gatewayId: string;
+    /** The region it lives in, e.g. `'us-east-1'`. */
+    readonly region: string;
+}
+/**
+ * The MCP endpoint of a Gateway.
+ *
+ * `https://{gatewayId}.gateway.bedrock-agentcore.{region}.amazonaws.com/mcp` —
+ * a shape nobody remembers correctly, which is the entire reason it is a
+ * function and not a line in a README.
+ */
+export declare function agentCoreGatewayUrl(options: AgentCoreGatewayUrlOptions): string;
+export interface AgentCoreGatewayTransportOptions extends AgentCoreGatewayUrlOptions {
+    /** Who vends the token. `agentCoreIdentity()` is the usual answer. */
+    readonly credentials: CredentialProvider;
+    /** The downstream service id your provider keys on. Default `'gateway'`. */
+    readonly service?: string;
+    /** OAuth scopes, when the provider uses them. */
+    readonly scopes?: readonly string[];
+    /** `machine` (default) or `user`, for a gateway that acts on someone's behalf. */
+    readonly mode?: 'machine' | 'user';
+    /**
+     * The policy session this caller's requests belong to — a string, or a
+     * function consulted PER REQUEST.
+     *
+     * **Prefer the function on any transport more than one person shares.** A
+     * fixed string on a shared transport merges every caller's action history
+     * into a single policy session, which is not a small mistake: it makes one
+     * person's earlier actions count against another person's rule. Passing
+     * `() => currentSessionId` keeps the boundary where it belongs, and returning
+     * `undefined` sends no header at all.
+     */
+    readonly policySessionId?: string | (() => string | undefined);
+    /** Extra static headers. **No secrets** — these live as long as the transport. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Your own `fetch`, called underneath the per-request vending. */
+    readonly fetch?: FetchLike;
+}
+/**
+ * An MCP transport pointed at an AgentCore Gateway.
+ *
+ * A configuration of {@link gatewayTransport}: the endpoint built from your
+ * gateway's id and region, and — when you name one — the policy session header
+ * stamped on every request. Token vending, the once-and-dropped secrecy rule
+ * and the rotation behaviour are all the neutral transport's, unchanged.
+ */
+export declare function agentCoreGatewayTransport(options: AgentCoreGatewayTransportOptions): McpGatewayTransport;
+/**
+ * The Gateway's semantic search tool, if this gateway has one.
+ *
+ * Returns `undefined` rather than throwing, because absence is a legitimate and
+ * PERMANENT answer: semantic search is enabled when a Gateway is created and
+ * cannot be turned on afterwards, so there is nothing to retry.
+ *
+ * ── Why this finds the tool instead of calling it ────────────────────────────
+ * The obvious convenience would be `search(gateway, 'refund an order')`, and it
+ * is deliberately not here. Executing a tool needs a `ToolExecutionContext` —
+ * the call id, the iteration, the credential seam, the artifact store — and
+ * that object belongs to the agent loop. A helper would have to invent one,
+ * and a call made on an invented context is a call that appears in no trace:
+ * the model would be handed a shortlist nobody can later explain the origin of,
+ * which is the opposite of what this library is for.
+ *
+ * So the search tool is registered like any other tool, the model calls it when
+ * the catalogue is too large to reason about, and that call is an ordinary
+ * tool call in the trace — visible, attributable, and replayable.
+ *
+ * @example  Give the model the catalogue's own search
+ *   const tools = await gateway.tools();
+ *   const search = gatewaySearchTool(tools);
+ *   Agent.create({ provider, model })
+ *     .tools(search ? [search] : tools)   // search it, or list it
+ *     .build();
+ */
+export declare function gatewaySearchTool(tools: readonly Tool[]): Tool | undefined;
+/** Whether this gateway's catalogue can be searched rather than listed. */
+export declare function hasGatewaySearch(tools: readonly Tool[]): boolean;

package/dist/esm/adapters/mcp/agentcore.js

@@ -0,0 +1,149 @@
+/**
+ * adapters/mcp/agentcore — reaching an AWS Bedrock **AgentCore Gateway**.
+ *
+ * ── What lives here, and why it is one file ──────────────────────────────────
+ * A Gateway is an MCP server, and `mcpClient` + `gatewayTransport` already know
+ * how to talk to one of those. Neither knows — and neither should learn — the
+ * handful of facts that are AgentCore's alone: the hostname its endpoints take,
+ * the name of the tool that searches its catalogue, the header that groups a
+ * caller's requests into one policy session, and the service name a SigV4
+ * signature is computed against. Those four facts are this file, and this file
+ * is the only place in the library that holds them.
+ *
+ * `gatewayTransport` says of itself: *"Nothing here is vendor-specific."* That
+ * stays true precisely because this exists next to it.
+ *
+ * ── What it does NOT do ──────────────────────────────────────────────────────
+ * It does not manage a Gateway. Creating one, adding targets, attaching a
+ * policy engine, enabling semantic search — all control-plane operations on
+ * `bedrock-agentcore-control`, all things an operator does once with the
+ * console, the CLI or their IaC. This is the CLIENT side: an agent using a
+ * gateway somebody already stood up.
+ *
+ * @example  An agent whose tools come from a Gateway
+ *   import { mcpClient } from 'agentfootprint/providers';
+ *   import { agentCoreGatewayTransport } from 'agentfootprint/providers';
+ *   import { agentCoreIdentity } from 'agentfootprint/security';
+ *
+ *   const gateway = await mcpClient({
+ *     name: 'gateway',
+ *     transport: agentCoreGatewayTransport({
+ *       gatewayId: 'my-gateway-a1b2c3d4e5',
+ *       region: 'us-east-1',
+ *       credentials: agentCoreIdentity({ region: 'us-east-1' }),
+ *     }),
+ *   });
+ *   const tools = await gateway.tools();
+ */
+import { gatewayTransport } from '../../lib/mcp/gatewayTransport.js';
+/**
+ * The Gateway's built-in semantic tool search, by its exact wire name.
+ *
+ * It is an ordinary MCP tool — `tools/call` with `{ query }` — that returns the
+ * catalogue entries closest to a natural-language description. It matters at
+ * the scale where listing every tool into a prompt stops being sensible.
+ *
+ * **It can only be enabled when the Gateway is CREATED**, never afterwards, so
+ * its absence from a catalogue is a fact about that gateway rather than a
+ * transient condition to retry.
+ */
+export const AGENTCORE_GATEWAY_SEARCH_TOOL = 'x_amz_bedrock_agentcore_search';
+/**
+ * The header that groups a caller's requests into ONE policy session.
+ *
+ * AgentCore's temporal policies decide on SEQUENCES of actions — "not after
+ * three refunds", "only once this was approved" — and a sequence needs a
+ * boundary. This header is that boundary, and without it every request is its
+ * own history of one, which quietly makes every sequence rule unenforceable.
+ */
+export const AGENTCORE_POLICY_SESSION_HEADER = 'x-amzn-bedrock-agentcore-policy-session-id';
+/** The service name a SigV4 signature for a Gateway is computed against. */
+export const AGENTCORE_SIGV4_SERVICE = 'bedrock-agentcore';
+/**
+ * The MCP endpoint of a Gateway.
+ *
+ * `https://{gatewayId}.gateway.bedrock-agentcore.{region}.amazonaws.com/mcp` —
+ * a shape nobody remembers correctly, which is the entire reason it is a
+ * function and not a line in a README.
+ */
+export function agentCoreGatewayUrl(options) {
+    const { gatewayId, region } = options;
+    if (!gatewayId || !region) {
+        throw new TypeError('agentCoreGatewayUrl: both `gatewayId` and `region` are required — the endpoint hostname ' +
+            'is built from the two.');
+    }
+    return `https://${gatewayId}.gateway.bedrock-agentcore.${region}.amazonaws.com/mcp`;
+}
+/**
+ * An MCP transport pointed at an AgentCore Gateway.
+ *
+ * A configuration of {@link gatewayTransport}: the endpoint built from your
+ * gateway's id and region, and — when you name one — the policy session header
+ * stamped on every request. Token vending, the once-and-dropped secrecy rule
+ * and the rotation behaviour are all the neutral transport's, unchanged.
+ */
+export function agentCoreGatewayTransport(options) {
+    const { policySessionId, fetch: innerFetch } = options;
+    // The header is stamped in the `fetch` seam rather than in `headers` because
+    // the seam runs per request. That is what lets the session id come from a
+    // function, which is what keeps two people on one transport in two sessions.
+    const stampPolicySession = policySessionId === undefined
+        ? innerFetch
+        : async (input, init) => {
+            const id = typeof policySessionId === 'function' ? policySessionId() : policySessionId;
+            const next = id === undefined || id === ''
+                ? init
+                : {
+                    ...init,
+                    headers: {
+                        ...init?.headers,
+                        [AGENTCORE_POLICY_SESSION_HEADER]: id,
+                    },
+                };
+            return innerFetch ? innerFetch(input, next) : globalThis.fetch(input, next);
+        };
+    return gatewayTransport({
+        url: agentCoreGatewayUrl(options),
+        credentials: options.credentials,
+        ...(options.service !== undefined && { service: options.service }),
+        ...(options.scopes !== undefined && { scopes: options.scopes }),
+        ...(options.mode !== undefined && { mode: options.mode }),
+        ...(options.headers !== undefined && { headers: options.headers }),
+        ...(stampPolicySession !== undefined && { fetch: stampPolicySession }),
+    });
+}
+/**
+ * The Gateway's semantic search tool, if this gateway has one.
+ *
+ * Returns `undefined` rather than throwing, because absence is a legitimate and
+ * PERMANENT answer: semantic search is enabled when a Gateway is created and
+ * cannot be turned on afterwards, so there is nothing to retry.
+ *
+ * ── Why this finds the tool instead of calling it ────────────────────────────
+ * The obvious convenience would be `search(gateway, 'refund an order')`, and it
+ * is deliberately not here. Executing a tool needs a `ToolExecutionContext` —
+ * the call id, the iteration, the credential seam, the artifact store — and
+ * that object belongs to the agent loop. A helper would have to invent one,
+ * and a call made on an invented context is a call that appears in no trace:
+ * the model would be handed a shortlist nobody can later explain the origin of,
+ * which is the opposite of what this library is for.
+ *
+ * So the search tool is registered like any other tool, the model calls it when
+ * the catalogue is too large to reason about, and that call is an ordinary
+ * tool call in the trace — visible, attributable, and replayable.
+ *
+ * @example  Give the model the catalogue's own search
+ *   const tools = await gateway.tools();
+ *   const search = gatewaySearchTool(tools);
+ *   Agent.create({ provider, model })
+ *     .tools(search ? [search] : tools)   // search it, or list it
+ *     .build();
+ */
+export function gatewaySearchTool(tools) {
+    return tools.find((t) => t.schema.name === AGENTCORE_GATEWAY_SEARCH_TOOL);
+}
+/** Whether this gateway's catalogue can be searched rather than listed. */
+export function hasGatewaySearch(tools) {
+    return gatewaySearchTool(tools) !== undefined;
+}
+//# sourceMappingURL=agentcore.js.map

package/dist/esm/adapters/mcp/agentcore.js.map

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

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

@@ -52,4 +52,6 @@ export { gatedTools } from './gatedTools.js';
 export { skillScopedTools, skillScopedToolsTarget, SKILL_SCOPED_TOOLS_ID_PREFIX, } from './skillScopedTools.js';
 export type { ToolProvider, ToolDispatchContext, ToolGatePredicate } from './types.js';
 export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizationRequiredError, } from '../lib/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 type { GatewayTransportOptions, McpCallToolResult, McpClient, McpClientOptions, McpSdkClient, McpTransport, McpStdioTransport, McpHttpTransport, McpGatewayTransport, MockMcpClientOptions, MockMcpTool, McpServeOptions, McpServeHandle, McpServeTransport, McpStdioServeTransport, McpHttpServeTransport, McpSdkServer, } from '../lib/mcp/index.js';

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

@@ -57,4 +57,9 @@ skillScopedToolsTarget, SKILL_SCOPED_TOOLS_ID_PREFIX, } from './skillScopedTools
 // one place. This subpath is the ONLY place `mcpClient` is public — the
 // top-level barrel does not re-export it.
 export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizationRequiredError, } from '../lib/mcp/index.js';
+// Reaching an AWS Bedrock AgentCore Gateway (9.66.0). A configuration of
+// `gatewayTransport` plus the four facts that are AgentCore's alone — kept in
+// the vendor's own file so the transport above stays able to say, truthfully,
+// that nothing in it is vendor-specific.
+export { agentCoreGatewayTransport, agentCoreGatewayUrl, gatewaySearchTool, hasGatewaySearch, AGENTCORE_GATEWAY_SEARCH_TOOL, AGENTCORE_POLICY_SESSION_HEADER, AGENTCORE_SIGV4_SERVICE, } from '../adapters/mcp/agentcore.js';
 //# sourceMappingURL=index.js.map

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,uBAAuB,CAAC;AAG/B,uEAAuE;AACvE,wEAAwE;AACxE,0CAA0C;AAC1C,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC,GAClC,MAAM,qBAAqB,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,uBAAuB,CAAC;AAG/B,uEAAuE;AACvE,wEAAwE;AACxE,0CAA0C;AAC1C,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC,GAClC,MAAM,qBAAqB,CAAC;AAC7B,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"}

package/dist/tool-providers/index.js

@@ -49,7 +49,7 @@
  * symbols, one door. Import from the door.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GatewayAuthorizationRequiredError = exports.gatewayTransport = exports.mockMcpClient = exports.mcpServe = exports.mcpClient = exports.SKILL_SCOPED_TOOLS_ID_PREFIX = exports.skillScopedToolsTarget = exports.skillScopedTools = exports.gatedTools = exports.staticTools = void 0;
+exports.AGENTCORE_SIGV4_SERVICE = exports.AGENTCORE_POLICY_SESSION_HEADER = exports.AGENTCORE_GATEWAY_SEARCH_TOOL = exports.hasGatewaySearch = exports.gatewaySearchTool = exports.agentCoreGatewayUrl = exports.agentCoreGatewayTransport = exports.GatewayAuthorizationRequiredError = exports.gatewayTransport = exports.mockMcpClient = exports.mcpServe = exports.mcpClient = exports.SKILL_SCOPED_TOOLS_ID_PREFIX = exports.skillScopedToolsTarget = exports.skillScopedTools = exports.gatedTools = exports.staticTools = void 0;
 var staticTools_js_1 = require("./staticTools.js");
 Object.defineProperty(exports, "staticTools", { enumerable: true, get: function () { return staticTools_js_1.staticTools; } });
 var gatedTools_js_1 = require("./gatedTools.js");
@@ -69,4 +69,16 @@ Object.defineProperty(exports, "mcpServe", { enumerable: true, get: function ()
 Object.defineProperty(exports, "mockMcpClient", { enumerable: true, get: function () { return index_js_1.mockMcpClient; } });
 Object.defineProperty(exports, "gatewayTransport", { enumerable: true, get: function () { return index_js_1.gatewayTransport; } });
 Object.defineProperty(exports, "GatewayAuthorizationRequiredError", { enumerable: true, get: function () { return index_js_1.GatewayAuthorizationRequiredError; } });
+// Reaching an AWS Bedrock AgentCore Gateway (9.66.0). A configuration of
+// `gatewayTransport` plus the four facts that are AgentCore's alone — kept in
+// the vendor's own file so the transport above stays able to say, truthfully,
+// that nothing in it is vendor-specific.
+var agentcore_js_1 = require("../adapters/mcp/agentcore.js");
+Object.defineProperty(exports, "agentCoreGatewayTransport", { enumerable: true, get: function () { return agentcore_js_1.agentCoreGatewayTransport; } });
+Object.defineProperty(exports, "agentCoreGatewayUrl", { enumerable: true, get: function () { return agentcore_js_1.agentCoreGatewayUrl; } });
+Object.defineProperty(exports, "gatewaySearchTool", { enumerable: true, get: function () { return agentcore_js_1.gatewaySearchTool; } });
+Object.defineProperty(exports, "hasGatewaySearch", { enumerable: true, get: function () { return agentcore_js_1.hasGatewaySearch; } });
+Object.defineProperty(exports, "AGENTCORE_GATEWAY_SEARCH_TOOL", { enumerable: true, get: function () { return agentcore_js_1.AGENTCORE_GATEWAY_SEARCH_TOOL; } });
+Object.defineProperty(exports, "AGENTCORE_POLICY_SESSION_HEADER", { enumerable: true, get: function () { return agentcore_js_1.AGENTCORE_POLICY_SESSION_HEADER; } });
+Object.defineProperty(exports, "AGENTCORE_SIGV4_SERVICE", { enumerable: true, get: function () { return agentcore_js_1.AGENTCORE_SIGV4_SERVICE; } });
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tool-providers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;;;AAEH,mDAA+C;AAAtC,6GAAA,WAAW,OAAA;AACpB,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,6DAM+B;AAL7B,uHAAA,gBAAgB,OAAA;AAChB,kFAAkF;AAClF,kFAAkF;AAClF,6HAAA,sBAAsB,OAAA;AACtB,mIAAA,4BAA4B,OAAA;AAI9B,uEAAuE;AACvE,wEAAwE;AACxE,0CAA0C;AAC1C,gDAM6B;AAL3B,qGAAA,SAAS,OAAA;AACT,oGAAA,QAAQ,OAAA;AACR,yGAAA,aAAa,OAAA;AACb,4GAAA,gBAAgB,OAAA;AAChB,6HAAA,iCAAiC,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tool-providers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;;;AAEH,mDAA+C;AAAtC,6GAAA,WAAW,OAAA;AACpB,iDAA6C;AAApC,2GAAA,UAAU,OAAA;AACnB,6DAM+B;AAL7B,uHAAA,gBAAgB,OAAA;AAChB,kFAAkF;AAClF,kFAAkF;AAClF,6HAAA,sBAAsB,OAAA;AACtB,mIAAA,4BAA4B,OAAA;AAI9B,uEAAuE;AACvE,wEAAwE;AACxE,0CAA0C;AAC1C,gDAM6B;AAL3B,qGAAA,SAAS,OAAA;AACT,oGAAA,QAAQ,OAAA;AACR,yGAAA,aAAa,OAAA;AACb,4GAAA,gBAAgB,OAAA;AAChB,6HAAA,iCAAiC,OAAA;AAEnC,yEAAyE;AACzE,8EAA8E;AAC9E,8EAA8E;AAC9E,yCAAyC;AACzC,6DAQsC;AAPpC,yHAAA,yBAAyB,OAAA;AACzB,mHAAA,mBAAmB,OAAA;AACnB,iHAAA,iBAAiB,OAAA;AACjB,gHAAA,gBAAgB,OAAA;AAChB,6HAAA,6BAA6B,OAAA;AAC7B,+HAAA,+BAA+B,OAAA;AAC/B,uHAAA,uBAAuB,OAAA"}

package/dist/types/adapters/mcp/agentcore.d.ts

@@ -0,0 +1,144 @@
+/**
+ * adapters/mcp/agentcore — reaching an AWS Bedrock **AgentCore Gateway**.
+ *
+ * ── What lives here, and why it is one file ──────────────────────────────────
+ * A Gateway is an MCP server, and `mcpClient` + `gatewayTransport` already know
+ * how to talk to one of those. Neither knows — and neither should learn — the
+ * handful of facts that are AgentCore's alone: the hostname its endpoints take,
+ * the name of the tool that searches its catalogue, the header that groups a
+ * caller's requests into one policy session, and the service name a SigV4
+ * signature is computed against. Those four facts are this file, and this file
+ * is the only place in the library that holds them.
+ *
+ * `gatewayTransport` says of itself: *"Nothing here is vendor-specific."* That
+ * stays true precisely because this exists next to it.
+ *
+ * ── What it does NOT do ──────────────────────────────────────────────────────
+ * It does not manage a Gateway. Creating one, adding targets, attaching a
+ * policy engine, enabling semantic search — all control-plane operations on
+ * `bedrock-agentcore-control`, all things an operator does once with the
+ * console, the CLI or their IaC. This is the CLIENT side: an agent using a
+ * gateway somebody already stood up.
+ *
+ * @example  An agent whose tools come from a Gateway
+ *   import { mcpClient } from 'agentfootprint/providers';
+ *   import { agentCoreGatewayTransport } from 'agentfootprint/providers';
+ *   import { agentCoreIdentity } from 'agentfootprint/security';
+ *
+ *   const gateway = await mcpClient({
+ *     name: 'gateway',
+ *     transport: agentCoreGatewayTransport({
+ *       gatewayId: 'my-gateway-a1b2c3d4e5',
+ *       region: 'us-east-1',
+ *       credentials: agentCoreIdentity({ region: 'us-east-1' }),
+ *     }),
+ *   });
+ *   const tools = await gateway.tools();
+ */
+import { type FetchLike } from '../../lib/mcp/gatewayTransport.js';
+import type { McpGatewayTransport } from '../../lib/mcp/types.js';
+import type { CredentialProvider } from '../../identity/types.js';
+import type { Tool } from '../../core/tools.js';
+/**
+ * The Gateway's built-in semantic tool search, by its exact wire name.
+ *
+ * It is an ordinary MCP tool — `tools/call` with `{ query }` — that returns the
+ * catalogue entries closest to a natural-language description. It matters at
+ * the scale where listing every tool into a prompt stops being sensible.
+ *
+ * **It can only be enabled when the Gateway is CREATED**, never afterwards, so
+ * its absence from a catalogue is a fact about that gateway rather than a
+ * transient condition to retry.
+ */
+export declare const AGENTCORE_GATEWAY_SEARCH_TOOL = "x_amz_bedrock_agentcore_search";
+/**
+ * The header that groups a caller's requests into ONE policy session.
+ *
+ * AgentCore's temporal policies decide on SEQUENCES of actions — "not after
+ * three refunds", "only once this was approved" — and a sequence needs a
+ * boundary. This header is that boundary, and without it every request is its
+ * own history of one, which quietly makes every sequence rule unenforceable.
+ */
+export declare const AGENTCORE_POLICY_SESSION_HEADER = "x-amzn-bedrock-agentcore-policy-session-id";
+/** The service name a SigV4 signature for a Gateway is computed against. */
+export declare const AGENTCORE_SIGV4_SERVICE = "bedrock-agentcore";
+export interface AgentCoreGatewayUrlOptions {
+    /** The gateway's id, as the console and `CreateGateway`'s response give it. */
+    readonly gatewayId: string;
+    /** The region it lives in, e.g. `'us-east-1'`. */
+    readonly region: string;
+}
+/**
+ * The MCP endpoint of a Gateway.
+ *
+ * `https://{gatewayId}.gateway.bedrock-agentcore.{region}.amazonaws.com/mcp` —
+ * a shape nobody remembers correctly, which is the entire reason it is a
+ * function and not a line in a README.
+ */
+export declare function agentCoreGatewayUrl(options: AgentCoreGatewayUrlOptions): string;
+export interface AgentCoreGatewayTransportOptions extends AgentCoreGatewayUrlOptions {
+    /** Who vends the token. `agentCoreIdentity()` is the usual answer. */
+    readonly credentials: CredentialProvider;
+    /** The downstream service id your provider keys on. Default `'gateway'`. */
+    readonly service?: string;
+    /** OAuth scopes, when the provider uses them. */
+    readonly scopes?: readonly string[];
+    /** `machine` (default) or `user`, for a gateway that acts on someone's behalf. */
+    readonly mode?: 'machine' | 'user';
+    /**
+     * The policy session this caller's requests belong to — a string, or a
+     * function consulted PER REQUEST.
+     *
+     * **Prefer the function on any transport more than one person shares.** A
+     * fixed string on a shared transport merges every caller's action history
+     * into a single policy session, which is not a small mistake: it makes one
+     * person's earlier actions count against another person's rule. Passing
+     * `() => currentSessionId` keeps the boundary where it belongs, and returning
+     * `undefined` sends no header at all.
+     */
+    readonly policySessionId?: string | (() => string | undefined);
+    /** Extra static headers. **No secrets** — these live as long as the transport. */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Your own `fetch`, called underneath the per-request vending. */
+    readonly fetch?: FetchLike;
+}
+/**
+ * An MCP transport pointed at an AgentCore Gateway.
+ *
+ * A configuration of {@link gatewayTransport}: the endpoint built from your
+ * gateway's id and region, and — when you name one — the policy session header
+ * stamped on every request. Token vending, the once-and-dropped secrecy rule
+ * and the rotation behaviour are all the neutral transport's, unchanged.
+ */
+export declare function agentCoreGatewayTransport(options: AgentCoreGatewayTransportOptions): McpGatewayTransport;
+/**
+ * The Gateway's semantic search tool, if this gateway has one.
+ *
+ * Returns `undefined` rather than throwing, because absence is a legitimate and
+ * PERMANENT answer: semantic search is enabled when a Gateway is created and
+ * cannot be turned on afterwards, so there is nothing to retry.
+ *
+ * ── Why this finds the tool instead of calling it ────────────────────────────
+ * The obvious convenience would be `search(gateway, 'refund an order')`, and it
+ * is deliberately not here. Executing a tool needs a `ToolExecutionContext` —
+ * the call id, the iteration, the credential seam, the artifact store — and
+ * that object belongs to the agent loop. A helper would have to invent one,
+ * and a call made on an invented context is a call that appears in no trace:
+ * the model would be handed a shortlist nobody can later explain the origin of,
+ * which is the opposite of what this library is for.
+ *
+ * So the search tool is registered like any other tool, the model calls it when
+ * the catalogue is too large to reason about, and that call is an ordinary
+ * tool call in the trace — visible, attributable, and replayable.
+ *
+ * @example  Give the model the catalogue's own search
+ *   const tools = await gateway.tools();
+ *   const search = gatewaySearchTool(tools);
+ *   Agent.create({ provider, model })
+ *     .tools(search ? [search] : tools)   // search it, or list it
+ *     .build();
+ */
+export declare function gatewaySearchTool(tools: readonly Tool[]): Tool | undefined;
+/** Whether this gateway's catalogue can be searched rather than listed. */
+export declare function hasGatewaySearch(tools: readonly Tool[]): boolean;
+//# sourceMappingURL=agentcore.d.ts.map

package/dist/types/adapters/mcp/agentcore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentcore.d.ts","sourceRoot":"","sources":["../../../../src/adapters/mcp/agentcore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACrF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,mCAAmC,CAAC;AAE9E;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,+CAA+C,CAAC;AAE5F,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,sBAAsB,CAAC;AAE3D,MAAM,WAAW,0BAA0B;IACzC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,MAAM,CAS/E;AAED,MAAM,WAAW,gCAAiC,SAAQ,0BAA0B;IAClF,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,kFAAkF;IAClF,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IACnC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,CAAC;IAC/D,kFAAkF;IAClF,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,mEAAmE;IACnE,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,gCAAgC,GACxC,mBAAmB,CAiCrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,SAAS,CAE1E;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,OAAO,CAEhE"}

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

@@ -52,5 +52,7 @@ export { gatedTools } from './gatedTools.js';
 export { skillScopedTools, skillScopedToolsTarget, SKILL_SCOPED_TOOLS_ID_PREFIX, } from './skillScopedTools.js';
 export type { ToolProvider, ToolDispatchContext, ToolGatePredicate } from './types.js';
 export { mcpClient, mcpServe, mockMcpClient, gatewayTransport, GatewayAuthorizationRequiredError, } from '../lib/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 type { GatewayTransportOptions, McpCallToolResult, McpClient, McpClientOptions, McpSdkClient, McpTransport, McpStdioTransport, McpHttpTransport, McpGatewayTransport, MockMcpClientOptions, MockMcpTool, McpServeOptions, McpServeHandle, McpServeTransport, McpStdioServeTransport, McpHttpServeTransport, McpSdkServer, } from '../lib/mcp/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/tool-providers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","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,EAGhB,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKvF,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC,GAClC,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,YAAY,GACb,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","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,EAGhB,sBAAsB,EACtB,4BAA4B,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKvF,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACb,gBAAgB,EAChB,iCAAiC,GAClC,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EACL,yBAAyB,EACzB,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,GACxB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,YAAY,GACb,MAAM,qBAAqB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "9.66.0",
+  "version": "9.67.0",
   "description": "The explainable agent framework — backtrack a wrong answer to the exact context that caused it (evidence, not guesses). Built on footprintjs.",
   "license": "MIT",
   "type": "commonjs",