@cyanheads/mcp-ts-core 0.13.2 → 0.13.4

package/dist/utils/network/pacer.d.ts

@@ -0,0 +1,117 @@
+/**
+ * One sliding start-rate window, e.g. `{ requests: 5, perMs: 60_000 }` for five
+ * requests a minute. Several may be declared together (per-minute and per-hour);
+ * a start needs every one of them to allow it.
+ */
+export interface PacerLimit {
+    /** Width of the sliding window in milliseconds. */
+    perMs: number;
+    /** Starts permitted within the window. */
+    requests: number;
+}
+/** Back-off applied to the shared gate when the upstream answers with a rate limit. */
+export interface PacerCooldownOptions {
+    /** First cooldown, doubled on each consecutive rate limit. */
+    baseMs: number;
+    /**
+     * Ceiling for both the doubling and an honored `Retry-After`, so a pathological
+     * upstream value cannot park the queue.
+     */
+    maxMs: number;
+}
+/** Configuration for {@link createPacer}. */
+export interface PacerOptions {
+    /** Shared 429 gate. Omitted, an upstream rate limit paces nothing by itself. */
+    cooldown?: PacerCooldownOptions;
+    /** Sliding start-rate windows. Every entry must allow a start. */
+    limits?: PacerLimit[];
+    /** In-flight ceiling. Unset, only the windows and the start gap bind. */
+    maxConcurrent?: number;
+    /**
+     * Absolute backpressure on queue length, for callers that pass no
+     * `maxWaitMs`. An arrival past it is shed at once.
+     */
+    maxQueueDepth?: number;
+    /**
+     * Minimum spacing between consecutive starts. Not expressible through
+     * {@link PacerOptions.limits} once a window admits more than one request:
+     * `{ requests: 10, perMs: 1000 }` permits ten starts in the same millisecond,
+     * which is exactly the burst the SEC and NCBI clients space out by hand.
+     */
+    minStartGapMs?: number;
+    /**
+     * Author-set label for telemetry attribution. Bounded and never
+     * caller-supplied — a metric attribute set lives until process restart.
+     */
+    name: string;
+}
+/** Per-call options for {@link Pacer.run}. */
+export interface PacerRunOptions {
+    /**
+     * Ceiling on queue time — not on the task, which bounds itself. Enqueue
+     * rejects when the projected wait already exceeds it, and a still-queued entry
+     * rejects when it elapses.
+     */
+    maxWaitMs?: number;
+    /**
+     * Caller cancellation. While queued, an abort removes the entry and rejects
+     * with `signal.reason`; once dispatched the signal is the task's own to honor,
+     * and it is what {@link Pacer.run} hands the task.
+     */
+    signal?: AbortSignal;
+}
+/** A queue in front of one upstream. Process-local; timers and `AbortSignal` only. */
+export interface Pacer extends Disposable {
+    /**
+     * Clears the dispatch timer and rejects every queued waiter with
+     * `RequestCancelled`. In-flight tasks are left to finish. Idempotent; wire it
+     * through `createApp({ teardown })`.
+     */
+    dispose(): void;
+    /**
+     * Queues `task` and runs it once a slot opens, handing it the caller's signal.
+     *
+     * @throws {McpError} `RateLimited` with `data.reason: 'pacer_shed'` when no
+     *   slot fits the caller's wait budget or the queue is at capacity.
+     */
+    run<T>(task: (signal: AbortSignal) => Promise<T>, options?: PacerRunOptions): Promise<T>;
+}
+/**
+ * Creates a FIFO pacer for one upstream.
+ *
+ * A slot is granted when every {@link PacerOptions.limits} window,
+ * {@link PacerOptions.minStartGapMs}, {@link PacerOptions.maxConcurrent}, and the
+ * cooldown gate allow it. Each window is a sliding view over recorded *start*
+ * times, so a slow response never widens the rate the upstream sees.
+ *
+ * **Composition with `withRetry`.** Retry outside, pacer inside —
+ * `withRetry(({ signal }) => pacer.run(fn, { signal }), { signal, deadlineMs })` —
+ * so each attempt re-queues and is re-paced. The cooldown gate is an absolute
+ * instant rather than a duration counted from dequeue, so `withRetry`'s
+ * `Retry-After` sleep and the gate overlap in wall-clock instead of summing: the
+ * caller waits the window the upstream named once, not twice. Pass the retry
+ * deadline's signal into `run` and the queue wait is charged to the same budget.
+ *
+ * **Runtime.** Process-local, so on Workers the limits bind per isolate, OTel is
+ * off and the metrics are inert, and `createWorkerHandler` accepts no `teardown`
+ * to call {@link Pacer.dispose} from.
+ *
+ * @example
+ * ```ts
+ * const pacer = createPacer({
+ *   name: 'courtlistener',
+ *   limits: [{ requests: 5, perMs: 60_000 }, { requests: 50, perMs: 3_600_000 }],
+ *   minStartGapMs: 100,
+ *   maxConcurrent: 2,
+ *   maxQueueDepth: 100,
+ *   cooldown: { baseMs: 5_000, maxMs: 60_000 },
+ * });
+ *
+ * const res = await pacer.run(
+ *   (signal) => fetchWithTimeout(url, 30_000, ctx, { signal }),
+ *   { signal: ctx.signal, maxWaitMs: 45_000 },
+ * );
+ * ```
+ */
+export declare function createPacer(options: PacerOptions): Pacer;
+//# sourceMappingURL=pacer.d.ts.map

package/dist/utils/network/pacer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pacer.d.ts","sourceRoot":"","sources":["../../../src/utils/network/pacer.ts"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,uFAAuF;AACvF,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,6CAA6C;AAC7C,MAAM,WAAW,YAAY;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,kEAAkE;IAClE,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;IACtB,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;CACd;AAED,8CAA8C;AAC9C,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,sFAAsF;AACtF,MAAM,WAAW,KAAM,SAAQ,UAAU;IACvC;;;;OAIG;IACH,OAAO,IAAI,IAAI,CAAC;IAChB;;;;;OAKG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC1F;AAgDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,KAAK,CAmQxD"}

package/dist/utils/network/pacer.js

@@ -0,0 +1,304 @@
+/**
+ * @fileoverview Outbound request pacer — a FIFO queue in front of a rate-limited
+ * upstream. Holds work back until every configured window, the minimum start gap,
+ * and the concurrency cap allow it; sheds callers whose wait budget cannot be met;
+ * and closes a shared cooldown gate when the upstream answers 429.
+ *
+ * The inbound `RateLimiter` (`utils/security`) is the mirror image: it is keyed
+ * per caller and rejects synchronously, so it cannot queue work against an
+ * upstream budget.
+ * @module src/utils/network/pacer
+ */
+import { JsonRpcErrorCode, McpError, rateLimited, requestCancelled, } from '../../types-global/errors.js';
+import { parseRetryAfterMs } from './retry.js';
+import { ATTR_MCP_PACER_NAME } from '../telemetry/attributes.js';
+import { createCounter, createHistogram, createUpDownCounter } from '../telemetry/metrics.js';
+let instruments;
+/**
+ * The four pacer instruments, shared across every pacer in the process and told
+ * apart by `mcp.pacer.name`. Lazy: a server that never queues emits no series.
+ */
+function getPacerMetrics() {
+    instruments ??= {
+        cooldowns: createCounter('mcp.pacer.cooldowns', 'Cooldown gates closed by an upstream rate limit', '{cooldowns}'),
+        queueDepth: createUpDownCounter('mcp.pacer.queue_depth', 'Requests waiting for a pacer slot', '{requests}'),
+        sheds: createCounter('mcp.pacer.sheds', 'Requests shed before dispatch because no slot fit the wait budget', '{requests}'),
+        wait: createHistogram('mcp.pacer.wait', 'Time a request spent waiting for a pacer slot', 'ms'),
+    };
+    return instruments;
+}
+/**
+ * Creates a FIFO pacer for one upstream.
+ *
+ * A slot is granted when every {@link PacerOptions.limits} window,
+ * {@link PacerOptions.minStartGapMs}, {@link PacerOptions.maxConcurrent}, and the
+ * cooldown gate allow it. Each window is a sliding view over recorded *start*
+ * times, so a slow response never widens the rate the upstream sees.
+ *
+ * **Composition with `withRetry`.** Retry outside, pacer inside —
+ * `withRetry(({ signal }) => pacer.run(fn, { signal }), { signal, deadlineMs })` —
+ * so each attempt re-queues and is re-paced. The cooldown gate is an absolute
+ * instant rather than a duration counted from dequeue, so `withRetry`'s
+ * `Retry-After` sleep and the gate overlap in wall-clock instead of summing: the
+ * caller waits the window the upstream named once, not twice. Pass the retry
+ * deadline's signal into `run` and the queue wait is charged to the same budget.
+ *
+ * **Runtime.** Process-local, so on Workers the limits bind per isolate, OTel is
+ * off and the metrics are inert, and `createWorkerHandler` accepts no `teardown`
+ * to call {@link Pacer.dispose} from.
+ *
+ * @example
+ * ```ts
+ * const pacer = createPacer({
+ *   name: 'courtlistener',
+ *   limits: [{ requests: 5, perMs: 60_000 }, { requests: 50, perMs: 3_600_000 }],
+ *   minStartGapMs: 100,
+ *   maxConcurrent: 2,
+ *   maxQueueDepth: 100,
+ *   cooldown: { baseMs: 5_000, maxMs: 60_000 },
+ * });
+ *
+ * const res = await pacer.run(
+ *   (signal) => fetchWithTimeout(url, 30_000, ctx, { signal }),
+ *   { signal: ctx.signal, maxWaitMs: 45_000 },
+ * );
+ * ```
+ */
+export function createPacer(options) {
+    const { cooldown, limits = [], maxConcurrent, maxQueueDepth, minStartGapMs = 0, name } = options;
+    const attributes = { [ATTR_MCP_PACER_NAME]: name };
+    /** Recorded start instants, ascending. Pruned to the longest constraint. */
+    const starts = [];
+    const retentionMs = Math.max(minStartGapMs, ...limits.map((limit) => limit.perMs), 0);
+    const queue = [];
+    let active = 0;
+    let consecutiveRateLimits = 0;
+    /** Absolute instant the shared gate reopens. */
+    let gateOpensAt = 0;
+    let dispatchTimer;
+    let disposed = false;
+    /**
+     * The earliest instant a start is permitted given `history`, evaluated at
+     * `at`. Exact over the cooldown gate, the start gap, and every window —
+     * concurrency is deliberately not modelled here, since a slot frees on an
+     * unknowable completion.
+     */
+    function earliestStart(history, at) {
+        let earliest = gateOpensAt;
+        const last = history[history.length - 1];
+        if (last !== undefined && minStartGapMs > 0) {
+            earliest = Math.max(earliest, last + minStartGapMs);
+        }
+        for (const { requests, perMs } of limits) {
+            if (requests <= 0)
+                continue;
+            let seen = 0;
+            for (let i = history.length - 1; i >= 0; i--) {
+                const start = history[i];
+                // A start exactly `perMs` old has already left the window.
+                if (start <= at - perMs)
+                    break;
+                seen++;
+                if (seen === requests) {
+                    earliest = Math.max(earliest, start + perMs);
+                    break;
+                }
+            }
+        }
+        return earliest;
+    }
+    /**
+     * When an arrival joining behind `ahead` waiters could start, by replaying the
+     * windows forward. Exact while only the windows and the gap bind; a lower
+     * bound once `maxConcurrent` does — which is what keeps a shed from ever being
+     * a false one.
+     */
+    function projectedStart(now, ahead) {
+        const simulated = starts.slice();
+        let at = now;
+        for (let i = 0; i <= ahead; i++) {
+            at = Math.max(at, earliestStart(simulated, at));
+            simulated.push(at);
+        }
+        return at;
+    }
+    /** Seconds until a slot opens, for the shed error's `retryAfter`. */
+    function secondsUntilSlot(now, ahead) {
+        return Math.ceil(Math.max(0, projectedStart(now, ahead) - now) / 1000);
+    }
+    /**
+     * The shed error. `rateLimited` with no `retryable: false`: to the calling
+     * agent this is an ordinary rate limit — wait `retryAfter`, call again — and
+     * that flag would tell them the opposite. `withRetry`'s default predicate
+     * reads `reason` instead, so an enclosing retry fails fast rather than
+     * sleeping past the deadline the shed exists to enforce.
+     */
+    function shed(retryAfter, queueDepth) {
+        getPacerMetrics().sheds.add(1, attributes);
+        return rateLimited(`No ${name} request slot available within the caller's wait budget.`, {
+            reason: 'pacer_shed',
+            retryAfter,
+            queueDepth,
+        });
+    }
+    /**
+     * Releases an entry that has left the queue: clears its shed timer and abort
+     * listener, and settles the depth gauge. Leaving the line and the gauge are
+     * the same event, so every exit — dequeued, removed, disposed — goes through
+     * here.
+     */
+    function detach(entry) {
+        if (entry.shedTimer !== undefined) {
+            clearTimeout(entry.shedTimer);
+            entry.shedTimer = undefined;
+        }
+        if (entry.onAbort && entry.signal) {
+            entry.signal.removeEventListener('abort', entry.onAbort);
+            entry.onAbort = undefined;
+        }
+        getPacerMetrics().queueDepth.add(-1, attributes);
+    }
+    /** Removes a waiter and settles the depth gauge. `false` if it already left. */
+    function remove(entry) {
+        const index = queue.indexOf(entry);
+        if (index === -1)
+            return false;
+        queue.splice(index, 1);
+        detach(entry);
+        return true;
+    }
+    function clearDispatchTimer() {
+        if (dispatchTimer === undefined)
+            return;
+        clearTimeout(dispatchTimer);
+        dispatchTimer = undefined;
+    }
+    /**
+     * Drains as much of the queue as the constraints allow, then either arms the
+     * dispatch timer for the next opening or leaves no timer at all. FIFO: only
+     * the head is ever considered, so a cheap arrival never overtakes.
+     */
+    function pump() {
+        clearDispatchTimer();
+        while (queue.length > 0) {
+            if (maxConcurrent !== undefined && active >= maxConcurrent)
+                return;
+            const now = Date.now();
+            const earliest = earliestStart(starts, now);
+            if (earliest > now) {
+                dispatchTimer = setTimeout(() => {
+                    dispatchTimer = undefined;
+                    pump();
+                }, earliest - now);
+                dispatchTimer.unref?.();
+                return;
+            }
+            const entry = queue.shift();
+            if (!entry)
+                return;
+            detach(entry);
+            starts.push(now);
+            while (starts.length > 0 && starts[0] <= now - retentionMs)
+                starts.shift();
+            entry.dispatch(now);
+        }
+    }
+    /**
+     * Closes the shared gate on an upstream rate limit:
+     * `min(max(baseMs · 2^(consecutive−1), retryAfter), maxMs)`, as an absolute
+     * instant. Any other error leaves it open; the first success resets the count.
+     */
+    function noteRateLimit(error) {
+        if (!cooldown)
+            return;
+        if (!(error instanceof McpError) || error.code !== JsonRpcErrorCode.RateLimited)
+            return;
+        consecutiveRateLimits++;
+        const doubled = cooldown.baseMs * 2 ** (consecutiveRateLimits - 1);
+        // An absent or unparseable hint contributes nothing, leaving the doubling.
+        const honored = parseRetryAfterMs(error) ?? 0;
+        const waitMs = Math.min(Math.max(doubled, honored), cooldown.maxMs);
+        gateOpensAt = Math.max(gateOpensAt, Date.now() + waitMs);
+        getPacerMetrics().cooldowns.add(1, attributes);
+    }
+    function run(task, runOptions = {}) {
+        const { maxWaitMs, signal } = runOptions;
+        if (disposed) {
+            return Promise.reject(requestCancelled(`The ${name} pacer has been disposed.`));
+        }
+        if (signal?.aborted)
+            return Promise.reject(signal.reason);
+        const now = Date.now();
+        const ahead = queue.length;
+        // Absolute backpressure first, so it rejects without arming a timer.
+        if (maxQueueDepth !== undefined && ahead >= maxQueueDepth) {
+            return Promise.reject(shed(secondsUntilSlot(now, ahead), ahead));
+        }
+        if (maxWaitMs !== undefined && projectedStart(now, ahead) - now > maxWaitMs) {
+            return Promise.reject(shed(secondsUntilSlot(now, ahead), ahead));
+        }
+        return new Promise((resolve, reject) => {
+            const entry = {
+                enqueuedAt: now,
+                reject,
+                signal,
+                dispatch: (startedAt) => {
+                    active++;
+                    getPacerMetrics().wait.record(startedAt - entry.enqueuedAt, attributes);
+                    // Called inside an async wrapper so a task that throws before returning
+                    // a promise rejects its own caller instead of escaping into `pump()`.
+                    void (async () => task(signal ?? new AbortController().signal))().then((value) => {
+                        consecutiveRateLimits = 0;
+                        resolve(value);
+                        active--;
+                        pump();
+                    }, (error) => {
+                        noteRateLimit(error);
+                        reject(error);
+                        active--;
+                        pump();
+                    });
+                },
+            };
+            if (maxWaitMs !== undefined) {
+                entry.shedTimer = setTimeout(() => {
+                    entry.shedTimer = undefined;
+                    if (!remove(entry))
+                        return;
+                    reject(shed(secondsUntilSlot(Date.now(), 0), queue.length));
+                    // The shed entry is gone; whoever is behind it should not wait on it.
+                    pump();
+                }, maxWaitMs);
+                entry.shedTimer.unref?.();
+            }
+            if (signal) {
+                entry.onAbort = () => {
+                    if (!remove(entry))
+                        return;
+                    reject(signal.reason);
+                    pump();
+                };
+                signal.addEventListener('abort', entry.onAbort, { once: true });
+            }
+            queue.push(entry);
+            getPacerMetrics().queueDepth.add(1, attributes);
+            pump();
+        });
+    }
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        clearDispatchTimer();
+        for (const entry of queue.splice(0, queue.length)) {
+            detach(entry);
+            entry.reject(requestCancelled(`The ${name} pacer has been disposed.`));
+        }
+    }
+    return {
+        dispose,
+        run,
+        [Symbol.dispose]: dispose,
+    };
+}
+//# sourceMappingURL=pacer.js.map

package/dist/utils/network/pacer.js.map

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

package/dist/utils/network/retry.d.ts

@@ -1,4 +1,25 @@
 import type { RequestContext } from '../internal/requestContext.js';
+/**
+ * The per-attempt handle {@link withRetry} passes to its operation.
+ *
+ * Both fields describe the *total* budget, not this attempt's: they exist so an
+ * attempt can bound its own I/O against what is left, which is what keeps the
+ * deadline from overshooting by one in-flight request.
+ */
+export interface RetryAttempt {
+    /**
+     * Milliseconds left on {@link RetryOptions.deadlineMs} as this attempt starts.
+     * Never negative, and `Number.POSITIVE_INFINITY` when no deadline is set — so
+     * `Math.min(perAttemptMs, remainingMs)` is correct either way.
+     */
+    readonly remainingMs: number;
+    /**
+     * `AbortSignal.any` over the deadline clock and {@link RetryOptions.signal}.
+     * Thread it into the attempt's fetch: a deadline that only fires *between*
+     * attempts cannot stop one already in flight.
+     */
+    readonly signal: AbortSignal;
+}
 /** Configuration for {@link withRetry}. */
 export interface RetryOptions {
     /**
@@ -18,6 +39,24 @@ export interface RetryOptions {
      * `state`, protocol method handles) before pino sees them.
      */
     context?: RequestContext;
+    /**
+     * Total wall-clock budget in milliseconds covering every attempt, every
+     * backoff, and any honored `Retry-After` — the bound `maxRetries` and a
+     * per-attempt timeout cannot express between them. Four 30s attempts plus
+     * backoff outlast a client's 60s request timeout, so the caller gets a
+     * transport timeout instead of this server's classified error.
+     *
+     * The clock is an `AbortController` + `setTimeout`, composed into
+     * {@link RetryAttempt.signal}; pass that signal into the attempt's I/O or the
+     * deadline overshoots by one in-flight request. Expiry rejects with a
+     * `Timeout` `McpError` carrying
+     * `data: { reason: 'retry_deadline_exceeded', deadlineMs, elapsedMs, retryAttempts }`
+     * and the last attempt's error as `cause`.
+     *
+     * Unset (the default) leaves attempt counts, delays, logging, and the
+     * exhausted-error shape exactly as they are.
+     */
+    deadlineMs?: number;
     /**
      * Custom predicate to determine if an error is transient and should be
      * retried. When provided, this **replaces** the default predicate entirely
@@ -56,10 +95,63 @@ export interface RetryOptions {
     operation?: string;
     /**
      * Optional AbortSignal. When aborted, the retry loop exits immediately
-     * without further attempts.
+     * without further attempts, rethrowing unchanged — this is the caller-abort
+     * passthrough and it outranks a {@link deadlineMs} expiry, so a cancelled
+     * request is never relabelled as one that ran out of budget. Also composed
+     * into {@link RetryAttempt.signal}.
      */
     signal?: AbortSignal;
 }
+/**
+ * Parses an upstream `Retry-After` hint into milliseconds. The two HTTP helpers
+ * (`fetchWithTimeout`, `httpErrorFromResponse`) capture the raw header value into
+ * `error.data.retryAfter`; this reads it back so the retry delay can honor the
+ * wait the upstream explicitly asked for instead of blind exponential backoff.
+ *
+ * Handles both RFC 9110 §10.2.3 forms:
+ * - **delta-seconds** — a bare non-negative integer (`"30"` → `30_000`).
+ * - **HTTP-date** — an absolute instant, converted to a wait from now and
+ *   clamped at `0` (a past date means "retry now").
+ *
+ * A numeric `data.retryAfter` is also accepted and interpreted as delta-seconds,
+ * matching the header's units. Returns `undefined` when the error carries no
+ * parseable hint, so callers fall back to exponential backoff.
+ *
+ * Module-level, not public: the pacer's cooldown gate reads the same hint off
+ * the same errors, and a second copy of the RFC 9110 forms would drift.
+ */
+export declare function parseRetryAfterMs(error: unknown): number | undefined;
+/**
+ * Default transient check: `McpError` with a transient code, or any non-McpError
+ * (network failures, unexpected throws) which are assumed transient.
+ *
+ * **Per-error opt-out.** When a thrown `McpError` carries `data.retryable === false`,
+ * the error is treated as non-transient and fails fast — even if its code is in
+ * `TRANSIENT_CODES`. This is the in-band escape hatch for deterministic upstream
+ * failures (e.g. a query too expensive to ever succeed surfaced as HTTP 200 +
+ * error body) that arrive with a transient code but should never be retried.
+ *
+ * Absent the flag (or when it is `true`), behavior is unchanged — code-based
+ * classification applies. Non-`McpError` throws (raw network errors, unexpected
+ * throws) are always assumed transient regardless of the flag.
+ *
+ * **Composing rather than replacing.** {@link RetryOptions.isTransient} replaces
+ * this predicate outright, so a caller that wants "the framework default, except
+ * this one error" composes off this export instead of mirroring the transient
+ * code set — a copy drifts silently when the framework's classification changes:
+ *
+ * ```ts
+ * withRetry(fn, {
+ *   isTransient: (error) =>
+ *     !(error instanceof McpError && error.data?.reason === 'budget_exhausted') &&
+ *     defaultIsTransient(error),
+ * });
+ * ```
+ *
+ * The inverse — treating one more shape as transient — composes the same way:
+ * `defaultIsTransient(error) || isMyRetryableShape(error)`.
+ */
+export declare function defaultIsTransient(error: unknown): boolean;
 /**
  * Executes `fn` with retry logic and exponential backoff.
  *
@@ -82,11 +174,24 @@ export interface RetryOptions {
  * fast: a window that won't clear within the retry budget is surfaced to the
  * caller immediately rather than burning attempts that cannot succeed.
  *
+ * **Total deadline.** `deadlineMs` bounds the whole ladder — every attempt, every
+ * backoff, every honored `Retry-After` — where `maxRetries` and a per-attempt
+ * timeout together cannot. `fn` receives `{ signal, remainingMs }`; thread
+ * `signal` into the attempt's I/O, or an expiry that fires mid-attempt overshoots
+ * by one in-flight request. A backoff that would consume the remaining budget
+ * fails fast rather than sleeping into a certain timeout, and expiry rejects with
+ * a single `Timeout` error carrying `data.reason: 'retry_deadline_exceeded'` —
+ * the `RequestCancelled` that an external-signal abort produces inside
+ * `fetchWithTimeout` normalizes to it. A caller abort on `options.signal` keeps
+ * precedence and is never relabelled. Without `deadlineMs`, behavior is
+ * unchanged.
+ *
  * When retries exhaust, the final error is enriched with attempt count in both
  * the message and structured data, so callers know retries were already attempted.
  *
  * @typeParam T - Return type of the operation.
- * @param fn - The async operation to execute with retries.
+ * @param fn - The async operation to execute with retries. Receives a
+ *   {@link RetryAttempt}; a zero-argument operation is assignable unchanged.
  * @param options - Retry configuration. All fields optional with sensible defaults.
  * @returns The result of `fn` on success.
  * @throws The enriched final error when all attempts are exhausted, or the original
@@ -105,6 +210,17 @@ export interface RetryOptions {
  *   );
  * }
  * ```
+ *
+ * @example Bounded by one wall-clock budget
+ * ```ts
+ * const data = await withRetry(
+ *   async ({ signal, remainingMs }) => {
+ *     const res = await fetchWithTimeout(url, Math.min(30_000, remainingMs), ctx, { signal });
+ *     return parse(await res.text());
+ *   },
+ *   { operation: 'search', context: ctx, signal: ctx.signal, deadlineMs: 50_000 },
+ * );
+ * ```
  */
-export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+export declare function withRetry<T>(fn: (attempt: RetryAttempt) => Promise<T>, options?: RetryOptions): Promise<T>;
 //# sourceMappingURL=retry.d.ts.map

package/dist/utils/network/retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/utils/network/retry.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAYzE,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,cAAc,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAE1C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AA8GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,CAAC,CAAC,CAgE/F"}
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/utils/network/retry.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAYzE;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B;AAED,2CAA2C;AAC3C,MAAM,WAAW,YAAY;IAC3B;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,cAAc,CAAC;IAEzB;;;;;;;;;;;;;;;;OAgBG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAE1C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAuBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAoBpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAgB1D;AA2FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,EACzC,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,CAAC,CAAC,CAuHZ"}