@animalabs/agent-framework 0.23.3 → 0.24.1

package/dist/src/mcpl/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mcpl/index.ts"],"names":[],"mappings":"AAyFA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,4BAA4B;AAC5B,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,iCAAiC;AACjC,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAGnI,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,kBAAkB,EAA4B,MAAM,sBAAsB,CAAC;AAEpF,4CAA4C;AAC5C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAElF,qDAAqD;AACrD,OAAO,EAAE,YAAY,EAAyB,MAAM,oBAAoB,CAAC;AAEzE,8DAA8D;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,YAAY,EACZ,UAAU,EACV,UAAU,EACV,uBAAuB,EACvB,mBAAmB,GAOpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,GAIZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,0BAA0B;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,0CAA0C;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,6EAA6E;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,4EAA4E;AAC5E,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAQ7F,6DAA6D;AAC7D,2HAA2H;AAC3H,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAYtF,8DAA8D;AAC9D,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mcpl/index.ts"],"names":[],"mappings":"AAyFA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,4BAA4B;AAC5B,OAAO,EACL,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,iCAAiC;AACjC,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAGnI,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,kBAAkB,EAA4B,MAAM,sBAAsB,CAAC;AAEpF,4CAA4C;AAC5C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAElF,qDAAqD;AACrD,OAAO,EAAE,YAAY,EAAyB,MAAM,oBAAoB,CAAC;AAEzE,8DAA8D;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,YAAY,EACZ,UAAU,EACV,UAAU,EACV,uBAAuB,EACvB,mBAAmB,GAOpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,GAIZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,0BAA0B;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,0CAA0C;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,6EAA6E;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,6EAA6E;AAC7E,+CAA+C;AAC/C,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAQ/G,6DAA6D;AAC7D,2HAA2H;AAC3H,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAYtF,8DAA8D;AAC9D,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/src/mcpl/log-value.d.ts

@@ -49,6 +49,12 @@ export declare function logValue(value: unknown): string;
  * text holds nothing `redact` replaces prints exactly as logValue prints it.
  */
 export declare function logValueRedacted(value: unknown, redact: (text: string) => string): string;
+/**
+ * A JSON-RPC error answer's code as a log line prints it: a number, as
+ * JSON-RPC says a code is, as logValue prints it; any other JSON value a
+ * server sends there redacted (logValueRedacted), since the server wrote it.
+ */
+export declare function loggedCode(code: unknown, redact: (text: string) => string): string;
 /**
  * The host's own message, as the free text that ends a log line after its
  * fields: `reason=coalesce-invalid field=payload.content: "content must be an

package/dist/src/mcpl/log-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-value.d.ts","sourceRoot":"","sources":["../../../src/mcpl/log-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAEzF;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEhD"}
+{"version":3,"file":"log-value.d.ts","sourceRoot":"","sources":["../../../src/mcpl/log-value.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAEzF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,MAAM,CAElF;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEhD"}

package/dist/src/mcpl/log-value.js

@@ -53,6 +53,14 @@ export function logValue(value) {
 export function logValueRedacted(value, redact) {
     return printed(redact(textOf(value)), FIELD);
 }
+/**
+ * A JSON-RPC error answer's code as a log line prints it: a number, as
+ * JSON-RPC says a code is, as logValue prints it; any other JSON value a
+ * server sends there redacted (logValueRedacted), since the server wrote it.
+ */
+export function loggedCode(code, redact) {
+    return typeof code === 'number' ? logValue(code) : logValueRedacted(code, redact);
+}
 /**
  * The host's own message, as the free text that ends a log line after its
  * fields: `reason=coalesce-invalid field=payload.content: "content must be an

package/dist/src/mcpl/log-value.js.map

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

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

@@ -48,6 +48,10 @@ export declare class ModernMcpConnection extends EventEmitter {
      *  connect() returns), delivered to the first listener. Bounded: the
      *  newest lines are kept. */
     private stderrBacklog;
+    private redactor?;
+    /** The server's text with its configuration's credentials replaced, for
+     *  the errors this connection hands its caller and its records. */
+    private get recorded();
     private constructor();
     private deliverStderr;
     /** The per-call deadline: `requestTimeoutMs`, validated positive. */
@@ -62,15 +66,18 @@ export declare class ModernMcpConnection extends EventEmitter {
      *  While it's true the connection owns that child, so whatever registered
      *  it keeps its id held; close() retries the reap. It's settled only once
      *  a reap has finished: while a lost session's reap or a close runs, it
-     *  reads false, so read it once lossReaped() or close() has settled. */
+     *  may not read true yet, so read it once lossReaped() or close() has
+     *  settled. */
     get holdsUnreapedChild(): boolean;
     /** The reap of a session lost on its own, settled once it's done, whether
      *  or not it confirmed the child exited (holdsUnreapedChild says which);
      *  settled at once when no such reap is running. */
     lossReaped(): Promise<void>;
     /** A failed generation's cleanup couldn't reap its child: keep owning it,
-     *  and halt reconnecting until close() settles it. */
+     *  and halt reconnecting until close() settles it. It's reported as an
+     *  'error' at once, unless the caller reports it later itself. */
     private holdUnreaped;
+    private reportUnreaped;
     /** The halt, as a permanent failure for the reconnect events. */
     private unreapedFailure;
     /**
@@ -126,7 +133,9 @@ export declare class ModernMcpConnection extends EventEmitter {
     private cancelRelisten;
     private scheduleRelisten;
     private reopenSubscription;
-    /** The transport went away (child exit, or a closed HTTP client). */
+    /** The transport went away (child exit, or a closed HTTP client).
+     *  `unreaped`: the child's pipe failed and it outlived SIGKILL, so its
+     *  launch is already known unreaped. */
     private handleLost;
     /** The legacy engine's backoff: doubling from the base interval, capped,
      *  with ±25% jitter, and never past the timer limit (a longer delay would
@@ -187,9 +196,9 @@ export declare class ModernMcpConnection extends EventEmitter {
      * The rules apply in this order. The call's answer is the server's final
      * one: an error or a `complete` result.
      * - nothing handed to the transport: `not-sent`, whatever was raised (a
-     *   pre-dispatch validation, a signal already aborted, no transport, a send
-     *   Connectome's stdio line refused before writing, an HTTP refusal before
-     *   any request went out);
+     *   pre-dispatch validation, a signal already aborted, no transport, a
+     *   message JSON can't write, a send Connectome's stdio line refused
+     *   before writing);
      * - the most recent leg answered with a JSON-RPC error: `error-response`
      *   with that error's data;
      * - the most recent leg answered with a complete result: the server

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

@@ -1 +1 @@
-{"version":3,"file":"modern-connection.d.ts","sourceRoot":"","sources":["../../../src/mcpl/modern-connection.ts"],"names":[],"mappings":"AAgDA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAUL,KAAK,cAAc,EAMpB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAatE;yEACyE;AACzE,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAoJD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,gBAAgB,EACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,QAAQ,GAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAmC,GAC/D,MAAM,CAKR;AA8HD,qBAAa,mBAAoB,SAAQ,YAAY;IAkC/B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAjC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAG,QAAQ,CAAU;IACpC,QAAQ,CAAC,aAAa,EAAE,OAAO,GAAG,MAAM,CAAC;IACzC,2EAA2E;IAC3E,eAAe,EAAE,MAAM,GAAG,IAAI,CAAQ;IAEtC,OAAO,CAAC,OAAO,CAAwB;IACvC,0DAA0D;IAC1D,OAAO,CAAC,OAAO,CAA0D;IACzE,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,gBAAgB,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAChD,OAAO,CAAC,cAAc,CAA8C;IACpE,OAAO,CAAC,iBAAiB,CAAK;IAC9B,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAA6E;IAC7F,OAAO,CAAC,gBAAgB,CAAK;IAC7B;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAmD;IACnE;gCAC4B;IAC5B,OAAO,CAAC,MAAM,CAA0D;IACxE;;iCAE6B;IAC7B,OAAO,CAAC,aAAa,CAAgB;IAErC,OAAO,eAuBN;IAED,OAAO,CAAC,aAAa;IASrB,qEAAqE;IACrE,IAAI,gBAAgB,IAAI,MAAM,CAE7B;IAED,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,0EAA0E;IAC1E,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;kEAC8D;IAC9D,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;;;4EAIwE;IACxE,IAAI,kBAAkB,IAAI,OAAO,CAEhC;IAED;;wDAEoD;IACpD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAE1B;IAED;0DACsD;IACtD,OAAO,CAAC,YAAY;IAQpB,iEAAiE;IACjE,OAAO,CAAC,eAAe;IAOvB;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,mBAAmB,CAE3D;IAED,0DAA0D;IAC1D,OAAO,CAAC,QAAQ,CAA8B;IAE9C;;;;;;;;;OASG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAErB;YAEa,YAAY;IAqB1B;;;;;OAKG;IACH,OAAa,OAAO,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAU3E;IAED,OAAO,CAAC,SAAS;IAIjB,qEAAqE;YACvD,IAAI;IAoElB,2EAA2E;YAC7D,SAAS;IA+BvB;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IA2BtB;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAYrB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,gBAAgB;YAYV,kBAAkB;IAoBhC,qEAAqE;IACrE,OAAO,CAAC,UAAU;IA0BlB;;gEAE4D;IAC5D,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,iBAAiB;YAQX,gBAAgB;IA4B9B;;;;;;OAMG;IACG,SAAS,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAa9C;IAED;;;;;OAKG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAazF;IAED;;yDAEqD;YACvC,OAAO;IA0BrB;;;;;;OAMG;mBACkB,YAAY;IAWjC,0DAA0D;IAC1D,OAAO,CAAC,OAAO,CAA8B;IAE7C;4DACwD;IACxD,OAAO,CAAC,eAAe,CAAS;IAEhC;;;;;;;;;OASG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAQrB;YAEa,SAAS;IAgDvB;4EACwE;IACxE,OAAO,CAAC,SAAS;IAMjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,OAAO,CAAC,cAAc;CAmIvB"}
+{"version":3,"file":"modern-connection.d.ts","sourceRoot":"","sources":["../../../src/mcpl/modern-connection.ts"],"names":[],"mappings":"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"}

package/dist/src/mcpl/modern-connection.js

@@ -50,9 +50,9 @@ import { EventEmitter } from 'node:events';
 import { Client, InsufficientScopeError, SdkError, SdkErrorCode, SdkHttpError, StreamableHTTPClientTransport, UnsupportedProtocolVersionError, parseJSONRPCMessage, } from '@modelcontextprotocol/client';
 import { StdioTransport } from './transport.js';
 import { McplProtocolVersionError, McplRequestError, McplUnreapedLaunchError } from './server-connection.js';
-import { LEGACY_MCP_PROTOCOL_VERSION, MAX_TIMER_MS, MODERN_MCP_PROTOCOL_VERSION, checkServerConfig, describeCredentialError, noteDialSent, redactServerText, serverTextRedactor } from './protocol-family.js';
+import { LEGACY_MCP_PROTOCOL_VERSION, MAX_TIMER_MS, MODERN_MCP_PROTOCOL_VERSION, checkServerConfig, describeCredentialError, maskedError, noteDialSent, redactServerText, redactedData, serverTextRedactor } from './protocol-family.js';
 import { boundedForLog } from './errors.js';
-import { logDetail, logValue, logValueRedacted } from './log-value.js';
+import { logDetail, logValue, logValueRedacted, loggedCode } from './log-value.js';
 const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
 /** Bound on establishing the connection (`server/discover`), like the legacy
  *  engine's initialize timeout. */
@@ -78,6 +78,11 @@ class NotWrittenError extends Error {
 /** The logical request a send belongs to. The SDK hands each request to the
  *  transport inside the caller's async chain, so the scope reaches `send`. */
 const wireScope = new AsyncLocalStorage();
+/** A send in flight, its transport, and what that transport reported
+ *  meanwhile, held until the send settles (ObservedTransport.send). A
+ *  scope that names no transport, a notification's or a settled send's,
+ *  holds nothing. */
+const sendScope = new AsyncLocalStorage();
 /**
  * The boundary between the SDK and the actual transport. It records, for the
  * logical request in scope, each request of the observed method that it
@@ -117,14 +122,36 @@ class ObservedTransport {
             else
                 this.onmessage?.(message, extra);
         };
-        this.inner.onerror = (error) => this.onerror?.(error);
+        // An error this transport reports while one of its sends is in flight
+        // waits for that send to settle: the SDK's HTTP send reports a failure
+        // here and then throws it, and whoever sent it reports what it throws
+        // (#556). Anything else is reported at once, another transport's report
+        // made in a send's async context too.
+        this.inner.onerror = (error) => {
+            const sending = sendScope.getStore();
+            if (sending?.wire === this)
+                sending.held.push(error);
+            else
+                this.onerror?.(error);
+        };
         this.inner.onclose = () => this.onclose?.();
         await this.inner.start();
     }
     async send(message, options) {
+        if ('method' in message && !('id' in message)) {
+            // A notification's sender can swallow what its send throws (the SDK's
+            // listen teardown does), so what its transport reports is reported at
+            // once, whatever send it was made in.
+            await sendScope.run({ wire: null, held: [] }, () => this.inner.send(message, options));
+            return;
+        }
         const record = wireScope.getStore();
         let undo;
         if (record && 'method' in message && 'id' in message && message.method === record.method) {
+            // Every transport writes a message as JSON, so one JSON can't write (a
+            // BigInt, a cycle) never leaves this host: it's refused here, before
+            // it's marked handed off (#556).
+            JSON.stringify(message);
             const prior = { handedOff: record.handedOff, currentId: record.currentId, answer: record.answer, error: record.error };
             // Handed off from here on: past this point nothing proves it unsent,
             // unless the transport says it wrote nothing.
@@ -138,10 +165,17 @@ class ObservedTransport {
                 Object.assign(record, prior);
             };
         }
+        // A request's or a response's sender reports what its send throws: a
+        // call through its outcome, the connect through its failure, the SDK
+        // through its own report. So what the transport reports meanwhile is held
+        // here, and the failure the send threw isn't reported a second time (#556).
+        const sending = { wire: this, held: [] };
+        let thrown;
         try {
-            await this.inner.send(message, options);
+            await sendScope.run(sending, () => this.inner.send(message, options));
         }
         catch (error) {
+            thrown = error;
             // Refused before any write: this leg never reached the server, so the
             // record is as it was before it. Any other throw (an HTTP send can fail
             // after part of the request went out) leaves it handed off.
@@ -149,6 +183,17 @@ class ObservedTransport {
                 undo?.();
             throw error;
         }
+        finally {
+            // Settled: what was held goes on, but for the failure the send threw,
+            // and the scope lets go of this transport, which work the send started
+            // still carries.
+            const { held } = sending;
+            sending.wire = null;
+            sending.held = [];
+            for (const error of held)
+                if (error !== thrown)
+                    this.onerror?.(error);
+        }
     }
     async close() {
         await this.inner.close();
@@ -221,7 +266,7 @@ class SpawnerStdioTransport {
     constructor(config, onStderr, 
     /** The child's pipe failed and it outlived SIGKILL too, so the line
      *  stays open, owning it (the line's 'unreaped'): `reason` names the
-     *  pipe's error. */
+     *  pipe's error, and `failure` is the reap's. */
     onUnreaped) {
         this.config = config;
         this.onStderr = onStderr;
@@ -259,14 +304,19 @@ class SpawnerStdioTransport {
         line.on('stderr', (text) => this.onStderr(text));
         line.on('error', (error) => this.onerror?.(error));
         line.on('close', () => this.onclose?.());
-        line.on('unreaped', () => this.onUnreaped(`its stdio pipe failed with ${line.pipeFailure?.message ?? 'an error'}`));
+        line.on('unreaped', (failure) => this.onUnreaped(`its stdio pipe failed with ${line.pipeFailure?.message ?? 'an error'}`, failure));
+    }
+    /** The first error on the child's stdin or stdout, once there is one: the
+     *  line is ending the child then, and writes nothing more to it. */
+    get pipeFailure() {
+        return this.line?.pipeFailure;
     }
     async send(message) {
         if (!this.line || this.line.closed)
             throw new NotWrittenError(`MCP server "${this.config.id}" stdio transport is closed`);
         // Once the child's stdin or stdout has failed, the line is ending it and
         // writes nothing more to it, so a message is refused here as not sent.
-        const failed = this.line.pipeFailure;
+        const failed = this.pipeFailure;
         if (failed)
             throw new NotWrittenError(`MCP server "${this.config.id}" stdio pipe failed with ${failed.message}`, true);
         this.line.writeLine(JSON.stringify(message));
@@ -347,6 +397,12 @@ export class ModernMcpConnection extends EventEmitter {
      *  connect() returns), delivered to the first listener. Bounded: the
      *  newest lines are kept. */
     stderrBacklog = [];
+    redactor;
+    /** The server's text with its configuration's credentials replaced, for
+     *  the errors this connection hands its caller and its records. */
+    get recorded() {
+        return (this.redactor ??= serverTextRedactor(this.config));
+    }
     constructor(config) {
         super();
         this.config = config;
@@ -404,7 +460,8 @@ export class ModernMcpConnection extends EventEmitter {
      *  While it's true the connection owns that child, so whatever registered
      *  it keeps its id held; close() retries the reap. It's settled only once
      *  a reap has finished: while a lost session's reap or a close runs, it
-     *  reads false, so read it once lossReaped() or close() has settled. */
+     *  may not read true yet, so read it once lossReaped() or close() has
+     *  settled. */
     get holdsUnreapedChild() {
         return this.unreaped.length > 0;
     }
@@ -415,11 +472,16 @@ export class ModernMcpConnection extends EventEmitter {
         return this.losing?.done ?? Promise.resolve();
     }
     /** A failed generation's cleanup couldn't reap its child: keep owning it,
-     *  and halt reconnecting until close() settles it. */
-    holdUnreaped(session, failure) {
+     *  and halt reconnecting until close() settles it. It's reported as an
+     *  'error' at once, unless the caller reports it later itself. */
+    holdUnreaped(session, failure, report = true) {
         if (this.unreaped.some((held) => held.session === session))
             return;
         this.unreaped.push({ session, failure });
+        if (report)
+            this.reportUnreaped(failure);
+    }
+    reportUnreaped(failure) {
         this.emit('error', new Error(`MCP server "${this.id}": ${failure.message}. Not starting another launch while it may still be running; close the connection to retry the reap.`));
     }
     /** The halt, as a permanent failure for the reconnect events. */
@@ -467,11 +529,17 @@ export class ModernMcpConnection extends EventEmitter {
                 this.reconnectEnabled = false;
                 throw error;
             }
+            // Any other failure is the SDK's or the transport's: it goes on as its
+            // words alone, redacted, since its message can quote the url and its
+            // other properties, such as Bun's fetch error's `path` or a wrapper's
+            // `cause`, can carry it whole (maskedError). The protocol refusal
+            // above was built from redacted words.
+            const masked = maskedError(error, this.recorded);
             // A launch that couldn't be reaped halts reconnecting, so no retry
             // will come: the first connect fails, as one without reconnect does.
             if (!this.reconnectEnabled || this.holdsUnreapedChild)
-                throw error;
-            console.error(`MCP server "${this.id}" initial connect failed, will retry:`, redactServerText(error.message, this.config));
+                throw masked;
+            console.error(`MCP server "${this.id}" initial connect failed, will retry:`, masked.message);
             this.reconnectAttempts = 1;
             this.emit('connect-failed', { error: error.message, attempt: 0 });
             this.scheduleReconnect();
@@ -510,16 +578,18 @@ export class ModernMcpConnection extends EventEmitter {
         // reopen backs off from the base interval, not from the previous
         // generation's failures.
         this.relistenAttempts = 0;
-        const inner = this.transportKind === 'stdio'
+        const stdio = this.transportKind === 'stdio'
             ? new SpawnerStdioTransport(this.config, (line) => { if (this.isCurrent(generation))
                 this.deliverStderr(line); }, 
-            // A child whose pipe failed and that outlived SIGKILL: a loss, whose
-            // reap finds the child still running and holds the launch, as for any
-            // launch it can't reap. During a connect there is no session to lose
-            // yet: the connect's own cleanup holds it, once the connect fails.
-            (reason) => { if (this.isCurrent(generation))
-                this.handleLost(generation, reason); })
-            : new StreamableHTTPClientTransport(new URL(this.config.url), { authProvider: bearerAuth(this.config) });
+            // A child whose pipe failed and that outlived SIGKILL: a loss whose
+            // launch is already known unreaped, so it's held as the loss is
+            // handled (handleLost). During a connect there is no session to lose
+            // yet: a connect whose pipe has failed fails, whether or not the SDK
+            // resolves it (establish), and its cleanup holds the launch.
+            (reason, failure) => { if (this.isCurrent(generation))
+                this.handleLost(generation, reason, failure); })
+            : null;
+        const inner = stdio ?? new StreamableHTTPClientTransport(new URL(this.config.url), { authProvider: bearerAuth(this.config) });
         const wire = new ObservedTransport(inner);
         const client = new Client({ name: 'agent-framework', version: '1.0.0' }, {
             versionNegotiation: { mode: { pin: MODERN_MCP_PROTOCOL_VERSION } },
@@ -535,7 +605,7 @@ export class ModernMcpConnection extends EventEmitter {
                 },
             },
         });
-        const session = { generation, client, wire, lost: false };
+        const session = { generation, client, wire, stdio, lost: false };
         client.onerror = (error) => {
             // The SDK reports late responses to deadline-abandoned calls here
             // ("unknown message ID"), and a list-change subscription it could not
@@ -585,17 +655,24 @@ export class ModernMcpConnection extends EventEmitter {
                 this.holdUnreaped(session, failure);
             return;
         }
-        if (session.lost) {
-            // The transport closed while the client connected, such as a child
-            // that exited at the connect-time list-change subscribe: the SDK
-            // reports that subscribe's failure only as an error, and resolves the
-            // connect anyway (R1-2). Adopted, the session would read as connected
-            // with nothing behind it, and no later close would come to reconnect
-            // it. So the connect failed.
+        // The transport closed while the client connected, such as a child that
+        // exited at the connect-time list-change subscribe, or the child's stdio
+        // pipe failed, such as that subscribe's write meeting EPIPE: the SDK
+        // reports the subscribe's failure only as an error, and resolves the
+        // connect anyway (R1-2). Adopted, the session would read as connected
+        // with nothing it can write to behind it, and from a child that outlived
+        // SIGKILL, whose 'unreaped' came while there was no session to lose, no
+        // later close would come to reconnect it. So the connect failed: its
+        // close reaps the child, and a child it can't reap is held. A failed
+        // pipe is named whether or not the child has exited by now.
+        const pipe = session.stdio?.pipeFailure;
+        if (session.lost || pipe) {
             const failure = await ModernMcpConnection.closeSession(session);
             if (failure)
                 this.holdUnreaped(session, failure);
-            throw new Error(`MCP server "${this.id}" closed its connection while connecting`);
+            throw new Error(pipe
+                ? `MCP server "${this.id}" stdio pipe failed with ${pipe.message} while connecting`
+                : `MCP server "${this.id}" closed its connection while connecting`);
         }
         this.session = session;
         this.protocolVersion = MODERN_MCP_PROTOCOL_VERSION;
@@ -611,7 +688,11 @@ export class ModernMcpConnection extends EventEmitter {
     versionVerdict(error) {
         if (!(error instanceof UnsupportedProtocolVersionError))
             return null;
-        const data = error.data;
+        // The server's words and data, redacted before they're bounded or kept:
+        // the error goes to the host. One build for all of them, so a
+        // configuration that can't be read is read once.
+        const redact = this.recorded.now();
+        const data = redactedData(error.data, redact);
         const supported = Array.isArray(data?.supported) && data.supported.every((v) => typeof v === 'string')
             ? data.supported
             : null;
@@ -624,8 +705,8 @@ export class ModernMcpConnection extends EventEmitter {
                 ? ` It speaks legacy MCP: configure it without protocol: 'modern'.`
                 : ` It speaks only legacy MCP, which this client reaches over stdio or WebSocket (ws://, wss://), not http(s).`;
         return new McplProtocolVersionError(`MCP server "${this.id}" does not support MCP ${MODERN_MCP_PROTOCOL_VERSION}` +
-            (supported ? ` (it supports: ${supported.join(', ') || 'none listed'}).` : ` (${error.message}).`) +
-            legacyHint, 'rejected', null, supported, error.code === undefined ? undefined : Number(error.code), error.data, MODERN_MCP_PROTOCOL_VERSION);
+            (supported ? ` (it supports: ${boundedForLog(supported.join(', ')) || 'none listed'}).` : ` (${boundedForLog(redact(error.message))}).`) +
+            legacyHint, 'rejected', null, supported, error.code === undefined ? undefined : Number(error.code), data, MODERN_MCP_PROTOCOL_VERSION);
     }
     /**
      * Keep list-change awareness while this generation lives. The SDK opens the
@@ -690,8 +771,10 @@ export class ModernMcpConnection extends EventEmitter {
             this.scheduleRelisten(generation);
         }
     }
-    /** The transport went away (child exit, or a closed HTTP client). */
-    handleLost(generation, reason) {
+    /** The transport went away (child exit, or a closed HTTP client).
+     *  `unreaped`: the child's pipe failed and it outlived SIGKILL, so its
+     *  launch is already known unreaped. */
+    handleLost(generation, reason, unreaped) {
         const session = this.session;
         if (session?.generation !== generation)
             return;
@@ -704,21 +787,42 @@ export class ModernMcpConnection extends EventEmitter {
         // reconnect's does, and is a permanent failure, as that one is: no
         // later attempt will come. The reap starts, and is recorded, before
         // 'close' is emitted, so a listener that throws can't skip it.
+        const permanent = () => this.emit('reconnect-failed', { error: `${reason}; ${this.unreapedFailure()}`, attempt: Math.max(1, this.reconnectAttempts), permanent: true });
         const done = ModernMcpConnection.closeSession(session).then((failure) => {
             if (this.losing?.session === session)
                 this.losing = null;
+            // A close() the host made meanwhile reports the failure itself.
+            if (unreaped) {
+                // Held as the loss was handled, whatever the reap found now.
+                if (!this.closedByHost)
+                    permanent();
+                return;
+            }
             if (failure) {
                 this.holdUnreaped(session, failure);
-                // A close() the host made meanwhile reports the failure itself.
-                if (!this.closedByHost) {
-                    this.emit('reconnect-failed', { error: `${reason}; ${this.unreapedFailure()}`, attempt: Math.max(1, this.reconnectAttempts), permanent: true });
-                }
+                if (!this.closedByHost)
+                    permanent();
             }
             else if (this.willReconnect)
                 this.scheduleReconnect();
         });
         this.losing = { session, done };
-        this.emit('close', { reason });
+        // A launch already known unreaped is held now, before 'close', so the
+        // calls the reap's close ends, which classify their failure only once
+        // this returns, and any made meanwhile, read that this host won't
+        // reconnect, as the legacy engine has it (#540's review, R1-1). It's
+        // reported after 'close', which is where the other route reports a hold
+        // too, whatever the 'close' listeners do, so a listener that throws can
+        // skip neither 'close' nor the report.
+        if (unreaped)
+            this.holdUnreaped(session, unreaped, false);
+        try {
+            this.emit('close', { reason });
+        }
+        finally {
+            if (unreaped)
+                this.reportUnreaped(unreaped);
+        }
     }
     /** The legacy engine's backoff: doubling from the base interval, capped,
      *  with ±25% jitter, and never past the timer limit (a longer delay would
@@ -944,9 +1048,9 @@ export class ModernMcpConnection extends EventEmitter {
      * The rules apply in this order. The call's answer is the server's final
      * one: an error or a `complete` result.
      * - nothing handed to the transport: `not-sent`, whatever was raised (a
-     *   pre-dispatch validation, a signal already aborted, no transport, a send
-     *   Connectome's stdio line refused before writing, an HTTP refusal before
-     *   any request went out);
+     *   pre-dispatch validation, a signal already aborted, no transport, a
+     *   message JSON can't write, a send Connectome's stdio line refused
+     *   before writing);
      * - the most recent leg answered with a JSON-RPC error: `error-response`
      *   with that error's data;
      * - the most recent leg answered with a complete result: the server
@@ -982,7 +1086,10 @@ export class ModernMcpConnection extends EventEmitter {
     requestFailure(what, record, error, timeoutMs, lost = false) {
         const server = `the "${this.id}" server`;
         const Server = `The "${this.id}" server`;
-        const message = redactServerText(error instanceof Error ? error.message : String(error), this.config);
+        // One build of the redactor for all of this failure's texts, so a
+        // configuration that can't be read is read once.
+        const redact = this.recorded.now();
+        const message = redact(error instanceof Error ? error.message : String(error));
         const log = (line) => console.error(`MCP server "${this.id}" ${line}`);
         const listing = record.method === 'tools/list';
         // What a failure whose effect is in doubt says: for a tool call, that the
@@ -1003,15 +1110,18 @@ export class ModernMcpConnection extends EventEmitter {
         }
         if (record.answer === 'error' && record.error) {
             const { code, message: wireMessage, data } = record.error;
-            // A JSON-RPC answer reaches the caller unredacted (redactServerText's
-            // scope). The log is a record of the server's text, so the message is
-            // redacted there, whatever JSON value it is, as every other line this
-            // connection writes is.
-            log(`answered ${what} with error ${logValue(code)}: ${logValueRedacted(wireMessage, (text) => redactServerText(text, this.config))}`);
-            // The server's own words, bounded as errors.ts says. Only a string is
-            // words: a message of any other JSON value reads as none.
-            const said = typeof wireMessage === 'string' ? boundedForLog(wireMessage.trim()) : '';
-            return new McplRequestError(said ? `${Server} answered with an error: ${said}` : unknown(`${Server} answered with an error without saying what went wrong`), 'error-response', data);
+            // The log is a record of the server's text, so the code (loggedCode)
+            // and the message are redacted there, whatever JSON values they are,
+            // as every other line this connection writes is.
+            log(`answered ${what} with error ${loggedCode(code, redact)}: ${logValueRedacted(wireMessage, redact)}`);
+            // The server's own words, redacted and then bounded as errors.ts says,
+            // since they're in an error the caller gets (redactServerText's
+            // scope), and its data's strings redacted too. It's trimmed after it's
+            // redacted, so a credential that ends in a space is whole when it's
+            // matched. Only a string is words: a message of any other JSON value
+            // reads as none.
+            const said = typeof wireMessage === 'string' ? boundedForLog(redact(wireMessage).trim()) : '';
+            return new McplRequestError(said ? `${Server} answered with an error: ${said}` : unknown(`${Server} answered with an error without saying what went wrong`), 'error-response', redactedData(data, redact));
         }
         if (record.answer === 'complete') {
             log(`answered ${what} with a result this host can't use: ${logDetail(message)}`);
@@ -1050,7 +1160,12 @@ export class ModernMcpConnection extends EventEmitter {
             // The response body (the SDK's `text`) is the server's text and can
             // echo the request's url, so it's left out of the data; the status stays.
             const { text: _body, ...data } = (error instanceof SdkHttpError && error.data && typeof error.data === 'object' ? error.data : {});
-            return new McplRequestError(`${Server} refused this host access, so the request didn't run. If you need it, ask whoever runs this host.`, 'error-response', { ...data, httpStatus: refusedWith });
+            const redacted = redactedData(data, redact);
+            return new McplRequestError(`${Server} refused this host access, so the request didn't run. If you need it, ask whoever runs this host.`, 'error-response', 
+            // The status is this host's own, so it's added after the server's
+            // data is redacted, and it stays when a configuration that can't be
+            // read withholds that data.
+            { ...(redacted !== null && typeof redacted === 'object' ? redacted : {}), httpStatus: refusedWith });
         }
         if (deadline) {
             log(`didn't answer ${what}${within}; cancellation requested`);