@animalabs/agent-framework 0.22.2 → 0.23.0

package/dist/src/mcpl/server-connection.d.ts

@@ -41,10 +41,93 @@ export interface McplConnectionCloseInfo {
  *  handshake's error keeps, when there is one. */
 export declare function stderrTailOf(error: unknown): string | undefined;
 /** For the host's own log line about a failed connect: the server's stderr
- *  that the error keeps as `stderrTail`, one marked line per line of it,
- *  each through log-value, since it's the server's text. '' when there's
+ *  that the error keeps as `stderrTail`, with the server's credentials
+ *  taken out by `redact` (its redactServerText), one marked line per line of
+ *  it, each through log-value, since it's the server's text. '' when there's
  *  none. */
-export declare function withStderr(error: unknown): string;
+export declare function withStderr(error: unknown, redact: (text: string) => string): string;
+/**
+ * The server and this engine have no protocol revision in common, so the
+ * connection was never established. This is a protocol-negotiation fact, not
+ * a request outcome. Retrying cannot change it: each engine offers one
+ * revision, and only configuration can fix the mismatch. A connection that
+ * gets this error does not schedule reconnects. The legacy engine and the
+ * modern one (ModernMcpConnection, whose pinned revision the server refused)
+ * both throw it, so its readers treat them alike.
+ *
+ * - `rejected`: the server refused the offered revision: the legacy engine's
+ *   `initialize` answered with error -32022, or a modern server's discovery
+ *   or error naming no common revision. `supported` is the server's own list,
+ *   when it gave one.
+ * - `mismatch`: the server answered the legacy engine's `initialize` with a
+ *   revision other than 2024-11-05, or with none.
+ */
+export declare class McplProtocolVersionError extends Error {
+    readonly kind: 'rejected' | 'mismatch';
+    /** Revision the server answered with (`mismatch`; null when it gave none). */
+    readonly returned: string | null;
+    /** Revisions the server says it supports (`rejected`, when stated). */
+    readonly supported: readonly string[] | null;
+    /** The JSON-RPC error's code and data, verbatim (`rejected`). */
+    readonly code?: number | undefined;
+    readonly data?: unknown;
+    /** The revision this client offered: the legacy engine's, unless a
+     *  modern connection's. */
+    readonly offered: string;
+    constructor(message: string, kind: 'rejected' | 'mismatch', 
+    /** Revision the server answered with (`mismatch`; null when it gave none). */
+    returned: string | null, 
+    /** Revisions the server says it supports (`rejected`, when stated). */
+    supported: readonly string[] | null, 
+    /** The JSON-RPC error's code and data, verbatim (`rejected`). */
+    code?: number | undefined, data?: unknown, 
+    /** The revision this client offered: the legacy engine's, unless a
+     *  modern connection's. */
+    offered?: string);
+}
+/**
+ * A connect that failed, and whose cleanup couldn't confirm that the child
+ * exited: it may still be running. `connection` owns that launch, closed and
+ * not reconnecting. Its close() retries the reap and resolves once the exit
+ * is confirmed, so the caller can still clean up, and should start nothing
+ * else for this server until then. connect() and connectWithReconnect()
+ * throw this, and the modern engine's ModernMcpConnection.connect() too.
+ * `cause` is the connect's own failure.
+ */
+export declare class McplUnreapedLaunchError<Connection extends {
+    close(): Promise<void>;
+} = McplServerConnection> extends Error {
+    readonly connection: Connection;
+    /** The cleanup's own failure: the child it couldn't confirm exited. */
+    readonly cleanup: Error;
+    constructor(connection: Connection, failure: Error, 
+    /** The cleanup's own failure: the child it couldn't confirm exited. */
+    cleanup: Error);
+}
+/**
+ * Why a request to an MCPL server produced no result, as far as the host can
+ * know it. Messages are unchanged from plain errors; the `outcome` makes the
+ * difference between "never left the host" and "left, and no answer came
+ * back" a fact a caller can act on instead of a string to match:
+ * - `not-sent`: the request was refused before anything was written (the
+ *   connection was already closed);
+ * - `error-response`: the server answered with a JSON-RPC error (it may have
+ *   acted before failing; the error alone does not say);
+ * - `no-response`: the request was handed to the transport and no answer
+ *   came back (timeout, or the connection closed while awaiting). It does
+ *   not prove the request reached the server — the transport can decline or
+ *   drop a write — only that the host can no longer say it didn't.
+ */
+export declare class McplRequestError extends Error {
+    readonly outcome: 'not-sent' | 'error-response' | 'no-response';
+    /** The JSON-RPC error's `data`, verbatim, when the server supplied one
+     *  (e.g. which parts of a multi-part send were posted). */
+    readonly data?: unknown;
+    constructor(message: string, outcome: 'not-sent' | 'error-response' | 'no-response', 
+    /** The JSON-RPC error's `data`, verbatim, when the server supplied one
+     *  (e.g. which parts of a multi-part send were posted). */
+    data?: unknown);
+}
 /**
  * McplServerConnection manages a single JSON-RPC 2.0 connection to an
  * MCPL server over stdio. Use the static `connect()` factory to create
@@ -66,7 +149,12 @@ export declare function withStderr(error: unknown): string;
  *   server's stderr when its handshake failed by its transport closing, a
  *   transport error or its timeout and it had written any; `error` never
  *   carries it.
- * - `'reconnect'`          — Background reconnect succeeded
+ * - `'reconnect'`          — Background reconnect succeeded. The new transport
+ *                            starts with an empty grant and both planes
+ *                            closed, as at initial connect: whoever owns the
+ *                            connection runs the §5.3 policy exchange again,
+ *                            then opens the planes (the framework's listener
+ *                            does).
  */
 export declare class McplServerConnection extends EventEmitter {
     /** Unique server identifier from config. */
@@ -82,6 +170,9 @@ export declare class McplServerConnection extends EventEmitter {
     /** OUTER standard MCP capabilities.tools was present at handshake (§5.1 —
      *  the sole source of the `tools` capability path). */
     mcpToolsAdvertised: boolean;
+    /** The MCP revision established by the last successful handshake (always
+     *  2024-11-05 for this engine), or null before the first one. */
+    protocolVersion: string | null;
     /** Host-owned per-server authority for host/command (config
      *  allowHostCommands, default false). No capability path exists and the
      *  grant cannot confer it — server params never decide admin authority. */
@@ -133,6 +224,19 @@ export declare class McplServerConnection extends EventEmitter {
      * performs a fresh initialize handshake, so authority from the dead epoch
      * must be revoked before the replacement transport is exposed. */
     private resetPolicyForTransportBoundary;
+    /** What of these held items a transport boundary keeps (see
+     *  resetPolicyForTransportBoundary), in order, each marked `kept`; the
+     *  rest is logged and dropped. A connection closed for good has no next
+     *  transport whose grant could admit what the server reported about the
+     *  world, so that is dropped too. */
+    private keepAcrossBoundary;
+    /** Hold these items in place of what is held, with heldRequests and
+     *  keptRequests counting the requests among them: a boundary keeps some of
+     *  what was held, a flush that crosses one holds the rest of its snapshot
+     *  again, and a flush starts from nothing held. Notifications need no cap
+     *  here: hold caps them kept or not, and what this is given never has more
+     *  than was held. */
+    private replaceHeld;
     /** The active transport (stdio child or WebSocket). Null for a disconnected
      *  stub awaiting its first background reconnect. */
     private transport;
@@ -148,23 +252,55 @@ export declare class McplServerConnection extends EventEmitter {
     /** Set by `reconnectAfterFailure()` before it closes a live transport, so
      *  the transport close handler reports that teardown as `byHost: true`. */
     private hostCloseRequested;
+    /** Set by `close()`: this host has stopped the connection, as a removal and
+     *  a restart both do, so a request after it can't say whether the server
+     *  comes back. */
+    private closedByThisHost;
+    /** The host's close attempt: in flight, or done. A failed one is cleared,
+     *  so the next close() tries again. */
     private closePromise;
+    /** The host closed this connection while it was live, and its teardown
+     *  hasn't completed yet: 'close' is emitted once it has. */
     private closeIncomplete;
-    private reconnectPromise;
     /** Per-request timeout in ms (0 disables). See McplServerConfig.requestTimeoutMs. */
     private requestTimeoutMs;
+    /** The deadline a channels/publish or channels/open request keeps when
+     *  requestTimeoutMs is 0 (see sendChannelsPublish). */
+    private publishDeadlineMs;
     private controlPlaneReady;
     private dataPlaneReady;
     private bufferedEvents;
-    /** Cap on buffered responder-less events during a plane pause (issue #122).
-     *  Held server→host requests are never dropped and may exceed this. */
-    private static readonly MAX_BUFFERED_EVENTS;
+    /** How many of bufferedEvents are server→host requests, each holding a
+     *  responder its server waits on. Every change to bufferedEvents keeps it. */
+    private heldRequests;
+    /** How many of bufferedEvents are requests a transport boundary kept:
+     *  incoming messages and pushes whose transport has closed. No server waits
+     *  on them, since their answers can't reach it (sameTransport), so they
+     *  stay out of the held-request budget, which bounds what a live server
+     *  waits on: a dead process's backlog must not refuse the next process's
+     *  registration. They have their own bound at the same size, past which a
+     *  kept request is dropped and logged, there being no one to refuse. */
+    private keptRequests;
+    /** Kept requests dropped at their bound since the planes last opened
+     *  (ready()), so the first of each run of drops is logged. */
+    private droppedKeptRequests;
+    /** Cap on held notifications (responder-less events) during a plane pause
+     *  (issue #122), counted apart from requests: past it, the oldest held
+     *  notification is dropped. */
+    private static readonly MAX_HELD_NOTIFICATIONS;
+    /** Budget of held requests during a plane pause (#387), counted apart from
+     *  notifications: past it, a request is refused at once, never dropped. It
+     *  bounds a server that pipelines requests without waiting for answers. A
+     *  server that doesn't send a refused request again loses it (discord-mcpl
+     *  doesn't), so the budget sits far above the notifications' cap, to leave
+     *  a busy server's long pause room. Requests a transport boundary kept are
+     *  counted apart from it (keptRequests), with a bound of the same size past
+     *  which they're dropped, since no server waits on them. */
+    private static readonly MAX_HELD_REQUESTS;
     private droppedBufferedEvents;
-    /** True while ready()/readyControlPlane() re-emit a buffer snapshot. Items
-     *  re-buffering mid-flush were already admitted once — applying the cap to
-     *  them again would evict events that were legally held (the cap targets
-     *  NEW arrivals during a pause, not churn from control-plane flushes). */
-    private flushDepth;
+    /** Requests refused at the budget since the planes last opened (ready()),
+     *  so each pause's first refusal is logged. */
+    private refusedHeldRequests;
     private config;
     private hostCapabilities;
     private reconnectEnabled;
@@ -174,9 +310,27 @@ export declare class McplServerConnection extends EventEmitter {
     /** Consecutive failed connect attempts since the last successful handshake.
      *  Drives the exponential backoff and is reported on reconnect events. */
     private reconnectAttempts;
+    /** The reconnect attempt in flight, so close() can abort it and wait for
+     *  its cleanup. */
+    private reconnecting;
+    /**
+     * Launches whose cleanup couldn't confirm that the child exited. While any
+     * is held, reconnecting is halted, since another launch could run beside
+     * one that's still alive. close() retries their reap.
+     */
+    private unreaped;
     /** Whether a background reconnect loop will revive this connection after a
-     *  drop. False once close() has been called (explicit close stops retrying). */
+     *  drop. False once close() has been called (explicit close stops retrying),
+     *  after a protocol-version verdict, and while a launch is unreaped. */
     get willReconnect(): boolean;
+    /** Whether a child this connection launched couldn't be confirmed exited.
+     *  While it's true the connection owns that child, so whatever registered
+     *  it keeps its id held; close() retries the reap. */
+    get holdsUnreapedChild(): boolean;
+    /** Closed with no reconnect to come: after close(), whether or not its
+     *  transport close succeeded, or a drop with reconnect off. A connection
+     *  between retries keeps reconnectEnabled, so it isn't closed for good. */
+    private get closedForGood();
     /**
      * Private constructor. Use `McplServerConnection.connect()` instead.
      */
@@ -185,19 +339,98 @@ export declare class McplServerConnection extends EventEmitter {
      * Mark the connection as ready — flushes any events that arrived between
      * construction (when setupMessageRouting starts emitting) and now (when
      * the caller has attached listeners via wireMcplEvents).
+     *
+     * Once the connection is closed for good it readies nothing. Its policy was
+     * reset when it closed, so what the server sent that needs a grant would be
+     * refused, and a closed connection sends no response, so nothing it held
+     * could be answered. It delivers only its own reports of how it ended (see
+     * {@link deliverOwnReports}). A connection between retries isn't closed for
+     * good: what it held, such as a reconnect stub's connect-failed, reaches
+     * its listeners as it does any connection's, except the incoming messages
+     * and pushes a transport boundary kept, which wait for the next
+     * transport's grant (see {@link flushHeld}).
      */
     ready(): void;
+    /**
+     * Re-emit a held snapshot through the admission gate (this.emit), inside
+     * the containment boundary every inbound event shares
+     * (dispatchInboundEvent), in admission order (admissionOrder). A transport
+     * boundary crossed during the flush (a listener that closes the connection,
+     * say) leaves the rest of the snapshot to the boundary rule, as if it had
+     * still been held: what the server said about its own process is dropped,
+     * and the rest is held again, after whatever this flush held.
+     *
+     * Between transports, the incoming messages and pushes a boundary kept
+     * stay held for the next transport's grant: admitted now, they would meet
+     * the empty grant the boundary left, with no transport to answer on. The
+     * host's own reports about the transport (a stub's connect-failed, say)
+     * need no grant and go on.
+     */
+    private flushHeld;
+    /** Whether the plane an event belongs to is open (lifecycle events always
+     *  pass), as the admission gate (emit) decides it. */
+    private planeReadyFor;
+    /**
+     * The order a flush admits a held snapshot in: as it was held, except that
+     * when it holds items a transport boundary kept, the current transport's
+     * channel registrations (`channels-register`, `channels-changed`) go
+     * first, each unless it names a channel that something the transport sent
+     * before it, and that stays where it was held, also names (below). The
+     * registry refuses a message for a channel it doesn't know
+     * (§14.5). It keeps a server's channels across a reconnect, but a
+     * registration the old process sent that was still held at the boundary
+     * was dropped with it (keepAcrossBoundary), so the next process registers
+     * that channel anew, behind what was kept: a kept message for it admitted
+     * first would be refused, and lost, since a bridge that recorded it as
+     * forwarded doesn't send it again.
+     * Nothing else moves, so a snapshot with nothing kept is flushed as it was
+     * held. A registration also passes whatever its own transport sent before
+     * it, which a server that announces its channels first, as a bridge does,
+     * never has. A removal stays where it was held, with whatever else it adds
+     * or updates, as everything does that isn't a registration. A registration
+     * that names a channel which an earlier removal, or an earlier registration
+     * that stays, names stays where it was held too, so the writes to one
+     * channel keep their order: a channel's removal and its re-registration,
+     * and two registrations or updates of it. In a flush that opens both
+     * planes, what the transport sent before a removal is admitted before it,
+     * its messages for that channel included. A flush that opens only the control
+     * plane, as during a quiesce, admits the control traffic, a removal
+     * included, and holds the data plane's again until that plane opens, as
+     * live traffic is during a quiesce: a message held for a channel a removal
+     * took is then refused as the data plane opens.
+     */
+    private static admissionOrder;
+    /** The channels a held `channels-changed` removes. The registry takes any
+     *  entry of `removed` as a channel id, by its string form, so a number
+     *  removes the channel of its digits; an object is left out here, since
+     *  its string form can throw. */
+    private static removedChannelIds;
+    /** The channels a held `channels-register` registers, or a held
+     *  `channels-changed` adds or updates. */
+    private static registeredChannelIds;
     /**
      * Release only server-establishment and lifecycle/control traffic. Responses
      * to host requests are never event-buffered, so tools/list and tools/call
      * responses remain live as well. Inference-bearing requests stay queued in
-     * their original relative order until {@link ready} is called.
+     * their original relative order until {@link ready} is called. Like
+     * {@link ready}, once the connection is closed for good it delivers only
+     * its own reports of how it ended.
      */
     readyControlPlane(): void;
+    /**
+     * A connection closed for good still says how it ended. Its own buffered
+     * connect-failed and reconnect-failed, such as the permanent failure of a
+     * launch held as unreaped before the first gate released it, are the
+     * framework's records of it: they need no grant, and its listeners act on
+     * them (a trace, and for a permanent failure an alert and its tools leaving
+     * the list). What the server sent stays held.
+     */
+    private deliverOwnReports;
     /**
      * Close the data plane synchronously while leaving an already-released
-     * control plane live. Used before reconnect adoption and list-change
-     * reconciliation so no new inference event can beat barrier installation.
+     * control plane live. Used before list-change reconciliation so no new
+     * inference event can beat barrier installation. A reconnect closes both
+     * planes instead.
      */
     pauseDataPlane(): void;
     /**
@@ -206,6 +439,20 @@ export declare class McplServerConnection extends EventEmitter {
      * new data-plane gate before the fresh transport is exposed.
      */
     emit(event: string | symbol, ...args: unknown[]): boolean;
+    /**
+     * Hold an event until its plane opens, `kept` when a transport boundary
+     * keeps it for the next transport's grant (afterBoundary).
+     */
+    private hold;
+    /** A buffered server→host request: it carries a responder its server waits on. */
+    private static hasResponder;
+    /** Events routed from a server's transport that report the world, which
+     *  the next process doesn't send again when its bridge records them as
+     *  forwarded first: kept at a transport boundary while held. */
+    private static readonly WORLD_EVENTS;
+    /** Events routed from a server's transport that speak for its process, not
+     *  the world: dropped at a transport boundary while held. */
+    private static get PROCESS_EVENTS();
     /** Event-name form of METHOD_TO_REQUIRED_CAPABILITY, for admission-time
      *  enforcement in emit(). */
     private static readonly EVENT_TO_REQUIRED_CAPABILITY;
@@ -216,31 +463,66 @@ export declare class McplServerConnection extends EventEmitter {
      * capability negotiation, and return a ready-to-use connection.
      *
      * Works over stdio (spawned child) or WebSocket, selected by `config` (see
-     * {@link openTransport}). Throws if the transport can't be opened, the server
-     * closes/errors before the handshake, or the handshake times out.
+     * {@link openTransport}). Throws if the configuration can't be used (before
+     * anything is spawned or dialed), the transport can't be opened, the server
+     * closes/errors before the handshake, or the handshake times out. If the
+     * failed launch's cleanup can't confirm its child exited, it throws
+     * {@link McplUnreapedLaunchError}, whose connection owns that launch.
+     */
+    static connect(config: McplServerConfig, hostCapabilities: McplHostCapabilities, signal?: AbortSignal): Promise<McplServerConnection>;
+    /** {@link connect}, for a configuration its caller has already checked
+     *  (and warned about) once. `signal` ends the connect at once, its launch
+     *  reaped as for any failed handshake: its caller's stop() or a
+     *  disconnect of its id. */
+    private static connectChecked;
+    /**
+     * This engine's configuration check, made before anything is spawned or
+     * dialed: every problem {@link checkServerConfig} finds, the same check the
+     * framework applies, and the modern family, which belongs to
+     * ModernMcpConnection (an http(s) url is never dialed as a WebSocket).
+     * Every configuration that worked before still passes but the one
+     * serverConfigProblems names.
      */
-    static connect(config: McplServerConfig, hostCapabilities: McplHostCapabilities): Promise<McplServerConnection>;
+    private static checkConfig;
     /**
      * Open a fresh transport and run the MCP/MCPL initialize handshake over it,
      * returning the connected transport plus the negotiated capabilities. Shared
      * by {@link connect} and {@link attemptReconnect} so both transports handshake
      * identically. On any failure the transport is closed so a spawned child /
-     * open socket never leaks.
+     * open socket never leaks. If that close can't confirm the child exited,
+     * the failure is a {@link HandshakeCleanupError} carrying the transport, so
+     * the caller keeps owning it. `signal` ends a handshake whose connection is
+     * closed meanwhile: it cuts a WebSocket dial short, is checked once the
+     * transport is open, and races the initialize answer.
      */
     private static handshake;
     /**
      * Connect with reconnect support.
      * When `config.reconnect` is true and the initial connection fails,
      * resolves immediately with null capabilities and retries in the background.
+     * A configuration this engine can't use, or a protocol-version verdict,
+     * still throws: retrying can't change either. So does a failed launch that
+     * can't be reaped, as in {@link connect}: no retry starts beside a child
+     * that may still be running, and the {@link McplUnreapedLaunchError}
+     * carries the connection that owns it, whose close() retries the reap.
      * Adapted from Anarchid/agent-framework@mcpl-module-proto.
      */
-    static connectWithReconnect(config: McplServerConfig, hostCapabilities: McplHostCapabilities): Promise<McplServerConnection>;
+    static connectWithReconnect(config: McplServerConfig, hostCapabilities: McplHostCapabilities, signal?: AbortSignal): Promise<McplServerConnection>;
     /**
-     * Create a disconnected stub connection that will reconnect in the background.
-     * Used when initial connect fails and reconnect is enabled.
+     * Create a disconnected stub connection, for a failed initial connect: one
+     * that will reconnect in the background (its caller schedules that), or one
+     * that owns a launch that couldn't be reaped.
      * @internal
      */
     private static createDisconnectedStub;
+    /**
+     * Keep a launch whose cleanup couldn't confirm its child exited, and halt
+     * reconnecting: another launch could run beside one that's still alive.
+     * close() retries the reap.
+     */
+    private holdUnreaped;
+    /** The halt, as a reconnect event's failure text. */
+    private unreapedFailure;
     /** Send `context/beforeInference` and await result. */
     sendBeforeInference(params: BeforeInferenceParams): Promise<BeforeInferenceResult>;
     /** RFC-006 deferred push rendering; its own timeout bounds context assembly. */
@@ -258,8 +540,10 @@ export declare class McplServerConnection extends EventEmitter {
      * — the caller leaves the grant empty and the connection MCP-only.
      */
     sendFeatureSetsUpdateRequest(params: FeatureSetsUpdateParams, timeoutMs?: number): Promise<FeatureSetsUpdateResult>;
-    /** Send `inference/chunk` notification. */
-    sendInferenceChunk(params: InferenceChunkParams): void;
+    /** Send `inference/chunk` notification, on the transport `epoch` names: a
+     *  chunk of a request from a transport that has closed goes nowhere, as
+     *  that request's answer does. */
+    sendInferenceChunk(params: InferenceChunkParams, epoch?: number): void;
     /** Send `inference/lifecycle` notification (§10.5). Best-effort. */
     sendInferenceLifecycle(params: InferenceLifecycleParams): void;
     /** Send `tools/lifecycle` notification (RFC-007). Best-effort. The
@@ -275,7 +559,10 @@ export declare class McplServerConnection extends EventEmitter {
     sendManifestRequest(timeoutMs?: number): Promise<McplCapabilities | null>;
     /** Send `state/rollback` request and await result. */
     sendStateRollback(params: StateRollbackParams): Promise<StateRollbackResult>;
-    /** Send `channels/open` request and await result. */
+    /** Send `channels/open` request and await result. It keeps a deadline as
+     *  channels/publish does: a delivery opens a closed channel before it
+     *  publishes, so an open that is never answered would hold the delivery,
+     *  and the turn that waits for it, for good. */
     sendChannelsOpen(params: ChannelsOpenParams): Promise<ChannelsOpenResult>;
     /** Send `channels/close` request and await result. */
     sendChannelsClose(params: ChannelsCloseParams): Promise<ChannelsCloseResult>;
@@ -287,6 +574,12 @@ export declare class McplServerConnection extends EventEmitter {
      * Send `channels/publish`.
      * May be sent as a request (if an ACK is desired) or notification.
      * When `params.stream` is true, sends as a notification (no ACK).
+     *
+     * A request always has a deadline: the server's requestTimeoutMs, or
+     * publishDeadlineMs when that is 0 (disabled). A publish is a side effect
+     * whose outcome the resident is told and a held draft's attempt records,
+     * so one that is never answered would hold both open for good. Its expiry
+     * is a no-response, which the caller reads as unknown.
      */
     sendChannelsPublish(params: ChannelsPublishParams): Promise<ChannelsPublishResult | void>;
     /** Send `channels/outgoing/chunk` notification. */
@@ -301,7 +594,16 @@ export declare class McplServerConnection extends EventEmitter {
      *  `op` defaults to 'start'; pass 'stop' to clear an active indicator
      *  immediately rather than waiting for server-side auto-expire. */
     sendChannelsTyping(channelId: string, metadata?: Record<string, unknown>, op?: 'start' | 'stop'): void;
-    /** Send `tools/list` and return the server's tool definitions. */
+    /**
+     * Send `tools/list` and return the server's complete tool inventory,
+     * following `nextCursor` across pages (2024-11-05 pagination). Cursors are
+     * opaque strings, `''` included: only an absent or null `nextCursor` ends
+     * the inventory (a null one is how some servers say "no more", and main
+     * read it as a complete page). A page that isn't well formed (no `tools` array, a cursor
+     * that isn't a string), or cursors that don't terminate (a repeat, or more
+     * than {@link MAX_TOOL_LIST_PAGES} pages), are errors, never a partial or
+     * empty inventory published as complete.
+     */
     sendToolsList(): Promise<{
         tools: McpToolDefinition[];
     }>;
@@ -316,13 +618,35 @@ export declare class McplServerConnection extends EventEmitter {
      * force even when the server's general requestTimeoutMs is configured as 0.
      */
     sendToolsCallWithDeadline(name: string, args: Record<string, unknown>, timeoutMs: number): Promise<McpToolCallResult>;
-    /** Close the connection: disable reconnect, kill the child process, and clean up resources. */
+    /** The requests still waiting for an answer, for the operator's log line
+     *  when the connection goes: their methods and ids. */
+    private unansweredRequests;
+    /**
+     * Close the connection for good: disable reconnect, kill the child
+     * process, and clean up resources. At once, as before, reconnecting stops
+     * and pending requests fail; a reconnect handshake in flight is aborted.
+     *
+     * Calls share one attempt: while it is pending, and once it has
+     * succeeded, close() returns it. The attempt waits for the aborted
+     * reconnect's own cleanup, closes the transport (its close is the reaping
+     * verdict) and retries each launch an earlier cleanup couldn't reap. It
+     * rejects while any child can't be confirmed exited, with that failure
+     * itself, or an AggregateError when there are several. A failed attempt is
+     * cleared, so the next close() retries what it couldn't reap. 'close' is
+     * emitted once, when the teardown of a connection the host closed while
+     * live completes.
+     */
     close(): Promise<void>;
+    /** One close attempt. `heldBefore` are the launches earlier cleanups
+     *  couldn't reap, which it retries. */
+    private closeStep;
     /**
      * Tear down a live transport after an awareness-accounting failure without
      * disabling configured auto-reconnect. The normal transport close handler
      * rejects requests, emits lifecycle state, and schedules the next bounded
-     * reconnect attempt. With reconnect disabled this leaves the server closed.
+     * reconnect attempt. With reconnect disabled the recycle ends the
+     * connection for good, as close() does: 'close' comes once the child's
+     * exit is confirmed, and a child it can't reap stays owned, holding the id.
      */
     reconnectAfterFailure(): Promise<void>;
     /** 'close' payload for a host-initiated teardown (no transport close code). */
@@ -342,9 +666,16 @@ export declare class McplServerConnection extends EventEmitter {
      * Attempt to reconnect by opening a fresh transport and performing the
      * handshake, then adopting that transport in place. Unlike the previous
      * approach this builds no throwaway connection instance, so there are no
-     * leaked listeners on a dead object.
+     * leaked listeners on a dead object. The attempt is close()'s to abort,
+     * and it settles only once its own launch is adopted, failed or cleaned up.
+     * One attempt at a time: a request that arrives while one is in flight (a
+     * recycle, say) starts nothing, since that attempt either adopts its
+     * launch or schedules the next retry itself. A second attempt would take
+     * close()'s ownership of the first (Iris-1827, room-293 #55410).
      */
     private attemptReconnect;
+    /** One reconnect attempt. It never rejects: each outcome is an event, a
+     *  scheduled retry, or a launch held as unreaped. */
     private reconnectOnce;
     /**
      * Send a JSON-RPC request and return a promise that resolves with the result
@@ -394,6 +725,46 @@ export declare class McplServerConnection extends EventEmitter {
      * Wire up the transport's line stream to route incoming JSON-RPC messages.
      */
     private setupMessageRouting;
+    /** Contain synchronous dispatch failures; async RPC handlers own their promises. */
+    private dispatchMessage;
+    /**
+     * A request's responder, bound to the transport it came on (`epoch`): an
+     * answer, or a streamed inference's chunk, sent after that transport has
+     * closed reaches nothing, never a server that didn't ask it.
+     */
+    private responderFor;
+    /**
+     * A request or notification read from a transport after its boundary has
+     * passed: the boundary's rule (resetPolicyForTransportBoundary). An
+     * incoming message or push is held as kept, for the next transport's
+     * grant, and any other is dropped and logged. (A response read then goes to
+     * handleResponse, flagged late.) A stdio
+     * server's transport closes on the child's 'exit', when its stdout may
+     * still be open, as it is while a process the server started holds it, and
+     * it is read until the next reconnect attempt closes its reader. No
+     * transport serves meanwhile, so what is held waits for the next grant
+     * (flushHeld). A connection closed for good, which won't reconnect, reads
+     * it while its writer lives, with no grant to come, so it drops and logs
+     * all of it; hold's bounds cap what any other keeps.
+     */
+    private afterBoundary;
+    /** Live delivery and delayed plane flushes share the same containment boundary. */
+    private dispatchInboundEvent;
+    /** Report a failure the containment boundary caught, naming the event (or
+     *  method) and request it was dispatching, and what failed. The message is
+     *  what the framework's 'error' listener traces. */
+    private reportInboundFailure;
+    /**
+     * Give an error to the connection's 'error' listeners, and say whether it
+     * has any. EventEmitter throws an 'error' that nothing listens for, and
+     * from a transport's callback, where these errors arise, nothing catches
+     * that throw, so it ends the process. A bare connection has no listener:
+     * the class is exported, and a probe, a playtest or a harness often attaches
+     * none. So with no listener, the error is the caller's to log, unless it
+     * already has. A listener that throws is caught and logged, with the error
+     * it was handling.
+     */
+    private emitToErrorListeners;
     /**
      * Handle a JSON-RPC response by resolving/rejecting the corresponding pending request.
      */
@@ -402,6 +773,10 @@ export declare class McplServerConnection extends EventEmitter {
      * Send a successful JSON-RPC response back to the server.
      */
     private sendResponse;
+    /** Whether a response to a request received on `epoch` may go out now.
+     *  The id is the server's, so it's logged as a field; `answer`, which the
+     *  caller has formatted for the log, ends the line. */
+    private sameTransport;
     /**
      * Send a JSON-RPC error response back to the server.
      */

package/dist/src/mcpl/server-connection.d.ts.map

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