agentfootprint 11.4.0 → 11.5.0

package/dist/esm/events/payloads.d.ts

@@ -2270,17 +2270,22 @@ export interface ToolsCodeRunPayload {
 /**
  * What one attempt of an MCP request came to.
  *
- *   - `'answered'` — a response arrived and no retry rule refused it. It is
- *     delivered as it came, WHATEVER its status: a 503 is `answered` with
+ *   - `'answered'` — an HTTP response arrived and no retry rule refused it. It
+ *     is delivered as it came, WHATEVER its status: a 503 is `answered` with
  *     `status: 503`. A response received is not an operation that succeeded,
- *     so nothing here is called success; read `status`.
+ *     so nothing here is called success; read `status`. Nor is it the MCP
+ *     call's answer: it records the HTTP exchange. A `202 Accepted`, or a
+ *     stream that closes before the call's result, is `answered`, and the
+ *     JSON-RPC answer may still never come — the end's `mayHaveRun` says when
+ *     the call failed that way.
  *   - `'refused'` — a response the retry policy recognises as a refusal
- *     (`kind`): HTTP 429, or AgentCore Runtime's session-busy reply. The only
- *     outcome that is ever retried. It records the response the server sent,
- *     not proof that nothing ran: a 429 says the request was rate-limited,
- *     nothing more (RFC 6585 §4).
+ *     (`kind`): HTTP 429, or AgentCore Runtime's session-busy reply. It records
+ *     the response the server sent, not proof that nothing ran: a 429 says the
+ *     request was rate-limited, nothing more (RFC 6585 §4). `effect` says what
+ *     is known; `permission` says what allowed asking again.
  *   - `'failed'` — the request threw before an answer arrived (a dropped
- *     connection, a DNS failure). Never retried: the server may have run it.
+ *     connection, a DNS failure). The server may have run it, so it is asked
+ *     again only when the app declared that for this tool (`replay`).
  *   - `'timed-out'` — the call's deadline (`maxElapsedMs`) cut the request
  *     while it was in flight.
  *   - `'cut'` — the call was cancelled while the request was in flight: the
@@ -2288,7 +2293,7 @@ export interface ToolsCodeRunPayload {
  *     or the call settling first. The request WAS sent; the server may already
  *     have received it and run it. A cut is never a "not run".
  *
- * The last three never had an answer, so they carry `remote: 'unknown'`.
+ * The last three never had a response, so they carry `remote: 'unknown'`.
  *
  * Every request the series sent is a row, or is counted in `omitted`: the rows
  * and `omitted` together are the requests the series sent. A request that was
@@ -2305,7 +2310,7 @@ export type ToolRequestAttemptOutcome = 'answered' | 'refused' | 'failed' | 'tim
 export type ToolRequestOutcome = ToolRequestAttemptOutcome | 'cancelled';
 /**
  * Whether the server received and ran a request, when that is not known: the
- * attempt ended without an answer (`failed`, `timed-out`, `cut`), so the
+ * attempt ended without a response (`failed`, `timed-out`, `cut`), so the
  * request may have reached the server and run there, or not. The library never
  * records such a request as not run.
  */
@@ -2313,24 +2318,81 @@ export type ToolRequestRemote = 'unknown';
 /**
  * Why the request went on after an attempt, or ended with it.
  *
- *   - `'retryable'` — refused; another attempt follows after `waitMs`. The
- *     only reason that is not an end.
+ *   - `'retryable'` — another attempt follows after `waitMs`; `permission`
+ *     says what allowed it. The only reason that is not an end.
  *   - `'answered'` — answered; the response is delivered.
- *   - `'exhausted'` — refused, and the request has made every attempt it may.
- *   - `'wait-limit'` — refused, and the wait would pass the call's total
- *     waiting budget (`maxWaitMs`). A stated `Retry-After` is never shortened
- *     to fit: the refusal is delivered instead.
- *   - `'no-time-left'` — refused, and the wait would pass the call's deadline;
- *     or the deadline cut a request or a wait.
- *   - `'not-replayable'` — refused, but the request's body cannot be sent twice.
- *   - `'not-retryable'` — the attempt failed in a way this retry never
- *     repeats: only a response the retry policy recognises as a refusal (a 429,
- *     a session-busy reply) is retried.
+ *   - `'exhausted'` — the request has made every attempt it may.
+ *   - `'wait-limit'` — the wait would pass the call's total waiting budget
+ *     (`maxWaitMs`). A stated `Retry-After` is never shortened to fit: the
+ *     refusal is delivered instead.
+ *   - `'no-time-left'` — the wait would pass the call's deadline; or the
+ *     deadline cut a request or a wait.
+ *   - `'not-replayable'` — the request's body cannot be sent twice.
+ *   - `'not-retryable'` — the attempt failed without an answer, and nothing
+ *     permits asking again after that failure: the app declared no repeat of
+ *     this tool on it (`replay`), or it is not a kind the series repeats.
+ *   - `'not-permitted'` — refused with a 429, and the policy in force does not
+ *     permit asking this tool again on it. Under `'app-authorized'`, only the
+ *     app's declaration does: a generic 429 does not prove the server ran
+ *     nothing.
+ *   - `'changes-without-key'` — the app declared this tool as making changes,
+ *     and the call carries no key the server is declared to deduplicate by. It
+ *     is never asked again automatically, under any policy.
  *   - `'cancelled'` — the caller's signal ended the request.
  */
-export type ToolRequestReason = 'retryable' | 'answered' | 'exhausted' | 'wait-limit' | 'no-time-left' | 'not-replayable' | 'not-retryable' | 'cancelled';
+export type ToolRequestReason = 'retryable' | 'answered' | 'exhausted' | 'wait-limit' | 'no-time-left' | 'not-replayable' | 'not-retryable' | 'not-permitted' | 'changes-without-key' | 'cancelled';
 /** The refusals a retry rule recognises: HTTP 429, and AgentCore Runtime's session-busy reply. */
 export type ToolRequestRefusalKind = 'throttle' | 'session-busy';
+/**
+ * What is known about whether an attempt took effect on the server —
+ * footprintjs's effect law (`AttemptEffect`), read for an MCP request:
+ *
+ *   - `'none'` — it ran nothing, and that is established: the request was
+ *     never sent (an `end` whose `attempts` is `0`). No reply establishes it.
+ *     A 429 says the request was rate-limited, and AgentCore's session-busy
+ *     body is matched by its code and words — a server behind the runtime can
+ *     answer with the same error after it ran the call.
+ *   - `'unknown'` — anything sent that did not complete: a 429, a session-busy
+ *     reply, a lost connection or a timeout after the request was sent, a cut,
+ *     a 5xx, a JSON-RPC error, a tool error (one can follow a write that
+ *     succeeded).
+ *   - `'applied'` — the call completed: the server answered it, and not with
+ *     an error. It is never proof that anything was written.
+ */
+export type ToolRequestEffect = 'none' | 'unknown' | 'applied';
+/** The failure kinds the app may declare a tool repeatable on (`replay.tools[name].on`). */
+export type ToolRequestReplayKind = 'throttle' | 'network';
+/**
+ * What allowed the next attempt — present exactly when `reason` is
+ * `'retryable'`. Permission and effect are separate facts: neither is ever
+ * read from the other.
+ *
+ *   - `by: 'declaration'` — the app's entry for this tool names the failure
+ *     kind (`on`).
+ *   - `by: 'adapter'` — the adapter the app chose retries this refusal as its
+ *     own policy: AgentCore Runtime's session-busy reply, which AWS documents
+ *     as a retryable conflict while a session starts or stops. It says what
+ *     it assumes in doing so (`assumes`).
+ *   - `by: 'compatibility'` — the compatibility policy, today's default: it
+ *     repeats a 429 for every tool, and says what it assumes in doing so
+ *     (`assumes`).
+ *
+ * An assumption is a policy, never evidence: the row's `effect` stays
+ * `'unknown'`.
+ */
+export interface ToolRequestPermission {
+    readonly by: 'declaration' | 'adapter' | 'compatibility';
+    /** `declaration` only — the failure kind the app's entry names. */
+    readonly on?: ToolRequestReplayKind;
+    /** `adapter` and `compatibility` only — what the policy assumes of the refusal it repeats. */
+    readonly assumes?: 'refused-before-execution';
+    /**
+     * The app declared this tool as making changes, so it was asked again only
+     * because the server is declared to deduplicate by a key this call carries.
+     * The key protects only if the server uses it.
+     */
+    readonly deduplicated?: true;
+}
 /**
  * footprintjs's failure categories (`AttemptCategory`) — the one fixed set
  * every attempt record uses, so a saved request groups with every other.
@@ -2373,13 +2435,22 @@ export interface ToolRequestAttempt {
     /** `failed` and `timed-out` only. */
     readonly error?: ToolRequestError;
     /**
-     * `'unknown'` when the attempt ended without an answer (`failed`,
+     * `'unknown'` when the attempt ended without a response (`failed`,
      * `timed-out`, `cut`): it was sent, and whether the server received and ran
      * it is not known. Absent when a response arrived: the record keeps what the
      * server answered (`status`) — for a `refused` attempt that is the server's
      * own refusal, not proof that nothing ran.
      */
     readonly remote?: ToolRequestRemote;
+    /**
+     * What is known about whether this attempt took effect (see
+     * {@link ToolRequestEffect}). On every attempt the library files.
+     */
+    readonly effect?: ToolRequestEffect;
+    /** What allowed the next attempt — present exactly when `reason` is `'retryable'`. */
+    readonly permission?: ToolRequestPermission;
+    /** How long the attempt took, in ms, from sending to its end. On every attempt the library files. */
+    readonly durationMs?: number;
 }
 /** How an MCP request ended. */
 export interface ToolRequestEnd {
@@ -2406,17 +2477,47 @@ export interface ToolRequestEnd {
     /** `failed` and `timed-out` only. */
     readonly error?: ToolRequestError;
     /**
-     * `'unknown'` when the request ended on an attempt with no answer (`failed`,
-     * `timed-out`, `cut`): whether the server ran that request is not known.
+     * `'unknown'` when the request ended on an attempt with no response
+     * (`failed`, `timed-out`, `cut`): whether the server ran that request is not
+     * known.
      */
     readonly remote?: ToolRequestRemote;
+    /**
+     * How many requests the series sent: `attempts.length + omitted`. On every
+     * end the library files.
+     */
+    readonly attempts?: number;
+    /**
+     * What is known about the series' effect as a whole. Uncertainty survives:
+     * once any attempt's effect is `'unknown'`, so is the series' — a later
+     * proven refusal does not resolve it, and a later success does not prove the
+     * operation happened only once. `'applied'` only when the call completed and
+     * no attempt's effect is unknown; `'none'` only when every attempt is proven
+     * to have run nothing (or none was sent). On every end the library files.
+     */
+    readonly effect?: ToolRequestEffect;
+    /**
+     * The call failed as "may have run" (footprintjs's `UnknownEffectError`, its
+     * final error — a later refusal's, or the timeout — as the `cause`): under
+     * the `'app-authorized'` policy, the call genuinely lacked an answer
+     * somewhere and did not complete. Lacking an answer is not an unknown
+     * effect: it is an attempt that got no response at all (`remote:
+     * 'unknown'`), or a request accepted over HTTP (an `answered` 2xx) whose
+     * JSON-RPC answer never came. A received refusal or error IS an answer —
+     * its effect unknown, delivered as the server sent it — so a call whose
+     * every attempt received one has no `mayHaveRun`. Absent under
+     * `'compatibility'`, where the caller sees the error it always did, and
+     * for a call its caller cancelled, which ends with the caller's reason.
+     */
+    readonly mayHaveRun?: true;
 }
 /**
  * What one MCP request's retry series did: every attempt it made, why it went
  * on or stopped after each, how long it waited, and how the request ended.
  *
  * Filed by `mcpClient`'s retry series for a call the agent dispatched, ONCE per
- * request, when the request ends — and at the moment of a cancellation, so a
+ * request, when the call settles — so the last attempt's `effect` can say
+ * whether the call completed — and at the moment of a cancellation, so a
  * run cancelled during a wait still carries it when it is saved. A call that
  * settles before its series (the MCP SDK's own timeout, say) cancels the series
  * there and then, inside the call, so it is never filed after its run, and no

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

@@ -15,35 +15,78 @@
  *      the call. The link is undone when the call settles: the SDK keeps its
  *      abort listener on the signal it was given, and a link that outlived the
  *      call would cancel a request that had already finished.
- *   2. ITS TICKET is issued, when the call carries the run's evidence port and
- *      the connection has a ledger, keyed by the request's params object.
+ *   2. ITS MARKER is issued when the connection has a ledger, with its ticket
+ *      when the call carries the run's evidence port: a library-private string
+ *      in the request's `_meta` (`callMarker.ts`), which ties the request to
+ *      the call even when the SDK copies the params, and which the transport
+ *      takes out before anything is sent.
  *   3. ITS SETTLING ENDS ITS SERIES. However `callTool` settles — answered,
  *      failed, or given up by the SDK (its own timeout) — a retry series still
  *      sending the request is cut there and then, inside the call: it files
  *      `cancelled` before the call's result is read, and sends nothing more.
+ *   4. ITS VERDICT REACHES ITS RECORD. A series that has ended waits for the
+ *      call to settle before it files, because only the call can say whether
+ *      the answer completed — a 200 can carry a tool error. The call leaves its
+ *      verdict in the request's shared replay facts (`replay.ts` ·
+ *      `RequestReplay`) before it settles the series' wait.
+ *   5. "MAY HAVE RUN" IS RAISED HERE — footprintjs's law, under the
+ *      `'app-authorized'` policy (`replay.ts` · `RequestReplay`, its
+ *      `uncertain`). A received refusal or error is preserved: a 429, a 503,
+ *      a JSON-RPC or tool error — or a chain in which every attempt received
+ *      one — keeps the server's error as it came, its effect still `unknown`.
+ *      A call that genuinely lacked an answer somewhere — an attempt with no
+ *      response at all, or a request the HTTP layer accepted whose JSON-RPC
+ *      answer never came — and then fails, fails with footprintjs's
+ *      `UnknownEffectError`, its final error (a later refusal's, or the
+ *      timeout) as the `cause`: that error alone would read as "failed, try
+ *      again". A call that completes returns normally. Under `'compatibility'`
+ *      the caller sees the error it always did; the record still says the
+ *      effect is unknown. A cancellation never raises it: a call its caller
+ *      cancelled ends with the caller's reason, as it always did.
  *
- * In dev mode, a ticket that no request was bound to by the time the call
- * settled, when a `tools/call` request DID go out, is named once per connection: the SDK copied
- * the params, so the call's attempts could not be matched to it. Its
- * cancellation still reached the request (1, and the ledger's own watch on
- * `notifications/cancelled`).
+ * In dev mode, a ticket that no request was matched to by the time the call
+ * settled, when a `tools/call` request DID go out, is named once per
+ * connection: the SDK rebuilt the params without the marker, so the call's
+ * attempts could not be matched to it. Its cancellation still reached the
+ * request (1, and the ledger's own watch on `notifications/cancelled`). Under
+ * `'app-authorized'` such a request is never sent at all
+ * (`replayUnavailable.ts`).
  */
+import type { CallVerdict } from './replay.js';
 import type { RequestLedger } from './requestLedger.js';
-/** A call that has been opened: the signal its SDK request runs under, and how to close it. */
-export interface OpenCall {
+/** A call that has been opened: the params to send, the signal its SDK request runs under, and how to close it. */
+export interface OpenCall<P extends object = object> {
+    /**
+     * What to hand the SDK: the call's params, with its private marker in
+     * `_meta` when a ledger watches the connection (`callMarker.ts`). The
+     * transport takes the marker out again: the server never sees it.
+     */
+    readonly params: P;
     /** What cancels the SDK request — absent when nothing can. */
     readonly signal?: AbortSignal;
-    /** The call settled: undo the link, cut a series still sending, check the ticket was bound. */
-    close(): void;
+    /**
+     * The call failed with `error` (`verdict` says how far it got): the error it
+     * fails with — `error` itself, or, under `'app-authorized'`, footprintjs's
+     * `UnknownEffectError` with `error` as its `cause` when the call genuinely
+     * lacked an answer somewhere (see 5 above).
+     */
+    failed(error: unknown, verdict: CallVerdict): unknown;
+    /**
+     * The call settled with `verdict`: leave it for the record, settle it in the
+     * ledger (its answer is no longer awaited), undo the link, cut a series
+     * still sending, check its request was matched.
+     */
+    close(verdict: CallVerdict): void;
 }
 /**
  * Open one call.
  *
- * @param params the request's params object — the SDK hands this very object to
- *   the transport, which is how the ledger knows the request is this call's.
+ * @param params the request's params. The call sends them marked
+ *   (`OpenCall.params`): the marker, not the object, is how the ledger knows
+ *   the request is this call's — it survives an SDK that copies the params.
  * @param ctx the call's context: its signal, and the run's evidence port if any.
  * @param clientSignal the client's own `signal` (`McpClientOptions.signal`).
  * @param ledger the connection's ledger, when the library built its transport.
  * @param server the client's name, for the dev-mode note.
  */
-export declare function openCall(params: object, ctx: unknown, clientSignal: AbortSignal | undefined, ledger: RequestLedger | undefined, server: string): OpenCall;
+export declare function openCall<P extends object>(params: P, ctx: unknown, clientSignal: AbortSignal | undefined, ledger: RequestLedger | undefined, server: string): OpenCall<P>;

package/dist/esm/mcp/callLifetime.js

@@ -15,27 +15,53 @@
  *      the call. The link is undone when the call settles: the SDK keeps its
  *      abort listener on the signal it was given, and a link that outlived the
  *      call would cancel a request that had already finished.
- *   2. ITS TICKET is issued, when the call carries the run's evidence port and
- *      the connection has a ledger, keyed by the request's params object.
+ *   2. ITS MARKER is issued when the connection has a ledger, with its ticket
+ *      when the call carries the run's evidence port: a library-private string
+ *      in the request's `_meta` (`callMarker.ts`), which ties the request to
+ *      the call even when the SDK copies the params, and which the transport
+ *      takes out before anything is sent.
  *   3. ITS SETTLING ENDS ITS SERIES. However `callTool` settles — answered,
  *      failed, or given up by the SDK (its own timeout) — a retry series still
  *      sending the request is cut there and then, inside the call: it files
  *      `cancelled` before the call's result is read, and sends nothing more.
+ *   4. ITS VERDICT REACHES ITS RECORD. A series that has ended waits for the
+ *      call to settle before it files, because only the call can say whether
+ *      the answer completed — a 200 can carry a tool error. The call leaves its
+ *      verdict in the request's shared replay facts (`replay.ts` ·
+ *      `RequestReplay`) before it settles the series' wait.
+ *   5. "MAY HAVE RUN" IS RAISED HERE — footprintjs's law, under the
+ *      `'app-authorized'` policy (`replay.ts` · `RequestReplay`, its
+ *      `uncertain`). A received refusal or error is preserved: a 429, a 503,
+ *      a JSON-RPC or tool error — or a chain in which every attempt received
+ *      one — keeps the server's error as it came, its effect still `unknown`.
+ *      A call that genuinely lacked an answer somewhere — an attempt with no
+ *      response at all, or a request the HTTP layer accepted whose JSON-RPC
+ *      answer never came — and then fails, fails with footprintjs's
+ *      `UnknownEffectError`, its final error (a later refusal's, or the
+ *      timeout) as the `cause`: that error alone would read as "failed, try
+ *      again". A call that completes returns normally. Under `'compatibility'`
+ *      the caller sees the error it always did; the record still says the
+ *      effect is unknown. A cancellation never raises it: a call its caller
+ *      cancelled ends with the caller's reason, as it always did.
  *
- * In dev mode, a ticket that no request was bound to by the time the call
- * settled, when a `tools/call` request DID go out, is named once per connection: the SDK copied
- * the params, so the call's attempts could not be matched to it. Its
- * cancellation still reached the request (1, and the ledger's own watch on
- * `notifications/cancelled`).
+ * In dev mode, a ticket that no request was matched to by the time the call
+ * settled, when a `tools/call` request DID go out, is named once per
+ * connection: the SDK rebuilt the params without the marker, so the call's
+ * attempts could not be matched to it. Its cancellation still reached the
+ * request (1, and the ledger's own watch on `notifications/cancelled`). Under
+ * `'app-authorized'` such a request is never sent at all
+ * (`replayUnavailable.ts`).
  */
-import { isDevMode } from 'footprintjs';
+import { isDevMode, UnknownEffectError } from 'footprintjs';
 import { eitherSignal, linkedController } from '../lib/abort.js';
 import { requestEvidenceOf } from '../tools/requestEvidence.js';
+import { markParams } from './callMarker.js';
 /**
  * Open one call.
  *
- * @param params the request's params object — the SDK hands this very object to
- *   the transport, which is how the ledger knows the request is this call's.
+ * @param params the request's params. The call sends them marked
+ *   (`OpenCall.params`): the marker, not the object, is how the ledger knows
+ *   the request is this call's — it survives an SDK that copies the params.
  * @param ctx the call's context: its signal, and the run's evidence port if any.
  * @param clientSignal the client's own `signal` (`McpClientOptions.signal`).
  * @param ledger the connection's ledger, when the library built its transport.
@@ -51,15 +77,37 @@ export function openCall(params, ctx, clientSignal, ledger, server) {
         ? undefined
         : { sink, signal: eitherSignal(signal, settled?.signal) };
     const sentBefore = ledger?.toolCallsSent ?? 0;
-    if (ticket !== undefined)
-        ledger?.issue(params, ticket);
+    // Every call on a watched connection gets a marker, ticket or not: under
+    // 'app-authorized' its request must be matched to it either way. The call
+    // holds its entry, so what it reads survives the connection closing.
+    const issued = ledger?.issue(ticket);
+    let mayHaveRun = false;
     return {
+        params: issued === undefined ? params : markParams(params, issued.marker),
         ...(signal !== undefined && { signal }),
-        close: () => {
+        failed: (error, verdict) => {
+            // A call its caller cancelled ends with the caller's reason, whatever its
+            // series did; the record still says what is known of its effect.
+            if (verdict === 'completed' || signal?.aborted === true)
+                return error;
+            const replay = issued?.request?.replay;
+            if (replay === undefined || !replay.uncertain)
+                return error;
+            mayHaveRun = true;
+            // The key, when one was sent, is an argument VALUE: it stays with the
+            // caller, who sent it, and never rides an error a run may record.
+            return new UnknownEffectError({ system: server, attempts: replay.sent, cause: error });
+        },
+        close: (verdict) => {
+            // The verdict first: settling the series' wait files its record.
+            issued?.request?.replay.settle(verdict, mayHaveRun);
+            // By its own entry, never the params object: a copy cannot keep a watch alive.
+            if (issued !== undefined)
+                ledger?.settle(issued);
             settled?.abort(callSettled());
             link?.unlink();
             if (ticket !== undefined && ledger !== undefined) {
-                noteUnbound(ledger, ticket, sentBefore, server);
+                noteUnbound(ledger, issued?.request !== undefined, sentBefore, server);
             }
         },
     };
@@ -85,15 +133,15 @@ function callSettled() {
     });
 }
 /** Dev mode, once per connection: a request went out for this call, but the ledger never matched it. */
-function noteUnbound(ledger, ticket, sentBefore, server) {
-    if (!isDevMode() || ledger.wasBound(ticket) || ledger.toolCallsSent <= sentBefore)
+function noteUnbound(ledger, matched, sentBefore, server) {
+    if (!isDevMode() || matched || ledger.toolCallsSent <= sentBefore)
         return;
     if (!ledger.firstUnbound())
         return;
     // eslint-disable-next-line no-console
     console.warn(`[agentfootprint] mcpClient[${server}]: a tool call's request could not be matched to ` +
-        'the call, so its retry attempts were not recorded in the run. The MCP SDK copied the ' +
-        "request's params before sending them. The call itself is unaffected, and its " +
-        'cancellation still reached the request.');
+        'the call, so its retry attempts were not recorded in the run. The MCP SDK sent the ' +
+        "request without the call's `_meta` marker: it rebuilt the request's params. The call " +
+        'itself is unaffected, and its cancellation still reached the request.');
 }
 //# sourceMappingURL=callLifetime.js.map

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

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

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

@@ -0,0 +1,43 @@
+/**
+ * callMarker — a library-private marker that ties one MCP tool call to the one
+ * request the SDK sends for it, whatever the SDK copies on the way.
+ *
+ * Pattern: mark at the call, take at the transport.
+ * Role:    The correlation hop of the request ledger (`requestLedger.ts`). The
+ *          call puts its marker in the request's own `_meta` bag
+ *          (`markParams`); the MCP SDK carries `_meta` through to the
+ *          transport — the very object, or a copy of it (`structuredClone`, a
+ *          spread) — and the ledger's watched `send` takes the marker out again
+ *          (`takeMarker`) before the transport serializes the request. The
+ *          server receives the bytes it always did: the marker never leaves the
+ *          client.
+ *
+ * An object's identity does not survive a copy; a string inside it does. So an
+ * SDK that copies the params still delivers the marker, and the request is
+ * matched to its call by the call's own word, never by guessing from content
+ * (two calls with the same arguments are the case content matching gets wrong).
+ * An SDK that rebuilds the params and drops `_meta` delivers nothing: the
+ * request then matches no call, and the ledger says so (`requestLedger.ts`).
+ */
+/** The `_meta` key the marker rides under. Never sent: `takeMarker` removes it. */
+export declare const CALL_MARKER_KEY = "agentfootprint/call-ref";
+/**
+ * `params` with `marker` added to its `_meta` bag: a new object, with every
+ * other key in its place; `params` itself is not changed. A `_meta` that was
+ * absent is added, after the other keys, so `takeMarker` can remove it whole.
+ */
+export declare function markParams<P extends object>(params: P, marker: string): P;
+/** What `takeMarker` found: the marker, when the message carried one, and the message to send. */
+export interface TakenMarker {
+    readonly marker?: string;
+    /** The message without the marker, or the message itself when it carried none. */
+    readonly message: unknown;
+}
+/**
+ * The marker a JSON-RPC message carries in `params._meta`, and the message
+ * without it. The message is never changed in place: the SDK's object stays
+ * the SDK's. Without the marker, the params are what they were before
+ * `markParams`: a `_meta` the marker alone filled is removed, and any other
+ * entry, the SDK's own included, keeps its place.
+ */
+export declare function takeMarker(message: unknown): TakenMarker;

package/dist/esm/mcp/callMarker.js

@@ -0,0 +1,69 @@
+/**
+ * callMarker — a library-private marker that ties one MCP tool call to the one
+ * request the SDK sends for it, whatever the SDK copies on the way.
+ *
+ * Pattern: mark at the call, take at the transport.
+ * Role:    The correlation hop of the request ledger (`requestLedger.ts`). The
+ *          call puts its marker in the request's own `_meta` bag
+ *          (`markParams`); the MCP SDK carries `_meta` through to the
+ *          transport — the very object, or a copy of it (`structuredClone`, a
+ *          spread) — and the ledger's watched `send` takes the marker out again
+ *          (`takeMarker`) before the transport serializes the request. The
+ *          server receives the bytes it always did: the marker never leaves the
+ *          client.
+ *
+ * An object's identity does not survive a copy; a string inside it does. So an
+ * SDK that copies the params still delivers the marker, and the request is
+ * matched to its call by the call's own word, never by guessing from content
+ * (two calls with the same arguments are the case content matching gets wrong).
+ * An SDK that rebuilds the params and drops `_meta` delivers nothing: the
+ * request then matches no call, and the ledger says so (`requestLedger.ts`).
+ */
+/** The `_meta` key the marker rides under. Never sent: `takeMarker` removes it. */
+export const CALL_MARKER_KEY = 'agentfootprint/call-ref';
+/**
+ * `params` with `marker` added to its `_meta` bag: a new object, with every
+ * other key in its place; `params` itself is not changed. A `_meta` that was
+ * absent is added, after the other keys, so `takeMarker` can remove it whole.
+ */
+export function markParams(params, marker) {
+    const meta = recordOf(params._meta) ?? {};
+    return { ...params, _meta: { ...meta, [CALL_MARKER_KEY]: marker } };
+}
+/**
+ * The marker a JSON-RPC message carries in `params._meta`, and the message
+ * without it. The message is never changed in place: the SDK's object stays
+ * the SDK's. Without the marker, the params are what they were before
+ * `markParams`: a `_meta` the marker alone filled is removed, and any other
+ * entry, the SDK's own included, keeps its place.
+ */
+export function takeMarker(message) {
+    const fields = recordOf(message);
+    const params = recordOf(fields?.['params']);
+    const meta = recordOf(params?.['_meta']);
+    if (fields === undefined ||
+        params === undefined ||
+        meta === undefined ||
+        !Object.prototype.hasOwnProperty.call(meta, CALL_MARKER_KEY)) {
+        return { message };
+    }
+    const { [CALL_MARKER_KEY]: marker, ...rest } = meta;
+    // A copy keeps every key in its place: `_meta` is replaced where it stood, or
+    // removed when the marker alone filled it.
+    const unmarked = { ...params };
+    if (Object.keys(rest).length > 0)
+        unmarked['_meta'] = rest;
+    else
+        delete unmarked['_meta'];
+    return {
+        ...(typeof marker === 'string' && { marker }),
+        message: { ...fields, params: unmarked },
+    };
+}
+/** A plain object's own fields, or `undefined` for anything else. */
+function recordOf(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+//# sourceMappingURL=callMarker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"callMarker.js","sourceRoot":"","sources":["../../../src/mcp/callMarker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,eAAe,GAAG,yBAAyB,CAAC;AAEzD;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAmB,MAAS,EAAE,MAAc;IACpE,MAAM,IAAI,GAAG,QAAQ,CAAE,MAAuC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;IAC5E,OAAO,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;AACtE,CAAC;AASD;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,OAAgB;IACzC,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC5C,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACzC,IACE,MAAM,KAAK,SAAS;QACpB,MAAM,KAAK,SAAS;QACpB,IAAI,KAAK,SAAS;QAClB,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,eAAe,CAAC,EAC5D,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,CAAC;IACrB,CAAC;IACD,MAAM,EAAE,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;IACpD,8EAA8E;IAC9E,2CAA2C;IAC3C,MAAM,QAAQ,GAA4B,EAAE,GAAG,MAAM,EAAE,CAAC;IACxD,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC;QAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;;QACtD,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC9B,OAAO;QACL,GAAG,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,EAAE,MAAM,EAAE,CAAC;QAC7C,OAAO,EAAE,EAAE,GAAG,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE;KACzC,CAAC;AACJ,CAAC;AAED,qEAAqE;AACrE,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QACzE,CAAC,CAAE,KAA2C;QAC9C,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC"}

package/dist/esm/mcp/connectionRefusals.js

@@ -65,6 +65,13 @@ const BUILT_BY_THE_TRANSPORT = [
             '`agentfootprint/providers`) and hand THAT to your transport — it is the same ' +
             'implementation, applied where you build it.',
     ],
+    [
+        'replay',
+        'The replay declaration is asked by the retry series inside that transport, and a ' +
+            'connection you built has none of ours: `retryingFetch` keeps the compatibility ' +
+            'policy (a 429 retried for every tool, the assumption recorded nowhere). Pass ' +
+            '`transport` instead to have tool calls sent again only as you declare.',
+    ],
     [
         'clientInfo',
         'Pass it to the SDK `Client` constructor instead: `new Client(clientInfo, { capabilities: {} })`.',

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

@@ -1 +1 @@
-{"version":3,"file":"connectionRefusals.js","sourceRoot":"","sources":["../../../src/mcp/connectionRefusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,0EAA0E;AAC1E,MAAM,kBAAkB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,CAAU,CAAC;AAEvE;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CACtC,IAA6C,EAC7C,IAAY;IAEZ,MAAM,EAAE,GAAG,aAAa,IAAI,GAAG,CAAC;IAChC,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,iCAAiC;IACjC,MAAM,KAAK,GAAG,IAAoD,CAAC;IAEnE,IAAI,KAAK,CAAC,YAAY,CAAC,KAAK,SAAS,EAAE,CAAC;QACtC,IAAI,KAAK,CAAC,WAAW,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,KAAK,SAAS,EAAE,CAAC;YACvE,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,kFAAkF;gBACrF,oDAAoD,CACvD,CAAC;QACJ,CAAC;QACD,OAAO;IACT,CAAC;IAED,sDAAsD;IACtD,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,sBAAsB,EAAE,CAAC;QACrD,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,SAAS,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,0BAA0B,MAAM,6BAA6B;gBAChE,oEAAoE,MAAM,QAAQ;gBAClF,6DAA6D,KAAK,EAAE,CACvE,CAAC;QACJ,CAAC;IACH,CAAC;IACD,gBAAgB,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,MAAM,sBAAsB,GAExB;IACF;QACE,iBAAiB;QACjB,gFAAgF;YAC9E,+EAA+E;YAC/E,6CAA6C;KAChD;IACD;QACE,YAAY;QACZ,kGAAkG;KACnG;IACD;QACE,WAAW;QACX,gGAAgG;KACjG;IACD;QACE,KAAK;QACL,+EAA+E;YAC7E,wCAAwC;KAC3C;IACD;QACE,SAAS;QACT,uFAAuF;KACxF;CACF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,SAAS,gBAAgB,CAAC,UAAmB,EAAE,EAAU;IACvD,MAAM,OAAO,GAAG,CAAC,UAAU,IAAI,EAAE,CAAsC,CAAC;IACxE,KAAK,MAAM,MAAM,IAAI,kBAAkB,EAAE,CAAC;QACxC,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,6BAA6B,MAAM,yCAAyC;gBAC/E,oFAAoF;gBACpF,kFAAkF;gBAClF,uDAAuD,CAC1D,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}
+{"version":3,"file":"connectionRefusals.js","sourceRoot":"","sources":["../../../src/mcp/connectionRefusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,0EAA0E;AAC1E,MAAM,kBAAkB,GAAG,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,CAAU,CAAC;AAEvE;;;;;;;GAOG;AACH,MAAM,UAAU,wBAAwB,CACtC,IAA6C,EAC7C,IAAY;IAEZ,MAAM,EAAE,GAAG,aAAa,IAAI,GAAG,CAAC;IAChC,6EAA6E;IAC7E,6EAA6E;IAC7E,8EAA8E;IAC9E,iCAAiC;IACjC,MAAM,KAAK,GAAG,IAAoD,CAAC;IAEnE,IAAI,KAAK,CAAC,YAAY,CAAC,KAAK,SAAS,EAAE,CAAC;QACtC,IAAI,KAAK,CAAC,WAAW,CAAC,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC,KAAK,SAAS,EAAE,CAAC;YACvE,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,kFAAkF;gBACrF,oDAAoD,CACvD,CAAC;QACJ,CAAC;QACD,OAAO;IACT,CAAC;IAED,sDAAsD;IACtD,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,sBAAsB,EAAE,CAAC;QACrD,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,SAAS,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,0BAA0B,MAAM,6BAA6B;gBAChE,oEAAoE,MAAM,QAAQ;gBAClF,6DAA6D,KAAK,EAAE,CACvE,CAAC;QACJ,CAAC;IACH,CAAC;IACD,gBAAgB,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,MAAM,sBAAsB,GAExB;IACF;QACE,iBAAiB;QACjB,gFAAgF;YAC9E,+EAA+E;YAC/E,6CAA6C;KAChD;IACD;QACE,QAAQ;QACR,mFAAmF;YACjF,iFAAiF;YACjF,+EAA+E;YAC/E,wEAAwE;KAC3E;IACD;QACE,YAAY;QACZ,kGAAkG;KACnG;IACD;QACE,WAAW;QACX,gGAAgG;KACjG;IACD;QACE,KAAK;QACL,+EAA+E;YAC7E,wCAAwC;KAC3C;IACD;QACE,SAAS;QACT,uFAAuF;KACxF;CACF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,SAAS,gBAAgB,CAAC,UAAmB,EAAE,EAAU;IACvD,MAAM,OAAO,GAAG,CAAC,UAAU,IAAI,EAAE,CAAsC,CAAC;IACxE,KAAK,MAAM,MAAM,IAAI,kBAAkB,EAAE,CAAC;QACxC,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,UAAU,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CACb,GAAG,EAAE,6BAA6B,MAAM,yCAAyC;gBAC/E,oFAAoF;gBACpF,kFAAkF;gBAClF,uDAAuD,CAC1D,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

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

@@ -11,4 +11,6 @@ export { mockMcpClient, type MockMcpClientOptions, type MockMcpTool } from './mo
 export { gatewayTransport, GatewayAuthorizationRequiredError, type GatewayTransportOptions, } from './gatewayTransport.js';
 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';

package/dist/esm/mcp/index.js

@@ -15,4 +15,7 @@ export { gatewayTransport, GatewayAuthorizationRequiredError, } from './gatewayT
 // 9.81.0 so the `connection` arm, which builds no transport of its own, can
 // apply the SAME implementation instead of silently going without it.
 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';
 //# 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"}
+{"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"}