agentfootprint 11.4.0 → 12.0.0

package/dist/types/mcp/requestLedger.d.ts

@@ -1,48 +1,73 @@
 /**
  * requestLedger — which dispatched tool call an MCP request belongs to, so the
- * retry series that sends it files its attempts into THAT call's run; and when
- * the MCP SDK cancels a request, so the series sending it stops.
+ * retry series that sends it files its attempts into THAT call's run; when the
+ * MCP SDK cancels a request, so the series sending it stops; and whether the
+ * request's JSON-RPC answer arrived.
  *
  * Pattern: a per-connection ledger + the SDK transport's `send`, watched in place.
  * Role:    The middle of the evidence seam (`tools/requestEvidence.ts` is its
  *          door). The retry series runs inside the transport's `fetch`, which
  *          the MCP SDK calls with a serialized body and nothing else — no tool
- *          call, no run. Three hops carry the call down to it, each by an
- *          identity the hop already holds:
+ *          call, no run. Three hops carry the call down to it:
  *
- *   1. call → params    `issue`: the MCP tool keys its ticket by the request's
- *                       params OBJECT. The SDK puts that very object into the
- *                       JSON-RPC message it hands the transport.
- *   2. params → id      the watched `send` finds the ticket by `message.params`
- *                       and keys it by the JSON-RPC `id` the SDK assigned, until
- *                       that send settles.
+ *   1. call → marker    `issue`: the MCP tool gets a library-private marker and
+ *                       puts it in its request's `_meta` (`callMarker.ts`). It
+ *                       survives an SDK that copies the params.
+ *   2. marker → id      the watched `send` takes the marker out of the message
+ *                       — the server receives the bytes it always did — and
+ *                       keys the call by the JSON-RPC `id` the SDK assigned.
  *   3. id → series      `claim`: the series reads the `id` back out of the body
  *                       it is about to send.
  *
  * CANCELLATION DOES NOT WAIT ON ATTRIBUTION. Every `tools/call` in flight gets
- * an entry, ticket or not, and the SDK says when it gives a request up: it sends
- * `notifications/cancelled` naming the request's id — on its own timeout, or
- * when the call's signal fires — through this same `send`. The ledger aborts
- * that request's series there and then, so a request nobody waits for is never
- * asked again, even when its params could not be matched to a call.
+ * an entry, matched or not, and the SDK says when it gives a request up: it
+ * sends `notifications/cancelled` naming the request's id — on its own
+ * timeout, or when the call's signal fires — through this same `send`. The
+ * ledger aborts that request's series there and then, so a request nobody waits
+ * for is never asked again, even when it could not be matched to a call.
  *
- * Nothing is added to the wire: the request the server receives is
- * byte-identical, and the SDK's own options keep their meanings. Ids are the
- * client's, one ledger per connection, so concurrent calls — and concurrent
- * runs sharing one client — can never claim each other's request. A request
- * that is not a `tools/call` (a `tools/list`, a notification, a response)
- * claims nothing.
+ * Under `'app-authorized'` (`strict`), two more things hold:
+ *   - A `tools/call` that reaches `send` without a marker this ledger issued
+ *     and has not used is REFUSED there (`replayUnavailable.ts`,
+ *     `'request-unmatched'`): its answer could not be tied to any call, so it
+ *     is never sent rather than guessed at.
+ *   - Each matched request's answer is AWAITED, by its id: the connection's
+ *     incoming messages are observed for the JSON-RPC response to it. A 202, or
+ *     a stream, is not that answer. The watch ends when the answer arrives,
+ *     when the SDK cancels the request, when the call settles (found by its
+ *     marker, never by its params object) or when the connection closes —
+ *     never when only the HTTP send finished, since a 202 or a stream can still
+ *     carry the answer later.
+ *
+ * Whether the answers are observed at all is established once, at
+ * initialization: the `initialize` answer must pass the observer
+ * (`answersObserved`). An SDK whose `connect` replaces the transport's
+ * `onmessage` instead of keeping it leaves the observer out, and a call under
+ * `'app-authorized'` is then refused before it is sent (`replayUnavailable.ts`).
+ *
+ * Ids are the client's, one ledger per connection, so concurrent calls — and
+ * concurrent runs sharing one client — can never claim each other's request. A
+ * request that is not a `tools/call` (a `tools/list`, a notification, a
+ * response) claims nothing.
  *
  * `send` is installed as an OWN property of the transport instance — the same
  * object, its own `send` bound to it, so a transport class with `#private`
  * fields works as it always did. Assigning `send` again afterwards THROWS: a
  * send that bypassed the ledger would quietly lose every call's attempts.
  *
+ * Each matched `tools/call` also gets ONE `RequestReplay` (`replay.ts`), the
+ * facts its series, this ledger and its call share: the series' claim hands it
+ * over by the request's id, the call reads it from the entry it was issued
+ * (`IssuedCall`), which outlives the connection's close. The
+ * series writes what HTTP showed; this ledger writes whether the JSON-RPC
+ * answer arrived; the call writes how it settled.
+ *
  * What it does NOT do: retry, wait, or decide anything. The series is the one
  * retry owner; this only tells it whose attempts it is making, and when the SDK
  * has stopped waiting for them.
  */
 import type { RequestEvidenceSink } from '../tools/requestEvidence.js';
+import { RequestReplay } from './replay.js';
 /** One call's claim on the request it sends. */
 export interface RequestTicket {
     /** Where the request's attempts are filed. */
@@ -56,23 +81,71 @@ export interface ClaimedRequest {
     readonly ticket?: RequestTicket;
     /** Fires when the MCP SDK cancels this request (`notifications/cancelled`). */
     readonly cancelled: AbortSignal;
+    /** What this request's series and its call share (`replay.ts` · `RequestReplay`). */
+    readonly replay: RequestReplay;
+}
+/** How a connection's ledger is set up. */
+export interface RequestLedgerOptions {
+    /** The client's name, which a refusal names. */
+    readonly server: string;
+    /** The `'app-authorized'` policy is in force: see the module note. */
+    readonly strict: boolean;
 }
-/** Per connection: the tickets issued and not yet sent, and the requests being sent. */
+type JsonRpcId = string | number;
+/** The request a call's marker was matched to. */
+export interface MatchedRequest {
+    readonly id: JsonRpcId;
+    readonly replay: RequestReplay;
+}
+/**
+ * One call, from `issue` until it settles: the marker it sends, and the
+ * request matched to it once one was. The call holds this entry itself, so
+ * what it reads does not depend on the ledger still holding it.
+ */
+export interface IssuedCall {
+    readonly marker: string;
+    readonly ticket?: RequestTicket;
+    /** Set once, by the watched `send`: a marker matches ONE request. */
+    readonly request?: MatchedRequest;
+}
+/** Per connection: the calls issued and not yet settled, the requests being sent, the answers awaited. */
 export declare class RequestLedger {
-    /** Issued, not yet sent — keyed by the request's params object. Collected with it. */
+    private readonly options;
+    /** Every call issued and not yet settled — keyed by its marker. */
     private readonly issued;
-    /** Tickets a request was bound to. */
-    private readonly bound;
     /** Every `tools/call` sent and not yet settled — keyed by its JSON-RPC id. */
     private readonly sending;
+    /** Matched requests whose JSON-RPC answer is awaited (`strict` only) — by id. */
+    private readonly awaiting;
+    private initializeId;
+    private initializeAnswered;
+    private markers;
     private calls;
     private unboundNamed;
-    /** The call about to send `params` files its attempts through `ticket`. */
-    issue(params: object, ticket: RequestTicket): void;
-    /** Whether a request the transport sent was bound to `ticket`. */
-    wasBound(ticket: RequestTicket): boolean;
+    constructor(options?: RequestLedgerOptions);
+    /**
+     * A call is about to send its request: its entry, whose `marker` the call
+     * puts in the request's `_meta` (`callMarker.ts` · `markParams`). `ticket`
+     * is where its attempts are filed, when the call carries the run's evidence
+     * port.
+     */
+    issue(ticket?: RequestTicket): IssuedCall;
+    /** `call` settled: forget it, and stop awaiting its request's answer. */
+    settle(call: IssuedCall): void;
+    /** The connection closed: nothing it sent is awaited, and no call is pending, any more. */
+    close(): void;
+    /**
+     * Whether this connection's answers pass the observer: the `initialize`
+     * answer did. Read once the connection is initialized.
+     */
+    get answersObserved(): boolean;
     /** How many `tools/call` requests the watched transport has sent — matched to a call or not. */
     get toolCallsSent(): number;
+    /**
+     * @internal How many entries the ledger holds: calls issued and not settled,
+     * requests being sent, answers awaited. Zero once every call settled.
+     */
+    get retained(): number;
     /** `true` the first time it is asked, then never again: an unmatched request is named once per connection. */
     firstUnbound(): boolean;
     /**
@@ -80,8 +153,17 @@ export declare class RequestLedger {
      * original bound to the instance itself. Returns the SAME object — or
      * `undefined` when it has no `send` to watch or refuses the property, and
      * then nothing is watched and no call should expect its attempts filed.
+     *
+     * Its incoming messages are watched too: an `onmessage` set before the
+     * client connects, which the current MCP SDK's `Protocol.connect` keeps and
+     * calls before its own dispatch. Whether it was kept is known once the
+     * `initialize` answer has, or has not, passed it (`answersObserved`).
      */
     watch<T extends object>(transport: T): T | undefined;
+    /** Observe incoming messages before whatever handled them already — never instead of it. */
+    private watchMessages;
+    /** One incoming message: the `initialize` answer, or the answer to an awaited request. */
+    private observe;
     /**
      * The `tools/call` request `body` carries, while its send runs — its ticket
      * when a call issued one, and the signal its cancellation fires. `undefined`
@@ -90,9 +172,10 @@ export declare class RequestLedger {
     claim(body: unknown): ClaimedRequest | undefined;
     /** One message through the watched transport. */
     private send;
-    /** Register a `tools/call` in flight, with the ticket its params were issued — if any. */
-    private bind;
-    /** The SDK gave a request up: stop the series still sending it. */
+    /** The `initialize` request: its answer is the one that proves the observer is in place. */
+    private noteInitialize;
+    /** The SDK gave a request up: stop the series still sending it, and stop awaiting its answer. */
     private cancelIfAsked;
 }
+export {};
 //# sourceMappingURL=requestLedger.d.ts.map

package/dist/types/mcp/requestLedger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestLedger.d.ts","sourceRoot":"","sources":["../../../src/mcp/requestLedger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,gDAAgD;AAChD,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,kEAAkE;AAClE,MAAM,WAAW,cAAc;IAC7B,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACjC;AAgBD,wFAAwF;AACxF,qBAAa,aAAa;IACxB,sFAAsF;IACtF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;IAC/D,sCAAsC;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgC;IACtD,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,YAAY,CAAS;IAE7B,2EAA2E;IAC3E,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI;IAIlD,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO;IAIxC,gGAAgG;IAChG,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,8GAA8G;IAC9G,YAAY,IAAI,OAAO;IAMvB;;;;;OAKG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAwBpD;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS;IAiBhD,iDAAiD;IACjD,OAAO,CAAC,IAAI;IAgBZ,0FAA0F;IAC1F,OAAO,CAAC,IAAI;IAgBZ,mEAAmE;IACnE,OAAO,CAAC,aAAa;CAQtB"}
+{"version":3,"file":"requestLedger.d.ts","sourceRoot":"","sources":["../../../src/mcp/requestLedger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C,gDAAgD;AAChD,MAAM,WAAW,aAAa;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,+FAA+F;IAC/F,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC/B;AAED,kEAAkE;AAClE,MAAM,WAAW,cAAc;IAC7B,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;IAChC,qFAAqF;IACrF,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAChC;AAED,2CAA2C;AAC3C,MAAM,WAAW,oBAAoB;IACnC,gDAAgD;IAChD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAED,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAIjC,kDAAkD;AAClD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,SAAS,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,qEAAqE;IACrE,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;CACnC;AAqBD,0GAA0G;AAC1G,qBAAa,aAAa;IAaZ,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZpC,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkC;IAC1D,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuC;IAChE,OAAO,CAAC,YAAY,CAAwB;IAC5C,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,YAAY,CAAS;gBAEA,OAAO,GAAE,oBAA8B;IAEpE;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,UAAU;IAUzC,yEAAyE;IACzE,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAQ9B,2FAA2F;IAC3F,KAAK,IAAI,IAAI;IAMb;;;OAGG;IACH,IAAI,eAAe,IAAI,OAAO,CAE7B;IAED,gGAAgG;IAChG,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED;;;OAGG;IACH,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,8GAA8G;IAC9G,YAAY,IAAI,OAAO;IAMvB;;;;;;;;;;OAUG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAyBpD,4FAA4F;IAC5F,OAAO,CAAC,aAAa;IAcrB,0FAA0F;IAC1F,OAAO,CAAC,OAAO;IAUf;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,OAAO,GAAG,cAAc,GAAG,SAAS;IAkBhD,iDAAiD;IACjD,OAAO,CAAC,IAAI;IA0CZ,4FAA4F;IAC5F,OAAO,CAAC,cAAc;IAQtB,iGAAiG;IACjG,OAAO,CAAC,aAAa;CAStB"}

package/dist/types/mcp/seriesEvidence.d.ts

@@ -28,17 +28,31 @@
  * timed out, or failed — was sent, and the server may have received it and run
  * it. Its row says so (`remote: 'unknown'`); nothing here records it as not run.
  *
- * WHEN IT FILES. When the series ends — and, for a cancellation, at the moment the
- * signal fires: a cancelled run stops waiting for its stage at once, so a record
- * filed when the series later unwinds would land after the run was saved. The
- * runner makes no record for an attempt it abandons at that moment or for a wait
- * it was cut out of, so those are written here: the cut attempt's row and
- * `during: 'request'`, or `during: 'wait'`. Anything the series reports after it
- * has filed is not part of the request's story any more and is ignored.
+ * THREE FACTS PER ATTEMPT, NONE READ FROM ANOTHER (`replay.ts`): the failure
+ * (footprintjs's category), what is known of its effect (`unknown` for every
+ * attempt sent that did not complete — a refusal included; `applied` when the
+ * call completed, never proof of a write; `none` only for what was never
+ * sent), and — on an attempt the series asked again after — what permitted it.
+ * Each row also says how long it took. The end says how many requests were
+ * sent and what is known of the whole series' effect; uncertainty survives
+ * (`SeriesKnowledge`).
+ *
+ * WHEN IT FILES. When the call settles — the series has ended by then, and the
+ * call's verdict is what says whether an answered attempt completed (a 200 can
+ * carry a tool error) — and, for a cancellation, at the moment the signal
+ * fires: a cancelled run stops waiting for its stage at once, so a record filed
+ * when the series later unwinds would land after the run was saved. The runner
+ * makes no record for an attempt it abandons at that moment or for a wait it
+ * was cut out of, so those are written here: the cut attempt's row and
+ * `during: 'request'`, or `during: 'wait'`. A series ended and waiting for its
+ * call files at once if the call is cancelled first, with what it knows.
+ * Anything the series reports after it has filed is not part of the request's
+ * story any more and is ignored.
  */
 import type { AttemptRecord } from 'footprintjs';
-import type { ToolRequestAttempt, ToolRequestReason } from '../events/payloads.js';
+import type { ToolRequestAttempt, ToolRequestEffect, ToolRequestPermission, ToolRequestReason } from '../events/payloads.js';
 import { type RequestEvidence, type RequestEvidenceSink } from '../tools/requestEvidence.js';
+import { type RequestReplay } from './replay.js';
 /** Where the request went, as a row may say it: the app's label for it, or its origin. */
 export type RequestWhere = Pick<RequestEvidence, 'endpoint' | 'origin'>;
 /** What the series saw of one attempt that its record does not hold. */
@@ -52,24 +66,49 @@ export interface AttemptSeen {
     };
 }
 /** Why the series' `retryOn` said no — the reasons the runner calls `declined`. */
-export type DeclineReason = Extract<ToolRequestReason, 'exhausted' | 'wait-limit' | 'no-time-left' | 'not-replayable' | 'not-retryable'>;
+export type DeclineReason = Extract<ToolRequestReason, 'exhausted' | 'wait-limit' | 'no-time-left' | 'not-replayable' | 'not-retryable' | 'not-permitted' | 'changes-without-key'>;
+/**
+ * What the series knows of one attempt beyond the runner's record (`replay.ts`):
+ * its effect — absent for an answered attempt, which the call's verdict decides
+ * when the record is filed — what permitted the next attempt, and how long it
+ * took.
+ */
+export interface AttemptFacts {
+    readonly effect?: ToolRequestEffect;
+    readonly permission?: ToolRequestPermission;
+    readonly durationMs: number;
+}
+/**
+ * Where the record waits for its call: the call's signal (it fires when the
+ * call settles or is cancelled), and the facts the call leaves there.
+ */
+export interface Settlement {
+    readonly signal: AbortSignal;
+    readonly replay: RequestReplay;
+}
 /** One request's evidence, collected as its series runs and filed once. */
 export declare class SeriesEvidence {
     private readonly sink;
     private readonly where;
+    private readonly settlement?;
     private readonly rows;
     private omitted;
     private last;
     private filed;
-    constructor(sink: RequestEvidenceSink, where: RequestWhere);
-    /** One attempt as the runner recorded it. */
-    attempt(record: AttemptRecord, seen: AttemptSeen | undefined, declined?: DeclineReason): void;
+    private waiting;
+    /** What is known of the series' effect, attempt by attempt — the answer's excepted. */
+    private readonly knowledge;
+    /** The answered attempt, while its effect waits for the call's verdict. */
+    private answer;
+    constructor(sink: RequestEvidenceSink, where: RequestWhere, settlement?: Settlement | undefined);
+    /** One attempt as the runner recorded it, with what the series knows of it. */
+    attempt(record: AttemptRecord, seen: AttemptSeen | undefined, declined?: DeclineReason, facts?: AttemptFacts): void;
     /**
      * The caller's cancellation cut attempt `n` in flight. It was sent — the
      * server may have it, and may have run it — so it is a row, `cut`, with the
      * remote outcome `unknown`; then the request's end says the same.
      */
-    cutInFlight(n: number): void;
+    cutInFlight(n: number, durationMs?: number): void;
     /**
      * The caller's cancellation landed with NO request in flight: between two —
      * `during: 'wait'`, the next request never sent — or before the first, when
@@ -82,7 +121,7 @@ export declare class SeriesEvidence {
      * refusal it will not ask again after. A refusal it MEANT to ask again after
      * is delivered when the deadline lands inside the wait: the runner's wait
      * ends early, the series stops, and the end says so (`no-time-left`, during
-     * the `wait`).
+     * the `wait`). Filed when the call has read it.
      */
     delivered(): void;
     /**
@@ -92,12 +131,31 @@ export declare class SeriesEvidence {
      * as one: a deadline that had passed before the first request (`timed-out`,
      * no `during`, nothing sent) or one a future runner reports from inside a wait
      * (`during: 'wait'`); anything else is filed as a failure the record cannot
-     * account for, so a request is never left unfiled.
+     * account for, so a request is never left unfiled. Filed when the call settles.
      */
     threw(outOfTime: boolean): void;
     private add;
+    /**
+     * File `end` once the call has settled — its verdict is what says whether an
+     * answered attempt completed — or at once, when the call is already settled
+     * or cancelled, or there is no call to wait for.
+     */
+    private fileWhenSettled;
     private file;
+    /**
+     * The rows, the answered one given its effect: `applied` when the call
+     * completed — the server answered it, and not with an error — else `unknown`
+     * (a 5xx, a JSON-RPC error, a tool error, a call cancelled before it read the
+     * answer). The answer's effect joins the series' knowledge here.
+     */
+    private settleAnswer;
 }
 /** One record as a row — see the module note for what a row may say. */
 export declare function rowOf(record: AttemptRecord, seen: AttemptSeen | undefined, declined?: DeclineReason): ToolRequestAttempt;
+/**
+ * `row` with what the series knows of its attempt beyond the record — its
+ * effect, what permitted the next attempt, how long it took. Without `facts`,
+ * the row as the record alone says it.
+ */
+export declare function withFacts(row: ToolRequestAttempt, facts: AttemptFacts | undefined): ToolRequestAttempt;
 //# sourceMappingURL=seriesEvidence.d.ts.map

package/dist/types/mcp/seriesEvidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seriesEvidence.d.ts","sourceRoot":"","sources":["../../../src/mcp/seriesEvidence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,KAAK,EACV,kBAAkB,EAGlB,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACzB,MAAM,6BAA6B,CAAC;AAErC,0FAA0F;AAC1F,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAC;AAExE,wEAAwE;AACxE,MAAM,WAAW,WAAW;IAC1B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc,CAAC;QAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnG;AAED,mFAAmF;AACnF,MAAM,MAAM,aAAa,GAAG,OAAO,CACjC,iBAAiB,EACjB,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,eAAe,CACjF,CAAC;AAOF,2EAA2E;AAC3E,qBAAa,cAAc;IAMb,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAuB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAL9E,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IACjD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,IAAI,CAAiC;IAC7C,OAAO,CAAC,KAAK,CAAS;gBAEO,IAAI,EAAE,mBAAmB,EAAmB,KAAK,EAAE,YAAY;IAE5F,6CAA6C;IAC7C,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,IAAI;IAK7F;;;;OAIG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAM5B;;;;;OAKG;IACH,SAAS,IAAI,IAAI;IAajB;;;;;;OAMG;IACH,SAAS,IAAI,IAAI;IAajB;;;;;;;;OAQG;IACH,KAAK,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;IAmB/B,OAAO,CAAC,GAAG;IAMX,OAAO,CAAC,IAAI;CASb;AAcD,wEAAwE;AACxE,wBAAgB,KAAK,CACnB,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,QAAQ,CAAC,EAAE,aAAa,GACvB,kBAAkB,CAqBpB"}
+{"version":3,"file":"seriesEvidence.d.ts","sourceRoot":"","sources":["../../../src/mcp/seriesEvidence.ts"],"names":[],"mappings":"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"}

package/dist/types/mcp/throttleRetry.d.ts

@@ -10,27 +10,33 @@
  * tool, or invents an answer. A designed, transient, self-clearing condition
  * was being turned into a wrong answer.
  *
- * ── What retrying a 429 assumes, and why the policy is 429-ONLY ─────────────
- * **Automatic 429 retries assume the server rejected the request before
- * executing it.** A rate limiter that refuses at the edge has not run the tool —
- * but HTTP 429 says only that the request was rate-limited (RFC 6585 §4), so the
- * saved response records the assumption's basis (the server's 429), not proof
- * that nothing ran. There is no side-effect guard here: a tool with side
- * effects is retried on 429 like any other today, and `retryOnThrottle: false`
- * turns that off per server. What is certain is the contrast with a 500 or a
- * timeout, where the call may have half-run and a retry could charge a card
- * twice.
+ * ── Who may ask again: the app, by declaration (`replay.ts`) ─────────────────
+ * HTTP 429 says only that the request was rate-limited (RFC 6585 §4). It does
+ * not prove the server ran nothing, and `Retry-After` says when to ask again,
+ * not that asking is safe. So permission to send a tool call again is the
+ * APP's, declared per (server, tool) when the client is built (`mcpClient({
+ * replay })`), and kept apart from what is known of an attempt's effect. Before
+ * every repeat the series asks `permit`; the record keeps its answer.
  *
- * That assumption is the whole license for this module, so the policy must
- * never widen. Only HTTP 429 retries here. Not 5xx, not network errors, not timeouts
- * — those belong to a caller who knows whether the specific tool is idempotent,
- * and this seam does not. A property test pins the boundary.
+ *   - `'compatibility'` (the default, kept in 12.0) keeps today's behaviour by
+ *     name: a 429 is repeated for every tool, ASSUMING the server refused it
+ *     before running it — and every such repeat records that assumption.
+ *   - `'app-authorized'` (opt-in, by name) repeats a 429 only for a tool the
+ *     app declared repeatable on it.
+ *   - A request that failed in transport without an answer (footprintjs's
+ *     `network`: a lost connection, a timeout below the series) is repeated
+ *     only when the app declared that for the tool. A 5xx is an answer, never
+ *     repeated. A cut or a deadline ends the series.
+ *   - Under both, a tool the app declares as making changes is never repeated
+ *     automatically unless the server is declared to deduplicate by a key the
+ *     call carries — footprintjs's side-effect guard, now wired here.
  *
  * The loop takes its question as a {@link RetryDecision}, so the one other
  * refusal a service documents as one to retry — AgentCore Runtime's "session
  * operation in progress" — reuses this loop rather than growing a second one.
- * That decision is applied only by that vendor's own transport; what
- * `mcpClient` and `retryingFetch` retry is still a 429 and nothing else.
+ * That decision is applied only by that vendor's own transport, and its rule
+ * carries the adapter's retry assumption (`RetryRule.assumes`) — a policy,
+ * never evidence: its attempts record effect `unknown`, as a 429's do.
  *
  * ── Why it lives at the fetch seam and not around `Tool.execute` ─────────────
  * Because `Retry-After` is only reachable here. The MCP SDK reads the response,
@@ -58,12 +64,17 @@
  * operation that succeeded: a 503 is delivered as the answer it was, never
  * retried — and written down as `answered` with its status, never success.
  * A response a rule's decision recognises is thrown as a refusal that names
- * its kind, and the policy's `retryOn` accepts those refusals and nothing
- * else — so a 5xx, a dropped connection or a timeout ends the series on the
- * attempt it happened in, as it always did. When the
- * series ends on a refusal (attempts spent, a ceiling reached, no time left),
- * the refusal's response is delivered as the server sent it: the caller sees
- * the 429, never an error of ours.
+ * its kind, and the policy's `retryOn` accepts those refusals — and a network
+ * failure the app declared for the tool — when the replay rule permits them,
+ * and nothing else: a 5xx ends the series on the attempt it happened in, as it
+ * always did. When the series ends on a refusal (attempts spent, a ceiling
+ * reached, no time left, no permission), the refusal's response is delivered
+ * as the server sent it: the caller sees the 429, never an error of ours. The
+ * call decides what that means for it (`callLifetime.ts`): under
+ * 'app-authorized', a call that genuinely lacked an answer somewhere and does
+ * not complete fails as "may have run". This series reports the HTTP half of
+ * that — an attempt that got no response at all, and the status it delivered;
+ * a received refusal is an answer, its effect still unknown.
  *
  * ── A fetch that already retries is JOINED, never wrapped ────────────────────
  * A transport whose own fetch runs a series (AgentCore Runtime's session-busy
@@ -90,6 +101,7 @@
  *
  * Pattern: Decorator over `fetch`. Role: Layer-3 tool transport.
  */
+import { type ReplayDeclaration } from './replay.js';
 import type { RequestLedger } from './requestLedger.js';
 /**
  * The fetch shape the MCP SDK's `fetch` hook uses — deliberately NARROWER
@@ -107,8 +119,12 @@ export type ThrottleFetch = (input: string | URL, init?: RequestInit) => Promise
 export type RetryKind = 'throttle' | 'session-busy';
 /** Reported to {@link ThrottleRetryOptions.onRetry} before each wait. */
 export interface ThrottleRetryInfo {
-    /** Which refusal this retry answers. */
-    readonly kind: RetryKind;
+    /**
+     * Which refusal this retry answers — or `'network'`, a tool call the app
+     * declared repeatable after a request that failed without an answer
+     * (`McpClientOptions.replay`). It is reported to the series' first rule.
+     */
+    readonly kind: RetryKind | 'network';
     /** The attempt about to START. `2` is the first retry. */
     readonly attempt: number;
     /** Ceiling in force for this refusal, including the first attempt. */
@@ -240,16 +256,18 @@ export interface RetryVerdict {
  * The one question the loop asks of each response.
  *
  * ── The license every decision must hold ─────────────────────────────────────
- * A decision may answer "again" ONLY for a response the library treats as a
- * refusal made before anything ran — the assumption a 429 retry rests on (see
- * the module note: the 429 is its basis, not proof). A response that could be
- * the record of half-done work is never one.
- * The library holds exactly two such decisions: {@link throttled} below, and
- * AgentCore Runtime's documented "session operation in progress" refusal,
- * which lives with that vendor's adapter (`adapters/mcp/agentcoreRuntime/`).
- * Each stays ONE small function, so a retry has exactly one place it is
- * decided — and each attempt is written down as one footprintjs attempt
- * record.
+ * A decision RECOGNISES a refusal; whether the request is sent again is the
+ * replay rule's (`replay.ts`), never the decision's. It may recognise only a
+ * response that is a refusal — never one that could be the record of
+ * half-done work. The library holds exactly two: {@link throttled} below, a
+ * 429, and AgentCore Runtime's "session operation in progress" refusal, which
+ * lives with that vendor's adapter (`adapters/mcp/agentcoreRuntime/`) and whose
+ * rule carries the adapter's retry assumption (`RetryRule.assumes`). Either
+ * one's effect stays unknown: a 429 says the request was rate-limited, and the
+ * busy body is matched by its code and words, which a server behind the
+ * runtime can send after it ran the call. Each stays ONE small function, so a
+ * refusal has exactly one place it is recognised — and each attempt is written
+ * down as one footprintjs attempt record.
  */
 export type RetryDecision = (response: Response, 
 /**
@@ -297,6 +315,13 @@ export interface RetryRule {
     /** The caller's own name for the endpoint, reported as `endpoint`. */
     readonly endpointLabel?: string;
     readonly onRetry?: (info: ThrottleRetryInfo) => void;
+    /**
+     * Set only by an adapter that retries this refusal as its own policy
+     * (`sessionBusy.ts`): what it assumes in doing so. The assumption is recorded
+     * beside each repeat (`permission: { by: 'adapter', assumes }`) — never as
+     * evidence: the attempt's effect stays `unknown`.
+     */
+    readonly assumes?: 'refused-before-execution';
 }
 /**
  * @internal A rule from a caller's options — `undefined` when retry is off
@@ -307,7 +332,7 @@ export interface RetryRule {
  * @throws TypeError, when the rule is BUILT, for a value the schedule cannot
  *   mean — named by option, never echoing a value that is not a number.
  */
-export declare function retryRule(kind: RetryKind, decide: RetryDecision, config: RetryOnThrottle | undefined, defaults: RetryDefaults, where: string): RetryRule | undefined;
+export declare function retryRule(kind: RetryKind, decide: RetryDecision, config: RetryOnThrottle | undefined, defaults: RetryDefaults, where: string, assumes?: 'refused-before-execution'): RetryRule | undefined;
 /**
  * Wrap a `fetch` so HTTP 429 responses are retried, honouring `Retry-After`.
  *
@@ -346,19 +371,37 @@ export declare function retryRule(kind: RetryKind, decide: RetryDecision, config
  */
 export declare function retryingFetch(inner: ThrottleFetch | undefined, config: RetryOnThrottle | undefined): ThrottleFetch | undefined;
 /**
- * @internal What one call's series is built from: the rules it asks, in order,
- * and the connection's ledger — which tool call each request belongs to, so the
- * series can file its attempts into that call's run (`requestLedger.ts`).
+ * @internal The series for a transport whose 429 rule is off (`retryOnThrottle:
+ * false`) while the app's replay declaration still needs one (`replay.ts` ·
+ * `needsSeries`): a tool declared repeatable on `'network'`, or the
+ * `'app-authorized'` policy, whose record and "may have run" rest on the series.
+ * `retryOnThrottle: false` turns off the 429 rule and nothing else, so its one
+ * rule is that rule switched off: it recognises no response and holds the
+ * call's budget (`retryOnThrottle`'s defaults). A transport fetch that already
+ * runs a series is joined, as `retryingFetch` joins it.
+ */
+export declare function seriesWithoutThrottle(inner: ThrottleFetch | undefined): ThrottleFetch;
+/**
+ * @internal What one call's series is built from: the rules it asks, in order;
+ * the connection's ledger — which tool call each request belongs to, so the
+ * series can file its attempts into that call's run (`requestLedger.ts`); and
+ * the app's replay declaration — who may send a tool call again (`replay.ts`).
+ * No declaration is the compatibility policy, naming no tool.
  */
 export interface SeriesSpec {
     readonly rules: readonly RetryRule[];
     readonly ledger?: RequestLedger;
+    readonly replay?: ReplayDeclaration;
 }
-/** @internal What a joinable fetch's series can be rebuilt with: one more rule, or a ledger. */
+/**
+ * @internal What a joinable fetch's series can be rebuilt with: one more rule,
+ * or a ledger and the replay declaration (they arrive together, from `mcpClient`).
+ */
 export type SeriesJoin = {
     readonly rule: RetryRule;
 } | {
     readonly ledger: RequestLedger;
+    readonly replay?: ReplayDeclaration;
 };
 /** @internal `spec` with `join` in it. */
 export declare function joinedSpec(spec: SeriesSpec, join: SeriesJoin): SeriesSpec;
@@ -372,10 +415,11 @@ export declare function joinedSpec(spec: SeriesSpec, join: SeriesJoin): SeriesSp
 export declare function joinableRetry(fetch: ThrottleFetch, rebuild: (join: SeriesJoin) => ThrottleFetch): ThrottleFetch;
 /**
  * @internal `fetch` rebuilt so its series files each request's attempts through
- * `ledger` — or `undefined` when `fetch` runs no series (retry off), so there
- * is nothing to file and the caller keeps `fetch` as it is.
+ * `ledger`, and asks `replay` before sending a tool call again — or `undefined`
+ * when `fetch` runs no series (retry off), so there is nothing to file and the
+ * caller keeps `fetch` as it is.
  */
-export declare function ledgeredFetch(fetch: ThrottleFetch, ledger: RequestLedger): ThrottleFetch | undefined;
+export declare function ledgeredFetch(fetch: ThrottleFetch, ledger: RequestLedger, replay?: ReplayDeclaration): ThrottleFetch | undefined;
 /**
  * @internal The one series per call over `inner`, asking `spec.rules` in order —
  * `inner` itself when there are none. The first rule holds the call's budget;

package/dist/types/mcp/throttleRetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"throttleRetry.d.ts","sourceRoot":"","sources":["../../../src/mcp/throttleRetry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"throttleRetry.d.ts","sourceRoot":"","sources":["../../../src/mcp/throttleRetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsGG;AAaH,OAAO,EAOL,KAAK,iBAAiB,EAEvB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,aAAa,EAAiB,MAAM,oBAAoB,CAAC;AAUvE;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAI3F;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;AAEpD,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IACrC,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;4DACwD;IACxD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,gFAAgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC5C;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACtD;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,oBAAoB,CAAC;AAI7D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,QAAQ,EAAE,QAAQ;AAClB;;;;GAIG;AACH,MAAM,CAAC,EAAE,WAAW,KACjB,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;AAElE,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,SAAS,CAItE;AAID;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,aAQpC,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,6FAA6F;IAC7F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;IAC3C,sEAAsE;IACtE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACrD;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,0BAA0B,CAAC;CAC/C;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,eAAe,GAAG,SAAS,EACnC,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,0BAA0B,GACnC,SAAS,GAAG,SAAS,CAsBvB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,GAAG,SAAS,EAChC,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC,aAAa,GAAG,SAAS,CAO3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,aAAa,CAYrF;AAKD;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAClB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,GAC5B;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAE5E,0CAA0C;AAC1C,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAOzE;AASD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,aAAa,GAC3C,aAAa,CAGf;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,EACpB,MAAM,EAAE,aAAa,EACrB,MAAM,CAAC,EAAE,iBAAiB,GACzB,aAAa,GAAG,SAAS,CAE3B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,GAAG,aAAa,CAStF;AAgfD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAOpF"}

package/dist/types/mcp/toolResult.d.ts

@@ -3,6 +3,12 @@ import type { McpCallToolResult, McpClientOptions } from './types.js';
 type ResultMode = NonNullable<McpClientOptions['resultMode']>;
 /** Validate before opening a transport; a misspelled opt-in must not disappear. */
 export declare function resultModeOf(value: unknown, name: string): ResultMode;
+/**
+ * Whether a `tools/call` answer is the tool's own error (`isError: true`, an
+ * own data property). Read once, never throwing: anything it cannot read is
+ * not a tool error — the decoder refuses it on its own.
+ */
+export declare function isToolError(result: unknown): boolean;
 /** Internal shared decoder for the real connection and curated mock. */
 export declare function readToolResult(result: McpCallToolResult, toolName: string, serverName: string, mode?: ResultMode): unknown;
 export {};