agentfootprint 12.1.0 → 12.2.0

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

@@ -0,0 +1,308 @@
+/**
+ * pool — the state behind `mcpClientPool`: who holds which client, what is
+ * charged, and what ends when.
+ *
+ * Pattern: one state machine, mutated only between awaits.
+ * Role:    §§ 5–7 of the design. Every mutation of the sets and the budget runs
+ *          synchronously — a check and the move it allows are never split by
+ *          an await — so two callers cannot both take the last slot.
+ *
+ *   - ADMISSION: every listing, call, acquire and ending is admitted against
+ *     `maxOperations` before anything is sent. At each interaction the lazy
+ *     sweep (revoked leases, idle ends, deferred ends) runs FIRST, so it
+ *     reserves its endings before the new operation is admitted.
+ *   - ONE OPEN PER KEY, from a plan resolved at that moment, under the pool's own
+ *     signal and `initTimeoutMs`, never a caller's. A caller that gives up
+ *     detaches alone; the operation that started the open keeps its charge until
+ *     the open's work settles. Past the deadline every waiter is refused at once
+ *     (`init-timeout`), and until the open's work settles the key cannot open
+ *     again. A failure reaches every current waiter and is not cached.
+ *   - THE HANDOFF: every operation waiting for an open holds a RESERVATION on
+ *     the client until it takes its lease, so between the open settling and
+ *     that lease the client is busy — nobody can evict, idle-end or end it. The
+ *     client's state is checked again after every wait, and the lease taken in
+ *     the same step: a lease is never handed out on a client that is ending.
+ *   - MAKING ROOM: the principal's, then the pool's, least recently used IDLE
+ *     client moves to the ending set — or `PoolFullError` at once.
+ *   - ENDING reserves an ending slot and an operation slot FIRST; when either is
+ *     full the client stays in the open set, counted, reported deferred, and is
+ *     ended when slots free. Every end goes through `terminate()` — but a client
+ *     whose handle this process lost: nothing can be sent for it, so its ending
+ *     is its local close alone, charged the same way until it settles.
+ *   - SETTLEMENT, never an abort, returns a slot (`work.ts`).
+ *   - NOTHING UNCHECKED: on a pooled client every request carries a guard — its
+ *     call's, or the client's open, listing or ending — and a request with none
+ *     is refused before it is sent (`request-unmatched`), at the watched `send`
+ *     and at the pool's own fetch alike.
+ */
+import type { Tool } from '../../tools/tools.js';
+import type { McpTerminateOutcome } from '../types.js';
+import { ClientSet, type PreviousEnd } from './clientSet.js';
+import { SharedDefinitions, type Definition, type DefinitionList } from './definitions.js';
+import { McpPoolRefusedError, PoolFullError, type McpPoolLimit } from './errors.js';
+import { type PoolKey } from './identityKey.js';
+import { type PoolSettings } from './options.js';
+import { type ClientPlan } from './plan.js';
+import { PooledClient, type EndReason } from './pooledClient.js';
+import { Reporter, type UseFacts } from './record.js';
+import { OperationBudget, Work, type Operation, type OperationKind, type WorkKind } from './work.js';
+/** An app lease, as the pool tracks it for `maxLeaseMs`. */
+export interface HeldLease {
+    readonly client: PooledClient;
+    readonly takenAt: number;
+    /** Revoked: its next use throws `lease-expired`. */
+    revoked: boolean;
+    /** Released: idempotent. */
+    released: boolean;
+}
+/** Where a list's definitions live: a client's own, or a shared entry. */
+export interface ServedList {
+    readonly list: DefinitionList;
+    readonly shared: boolean;
+    /** The definitions context: `pc:` or `sh:`. */
+    readonly context: string;
+}
+/** What `stats()` returns: counts, never keys. */
+export interface McpPoolStats {
+    /** Clients in the open set: opening, busy or idle. */
+    readonly open: number;
+    readonly busy: number;
+    readonly idle: number;
+    readonly opening: number;
+    /** Clients being ended, until each ending's work has settled. */
+    readonly ending: number;
+    /** Operations charged. */
+    readonly operations: number;
+    /** Shared definition entries kept. */
+    readonly entries: number;
+    /** Charged work past its deadline that has not settled, by what it is doing. */
+    readonly unsettled: Readonly<Record<WorkKind, number>>;
+    /** Endings whose remote outcome was not confirmed. */
+    readonly unresolvedEndings: number;
+}
+export declare class Pool {
+    readonly settings: PoolSettings;
+    readonly clients: ClientSet;
+    readonly budget: OperationBudget;
+    readonly shared: SharedDefinitions;
+    readonly reporter: Reporter;
+    /** The pool's own signal: what every open, listing and call runs under; aborted at `close()`. */
+    private readonly lifetime;
+    private readonly leases;
+    private readonly settleWaiters;
+    /** Waiting for some client to become idle (`terminate`, `close`). */
+    private readonly idleWaiters;
+    closed: boolean;
+    unresolvedEndings: number;
+    constructor(settings: PoolSettings);
+    now(): number;
+    get signal(): AbortSignal;
+    /**
+     * The lazy sweep, run at the start of every interaction: leases past
+     * `maxLeaseMs` revoked, idle clients ended, deferred endings retried — all of
+     * it before a new operation is admitted.
+     */
+    interact(): void;
+    /**
+     * Admit one operation, or refuse at once: `closed`, or `PoolFullError`
+     * (`limit: 'operations'`) — before anything is sent.
+     */
+    admit(kind: OperationKind, phase: WorkKind, callerSignal: AbortSignal | undefined): Operation;
+    refused(reason: McpPoolRefusedError['reason'], cause?: unknown): McpPoolRefusedError;
+    full(limit: McpPoolLimit): PoolFullError;
+    /**
+     * A library lease on `key`'s client for `operation`, opening one when the key
+     * has none (inside the operation's slot). `plan` is the plan resolved for a
+     * new client; a key that already has one keeps its own. The lease is
+     * released when the operation SETTLES.
+     */
+    leaseClient(key: PoolKey, operation: Operation, facts: UseFacts, plan?: ClientPlan): Promise<PooledClient>;
+    /**
+     * Wait for `client`'s open inside `operation`, holding a reservation on it
+     * all the while — between the open settling and this lease the client is
+     * busy, so nobody can evict, idle-end or end it — then check it again and
+     * lease it in the same step, with no wait between. `undefined` when it no
+     * longer serves: the caller's next round finds the key's next client.
+     */
+    private leaseOnceOpen;
+    /** `client` may have just become idle: a deferred ending may run, and a waiter for idleness may go on. */
+    private becameIdle;
+    private takeLease;
+    /** One lease ended: the client may now be idle, and a deferred ending may run. */
+    releaseLease(client: PooledClient): void;
+    private notifyIdle;
+    /** An app lease: a hold on a client for as long as the app keeps it, at most `maxLeaseMs`. */
+    holdLease(client: PooledClient): HeldLease;
+    /** End an app lease — at most once, whether released or revoked. */
+    endLease(lease: HeldLease): void;
+    private revokeExpiredLeases;
+    /** Every app lease is revoked: the pool is closing. */
+    revokeAllLeases(): void;
+    /**
+     * Open a client for `key`: make room, resolve its plan, admit it to the open
+     * set, and start the one open. The operation that started it tracks the open's
+     * settlement, so its charge stays until the open's work has settled.
+     */
+    private openFor;
+    /** The one open of `client`, under the pool's own signal and `initTimeoutMs`. */
+    private startOpen;
+    private dropFailedOpen;
+    /** Wait for `client`'s open inside `operation`: the caller's signal detaches the caller only. */
+    private waitOpen;
+    /** What `mcpClient` is opened with: the connection-shaping options, the pool's signal. */
+    private clientOptions;
+    /** What only a pool asks of the client it opens (`clientPort.ts`). */
+    private seamFor;
+    /**
+     * The guard for a message on `client` that carries none of its own: a tool
+     * call always brings its call's guard, so one without it is refused; any
+     * other request runs under the client's open, listing or ending — and with
+     * none under way, it is refused too. Nothing pooled is sent unchecked.
+     */
+    private guardOf;
+    /** The guard of a request nothing covers: it refuses, so the request is never sent. */
+    private readonly unmatched;
+    /**
+     * The pool's own fetch, outermost on every pooled transport: a request is
+     * checked against its guard (the pooled call's, else the client's phase) and
+     * counted under it; the guard's signal is linked in; and the answer is read
+     * for the two pieces of evidence the pool classifies on — a 404 the MCP server
+     * itself sent to a request that carried its session id, and a handle this
+     * process lost. The client's own standalone stream (a GET), a notification and
+     * an answer to the server's own request are the client's, not an operation's:
+     * they pass untouched. Any other request with no guard is refused unsent.
+     */
+    private pooledFetch;
+    /**
+     * Make room for a new client of `key`: the principal's least recently used
+     * idle client, then the pool's, moves to the ending set — or `PoolFullError`
+     * at once, naming the budget. There is no queue.
+     */
+    private makeRoom;
+    /**
+     * Move `victim` to the ending set to make room. When the slots cannot be
+     * reserved, the arrival is refused at once, and the victim stays in the open
+     * set, counted, reported deferred — ended once slots free.
+     */
+    private evict;
+    /** An ending slot and an operation slot, both, or which one is full. */
+    private reserveEnding;
+    /**
+     * End `client` for `reason` — when it is idle and both slots can be reserved.
+     * Otherwise it stays in the open set, still counted, and is reported deferred
+     * (once); it is ended when its last lease ends or slots free.
+     */
+    endClient(client: PooledClient, reason: EndReason): void;
+    private defer;
+    /**
+     * Move `client` into the ending set under `operation`, and end it through
+     * `terminate()` — or, for a lost handle, through its local close alone.
+     */
+    private startEnding;
+    private noteEnded;
+    /**
+     * A client whose handle this process lost: nothing can be sent for it, so it
+     * leaves its key at once — the next use opens the key's next client — and is
+     * ended under the ending rule like any other: its ending is its LOCAL close,
+     * charged an ending slot and an operation slot until that close settles, its
+     * remote outcome recorded unresolved. Busy, or with no slots free, it waits —
+     * still counted in the open set, reported deferred.
+     */
+    lostHandle(client: PooledClient): void;
+    /** A client whose session the server ended: no new lease; ended (through `terminate()`) when idle. */
+    expired(client: PooledClient): void;
+    private sweepIdle;
+    /** Retry every deferred ending whose client is now idle. */
+    retryDeferred(): void;
+    /** Where `client`'s definitions are served from: its shared entry, or its own list. */
+    servedListOf(client: PooledClient): ServedList;
+    /**
+     * The definitions context `client` serves under NOW: the app's `share` asked
+     * again over the client's own configuration. A changed answer moves the
+     * client to the new context and stops serving its own list, so every tool
+     * bound under the old one is refused before it is sent.
+     *
+     * @throws `binding-changed`, `share`'s error as its cause, when the answer
+     *   cannot be had — never the old context
+     */
+    refreshContext(client: PooledClient): PooledClient['definitions'];
+    /** Does `context` still name the definitions context `client` serves under? False when it cannot be had. */
+    contextHolds(client: PooledClient, context: string): boolean;
+    /**
+     * The list `client` serves under NOW, listed again on it when it cannot be
+     * served as it stands — one listing at a time per list; a second caller joins
+     * it inside its own slot. Every attempt asks the app's names again
+     * (`refreshContext`), so a listing that a moved context discarded or refused
+     * at its send is listed once more under the context of now, never written
+     * into the one it began under. A listing raced by an invalidation is
+     * discarded too. Refused (`stale-tools`) when three attempts serve nothing.
+     * What it returns was checked against the context with no wait since.
+     */
+    ensureListed(client: PooledClient, operation: Operation): Promise<ServedList>;
+    /**
+     * What `client` can serve under the context of now — asked of the app's names
+     * here — or, when nothing can, the list it should list. Too long to share:
+     * the conversation's own client keeps that list, under the same context.
+     */
+    private servableNow;
+    /**
+     * One listing on `client` for `served`'s context. Its requests are sent only
+     * while that context holds — asked at every boundary they cross — and its
+     * answer is written only if the context still holds when it arrives and the
+     * list's generation held: an answer the app's names moved under belongs to
+     * no context, and is dropped.
+     */
+    private startListing;
+    /**
+     * A request failed: when the pool's fetch read the server's own 404 for the
+     * session, or this process lost the handle, the client leaves its key — the
+     * next use opens the next client under the SAME key — and the error says so.
+     */
+    classifyFailure(client: PooledClient, work: Work, error: unknown): RequestEvidenceOutcome;
+    /** The server said a client's tool list changed: that client's list and its shared entry. */
+    private toolsChangedOn;
+    /** The app's permission signal: every list in the scope. */
+    permissionsChanged(scope: {
+        readonly tenant?: string;
+        readonly principal?: string;
+    }): void;
+    /** The server changed: every list. */
+    toolsChanged(): void;
+    /**
+     * Stop new leases on every client `scope` names, at once; wait for their
+     * in-flight work up to `waitMs`; then end each one whose slots can be
+     * reserved. The rest are reported deferred and ended when they can be.
+     */
+    terminate(matches: (key: PoolKey) => boolean, reason: EndReason, waitMs: number): Promise<readonly McpTerminateOutcome[]>;
+    /** End each of `clients` whose slots can be reserved; the outcomes of those that started. */
+    private endNow;
+    /** Wait until every client in `clients` is idle, or `waitMs` passed. */
+    private waitIdle;
+    /**
+     * Close: refuse new work, revoke app leases, abort in-flight work through the
+     * pool's own signal, then end every client as slots can be reserved — at most
+     * `maxEnding` at a time — in rounds, each bounded by `waitMs` (and each
+     * ending's answer by its own deadline). What could not be ended yet is
+     * reported deferred and ended when slots free; work still unsettled stays
+     * charged until it settles.
+     */
+    closeAll(waitMs: number): Promise<readonly McpTerminateOutcome[]>;
+    /** Wait until an ending slot and an operation slot are free, or `waitMs` passed. */
+    private waitSlots;
+    /** Refuse new work, revoke app leases, abort in-flight work through the pool's signal. */
+    shutDown(): void;
+    /** Resolve once every charged operation and every ending has settled. */
+    settled(): Promise<void>;
+    private quiet;
+    private notifySettled;
+    stats(): McpPoolStats;
+    /** The bound shape of every definition in `served`, for a client of `key`. */
+    definitionsOf(served: ServedList): readonly Definition[];
+    /** The tools a list's client-own entries carry, by name (per-client lists only). */
+    ownTool(served: ServedList, name: string): Tool | undefined;
+}
+/** What a failed request proved about its client, if anything. */
+export type RequestEvidenceOutcome = 'expired' | 'handle-lost' | undefined;
+/** Re-exported for the bound tool: which end reasons name a previous client. */
+export type { PreviousEnd };
+//# sourceMappingURL=pool.d.ts.map

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

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

package/dist/types/mcp/pool/pooledClient.d.ts

@@ -0,0 +1,94 @@
+/**
+ * pooledClient — one client INCARNATION: the conversation it serves, the plan it
+ * was opened from, its leases, its own tool list, and where it is in its life.
+ *
+ * Pattern: a plain record the pool owns; no behaviour beyond its own counters.
+ * Role:    § 5 of the design. A client is OPENING until its open settles, OPEN
+ *          while it can serve, ENDING from the decision to end it until that
+ *          ending's work has settled, then ENDED. It is BUSY while any lease is
+ *          open — the library's, one per operation, or the app's — while an
+ *          operation that waited for its open has not yet taken its lease (a
+ *          RESERVATION), and while it opens; IDLE otherwise. A busy client is
+ *          never evicted, closed for idleness or ended. "Used" is the last lease
+ *          taken or released.
+ *
+ * Its `clientId` is the pool's own random id; its `generation` counts the key's
+ * incarnations (1 = the key's first client). A replacement is a new record with
+ * a new id, a new list and a count of its own: nothing of an old incarnation
+ * can match it.
+ */
+import type { McpClient, McpTerminateOutcome } from '../types.js';
+import type { ClientPort } from '../clientPort.js';
+import type { RequestGuard } from '../requestGuard.js';
+import { DefinitionList } from './definitions.js';
+import type { PoolKey } from './identityKey.js';
+import type { ClientPlan } from './plan.js';
+import type { Work } from './work.js';
+/** Where a client is in its life. */
+export type ClientState = 'opening' | 'open' | 'ending' | 'ended';
+/** Why a client ended — the record's `reason`. */
+export type EndReason = 'idle' | 'evicted' | 'terminated' | 'closed' | 'expired' | 'handle-lost' | 'abandoned-open';
+/** One client incarnation. */
+export declare class PooledClient {
+    readonly key: PoolKey;
+    readonly plan: ClientPlan;
+    /** 1 = the key's first client, 2 = its first replacement, … */
+    readonly generation: number;
+    readonly clientId: string;
+    state: ClientState;
+    /** The ordinary `McpClient`, once opened. */
+    client: McpClient | undefined;
+    /** The port back (`clientPort.ts`), once opened. */
+    port: ClientPort | undefined;
+    /** Open leases: one per library operation, one per app lease. */
+    leases: number;
+    /**
+     * Operations waiting for its open, each holding it until it takes its lease —
+     * so between the open settling and that lease nothing can evict or end it.
+     */
+    reserved: number;
+    /** The last lease taken or released, on the pool's clock. */
+    usedAt: number;
+    /** No new lease: `terminate` named it, its session expired, or its handle was lost. */
+    closedToNew: boolean;
+    /** Its open ran past `initTimeoutMs`: refused to every waiter, still counted until it settles. */
+    abandoned: boolean;
+    /** Waiting for an ending slot and an operation slot, and why. */
+    deferredEnd: EndReason | undefined;
+    /** This incarnation's own tool list. */
+    readonly list: DefinitionList;
+    /**
+     * The guard of the open, listing or ending in progress on this client — what
+     * a request that is not a pooled tool call is checked against and counted by.
+     */
+    phase: RequestGuard | undefined;
+    /** The open in flight, with the work it owns. */
+    opening: {
+        readonly ready: Promise<void>;
+        readonly work: Work;
+        readonly startedAt: number;
+    } | undefined;
+    /** How long the open took, once it settled within its deadline. */
+    initMs: number | undefined;
+    /** Why it left its key without an ordinary ending: its session expired, or its handle was lost. */
+    lost: 'expired' | 'handle-lost' | undefined;
+    /** The outcome of its ending, once one started. */
+    endingOutcome: Promise<McpTerminateOutcome> | undefined;
+    /**
+     * The definitions context its tools are served under now. It starts as its
+     * plan's; the app's `share` is asked again at every use, and a changed answer
+     * moves it here — its connection, the plan's transport, never changes.
+     */
+    definitions: {
+        readonly context: string;
+        readonly shared: boolean;
+    };
+    constructor(key: PoolKey, plan: ClientPlan, 
+    /** 1 = the key's first client, 2 = its first replacement, … */
+    generation: number, now: number);
+    /** Busy: a lease is open, an operation holds it between its open and its lease, or it is still opening. */
+    get busy(): boolean;
+    /** Can it serve a new lease right now? */
+    get serving(): boolean;
+}
+//# sourceMappingURL=pooledClient.d.ts.map

package/dist/types/mcp/pool/pooledClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pooledClient.d.ts","sourceRoot":"","sources":["../../../../src/mcp/pool/pooledClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,qCAAqC;AACrC,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAElE,kDAAkD;AAClD,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,SAAS,GACT,YAAY,GACZ,QAAQ,GACR,SAAS,GACT,aAAa,GACb,gBAAgB,CAAC;AAOrB,8BAA8B;AAC9B,qBAAa,YAAY;IA+CrB,QAAQ,CAAC,GAAG,EAAE,OAAO;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,UAAU,EAAE,MAAM;IAjD7B,QAAQ,CAAC,QAAQ,SAAiB;IAClC,KAAK,EAAE,WAAW,CAAa;IAC/B,6CAA6C;IAC7C,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,oDAAoD;IACpD,IAAI,EAAE,UAAU,GAAG,SAAS,CAAC;IAC7B,iEAAiE;IACjE,MAAM,SAAK;IACX;;;OAGG;IACH,QAAQ,SAAK;IACb,6DAA6D;IAC7D,MAAM,EAAE,MAAM,CAAC;IACf,uFAAuF;IACvF,WAAW,UAAS;IACpB,kGAAkG;IAClG,SAAS,UAAS;IAClB,iEAAiE;IACjE,WAAW,EAAE,SAAS,GAAG,SAAS,CAAC;IACnC,wCAAwC;IACxC,QAAQ,CAAC,IAAI,iBAAwB;IACrC;;;OAGG;IACH,KAAK,EAAE,YAAY,GAAG,SAAS,CAAC;IAChC,iDAAiD;IACjD,OAAO,EACH;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAClF,SAAS,CAAC;IACd,mEAAmE;IACnE,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,mGAAmG;IACnG,IAAI,EAAE,SAAS,GAAG,aAAa,GAAG,SAAS,CAAC;IAC5C,mDAAmD;IACnD,aAAa,EAAE,OAAO,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAC;IACxD;;;;OAIG;IACH,WAAW,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;gBAGzD,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,UAAU;IACzB,+DAA+D;IACtD,UAAU,EAAE,MAAM,EAC3B,GAAG,EAAE,MAAM;IAMb,2GAA2G;IAC3G,IAAI,IAAI,IAAI,OAAO,CAElB;IAED,0CAA0C;IAC1C,IAAI,OAAO,IAAI,OAAO,CAErB;CACF"}

package/dist/types/mcp/pool/record.d.ts

@@ -0,0 +1,81 @@
+/**
+ * record — what the pool says about itself: one event per use in a run, and a
+ * report for what happens outside one.
+ *
+ * Pattern: facts gathered while a use runs, filed once; reports delivered to the
+ *          app's `onEvent`, which can never break the pool.
+ * Role:    § 8 of the design. The record holds ids and outcomes. It never holds
+ *          identity values, remote session ids or handles, header values, tool
+ *          arguments, results, definitions, or a server's error text. In a run,
+ *          every listing and every call files one `agentfootprint.tools.mcp_client`
+ *          (`tools/mcpClientUse.ts`). Outside a run — idle ends, evictions,
+ *          terminations, revoked leases, deferred ends and work that settled
+ *          after its deadline — the pool reports to `onEvent`.
+ *
+ * Local settlement and remote resolution are different facts, reported apart:
+ * an ending can settle here and stay unresolved there.
+ */
+import type { ToolsMcpClientPayload } from '../../events/payloads.js';
+import type { McpClientUse } from '../../tools/mcpClientUse.js';
+import type { McpTerminateOutcome } from '../types.js';
+import type { EndReason } from './pooledClient.js';
+import type { WorkKind } from './work.js';
+/** What happens to a pool outside a run, as `onEvent` receives it. Ids and outcomes only. */
+export interface McpPoolReport {
+    /**
+     * - `'ended'` — a client's ending finished, with its remote outcome;
+     * - `'deferred'` — a client to be ended stays in the open set, still counted,
+     *   until an ending slot and an operation slot free (or its lease ends);
+     * - `'lease-revoked'` — an app lease ran past `maxLeaseMs`;
+     * - `'settled-late'` — work whose caller was already answered has settled,
+     *   and its charge is released.
+     */
+    readonly kind: 'ended' | 'deferred' | 'lease-revoked' | 'settled-late';
+    /** The pool's name. */
+    readonly server: string;
+    /** The pool's own random id for the client, when one is concerned. */
+    readonly clientId?: string;
+    /** The tool-session digest of the conversation's key, when one is concerned. */
+    readonly keyHash?: string;
+    /** Why the client ended, or is to end. */
+    readonly reason?: EndReason;
+    /** `'ended'`: what the remote side answered (`McpTerminateOutcome.remote`). */
+    readonly remote?: McpTerminateOutcome['remote'];
+    /** `'ended'`: whether the remote ending was confirmed. */
+    readonly resolved?: boolean;
+    /** `'ended'`: the HTTP status the remote side answered with, when one was read. */
+    readonly status?: number;
+    /** `'ended'`: a failure's class name, never its message. */
+    readonly errorClass?: string;
+    /** `'settled-late'`: what the work was doing. */
+    readonly work?: WorkKind;
+    /** `'ended'`: how long the caller waited; `'settled-late'`: how long it ran past its answer. */
+    readonly durationMs: number;
+}
+/** Delivers reports to the app; a throwing handler is swallowed and changes nothing. */
+export declare class Reporter {
+    private readonly server;
+    private readonly onEvent;
+    constructor(server: string, onEvent: ((report: McpPoolReport) => void) | undefined);
+    report(report: Omit<McpPoolReport, 'server'>): void;
+}
+/** The facts one pool use gathers while it runs, filed once when it settles. */
+export declare class UseFacts {
+    private readonly server;
+    private readonly at;
+    keyHash: string | undefined;
+    clientId: string | undefined;
+    generation: number | undefined;
+    client: ToolsMcpClientPayload['client'];
+    previous: ToolsMcpClientPayload['previous'];
+    evidence: ToolsMcpClientPayload['evidence'];
+    refusal: ToolsMcpClientPayload['refusal'];
+    initMs: number | undefined;
+    definitions: ToolsMcpClientPayload['definitions'];
+    definitionsAgeMs: number | undefined;
+    revalidated: ToolsMcpClientPayload['revalidated'];
+    constructor(server: string, at: ToolsMcpClientPayload['at']);
+    /** The use, as `tools/mcpClientUse.ts` files it. */
+    toUse(): McpClientUse;
+}
+//# sourceMappingURL=record.d.ts.map

package/dist/types/mcp/pool/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../../src/mcp/pool/record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAE1C,6FAA6F;AAC7F,MAAM,WAAW,aAAa;IAC5B;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,eAAe,GAAG,cAAc,CAAC;IACvE,uBAAuB;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAChD,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,mFAAmF;IACnF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,iDAAiD;IACjD,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IACzB,gGAAgG;IAChG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED,wFAAwF;AACxF,qBAAa,QAAQ;IAEjB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBADP,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC,GAAG,SAAS;IAGzE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,GAAG,IAAI;CAQpD;AAED,gFAAgF;AAChF,qBAAa,QAAQ;IAaP,OAAO,CAAC,QAAQ,CAAC,MAAM;IAAU,OAAO,CAAC,QAAQ,CAAC,EAAE;IAZhE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,MAAM,EAAE,qBAAqB,CAAC,QAAQ,CAAC,CAAa;IACpD,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC5C,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC5C,OAAO,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC1C,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,WAAW,EAAE,qBAAqB,CAAC,aAAa,CAAC,CAAC;IAClD,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,WAAW,EAAE,qBAAqB,CAAC,aAAa,CAAC,CAAC;gBAErB,MAAM,EAAE,MAAM,EAAmB,EAAE,EAAE,qBAAqB,CAAC,IAAI,CAAC;IAE7F,oDAAoD;IACpD,KAAK,IAAI,YAAY;CAiBtB"}

package/dist/types/mcp/pool/sessionEnded.d.ts

@@ -0,0 +1,25 @@
+/**
+ * sessionEnded — the MCP server ended a conversation's session: the library's
+ * one `SessionExpiredError`, said the pool's way.
+ *
+ * Pattern: a subclass that keeps the class and changes only what the pool must.
+ * Role:    § 5.5 of the design. There is ONE expired-session class
+ *          (`provider-contract/sessionExpired.ts` · `SessionExpiredError`), so a
+ *          caller catches a code session's expiry and an MCP session's with the
+ *          same `instanceof`, under the same rule: only documented evidence
+ *          raises it. Here the evidence is `'server-404'`: an MCP server answered
+ *          HTTP 404 to a request that carried the session id it issued.
+ *
+ * What differs is what the pool may say. The model reads this error as the
+ * call's result, so its message is one fixed sentence; it names no remote
+ * session id (`sessionId` is the pool's own client id, which the record carries
+ * too) and never the server's text. The original error is `cause`, for the app.
+ */
+import { SessionExpiredError } from '../../provider-contract/sessionExpired.js';
+/** The one sentence a server-ended session reaches the model as. */
+export declare const SESSION_ENDED_SENTENCE = "The server had already ended the conversation's session when the call this result answers reached it.";
+/** @internal An MCP server ended the session; raised by the pool. Catch `SessionExpiredError`. */
+export declare class ServerEndedSessionError extends SessionExpiredError {
+    constructor(server: string, clientId: string, cause: unknown);
+}
+//# sourceMappingURL=sessionEnded.d.ts.map

package/dist/types/mcp/pool/sessionEnded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionEnded.d.ts","sourceRoot":"","sources":["../../../../src/mcp/pool/sessionEnded.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAEhF,oEAAoE;AACpE,eAAO,MAAM,sBAAsB,0GACsE,CAAC;AAE1G,kGAAkG;AAClG,qBAAa,uBAAwB,SAAQ,mBAAmB;gBAClD,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAO7D"}

package/dist/types/mcp/pool/work.d.ts

@@ -0,0 +1,117 @@
+/**
+ * work — an admitted operation's charge, and the work under it until that work
+ * has settled.
+ *
+ * Pattern: one object per unit of work that is at once the request guard
+ *          (`mcp/requestGuard.ts`) and the count of what is still running.
+ * Role:    The pool's third budget (`docs/design/2026-10-mcp-client-pool.md`
+ *          § 5.3). The accounting unit is the admitted LOGICAL operation: a
+ *          `tools/call`, a listing (one `list(ctx)` for one conversation), an
+ *          `acquire` and an ending each take one slot at admission. Setup an
+ *          operation performs for itself — the open of its key's client, the
+ *          revalidating `tools/list` of a replacement — runs inside that slot.
+ *
+ * AN ABORT IS NOT SETTLEMENT. A slot is released only when the operation's
+ * logical request has its answer AND every piece of work under it has settled:
+ * the `send()` it made, a credential vend, an attempt's `fetch`, an AWS `send`,
+ * the open it owns. A caller's timeout answers the caller; it frees nothing.
+ * Work that never settles keeps its charge — `stats().unsettled` reports it,
+ * and the budget refuses new work rather than admit it against room that does
+ * not exist. There is no release that returns capacity sooner.
+ */
+import type { RequestGuard } from '../requestGuard.js';
+/** What a unit of work is doing now — what `stats().unsettled` counts it under. */
+export type WorkKind = 'open' | 'listing' | 'call' | 'ending';
+/** What an operation is, as the budget admits it. */
+export type OperationKind = 'listing' | 'call' | 'acquire' | 'ending';
+/** What a request's answer proved, as the pool's fetch read it (`pool.ts`). */
+export type WorkEvidence = 'server-404' | 'handle-lost';
+/**
+ * One unit of pooled work: its requests are checked against it at every
+ * boundary (`check`), and every promise started for it is counted until it
+ * settles (`track`). It is SETTLED once its logical part has finished and the
+ * count is zero.
+ */
+export declare class Work implements RequestGuard {
+    /** What it is doing now. */
+    phase: WorkKind;
+    private readonly link;
+    private pending;
+    private finished;
+    private done;
+    /** Still running underneath when the caller was answered: it lingered. */
+    private lingered;
+    private readonly listeners;
+    /** What `check` asks besides the abort — a call's binding. */
+    private extra;
+    /** What the latest answered request proved, if anything. */
+    evidence: WorkEvidence | undefined;
+    constructor(
+    /** What it is doing now. */
+    phase: WorkKind, sources: readonly (AbortSignal | undefined)[]);
+    /** What aborts its own work: its sources, its deadline, its caller detaching. */
+    get signal(): AbortSignal;
+    /** True once its logical part finished and everything under it settled. */
+    get settled(): boolean;
+    /** Its caller was answered while work under it still ran. */
+    get unsettledPastAnswer(): boolean;
+    /** Abort its work with `reason` (a deadline, a detached caller). Idempotent. */
+    abort(reason: unknown): void;
+    /** Ask `gate` too, each time a request is checked. */
+    guardWith(gate: () => void): void;
+    /**
+     * The send gate: refused once its caller was answered (nothing more is sent
+     * for an answered operation), once aborted, or when the extra gate refuses.
+     */
+    check(): void;
+    /** Count `work` until it settles. Never throws; never surfaces its rejection. */
+    track(work: PromiseLike<unknown>): void;
+    /** Record what a request's answer proved. */
+    note(evidence: WorkEvidence): void;
+    /**
+     * Its logical part is over: the caller has its answer. It settles now, or —
+     * when work under it still runs — when that work does.
+     */
+    finish(): void;
+    /** Did it linger — answered while work under it ran? Read once it settled. */
+    get settledLate(): boolean;
+    /** Call `listener` once it has settled (at once when it already has). */
+    onSettled(listener: () => void): void;
+    /** A promise that resolves once it has settled. */
+    whenSettled(): Promise<void>;
+    private settleIfDone;
+}
+/** An admitted operation: a unit of work that holds one slot of the budget. */
+export declare class Operation extends Work {
+    readonly kind: OperationKind;
+    /** When it was admitted, on the pool's clock. */
+    readonly admittedAt: number;
+    constructor(kind: OperationKind, phase: WorkKind, sources: readonly (AbortSignal | undefined)[], 
+    /** When it was admitted, on the pool's clock. */
+    admittedAt: number);
+}
+/**
+ * The pool-wide operation budget: at most `max` operations charged, each from
+ * its admission until it has SETTLED (see the module note). Admission is the
+ * only way in; settlement the only way out.
+ */
+export declare class OperationBudget {
+    readonly max: number;
+    private readonly charged;
+    private readonly onRelease;
+    constructor(max: number);
+    /** Operations charged now. */
+    get count(): number;
+    /** Is there a free slot? */
+    get hasRoom(): boolean;
+    /**
+     * Admit one operation, or `undefined` when the budget is full. The slot is
+     * charged from here until the operation settles.
+     */
+    admit(kind: OperationKind, phase: WorkKind, sources: readonly (AbortSignal | undefined)[], now: number): Operation | undefined;
+    /** Call `listener` each time an operation settles and frees its slot. Returns the unsubscribe. */
+    whenReleased(listener: (operation: Operation) => void): () => void;
+    /** Charged work whose caller was already answered and which has not settled, by what it is doing. */
+    unsettled(): Record<WorkKind, number>;
+}
+//# sourceMappingURL=work.d.ts.map