@mcp-abap-adt/connection 8.0.1 → 8.1.0

package/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [8.1.0] - 2026-09-21
+
+**The RFC wire can be asked for its payload, and what it logs is safe to
+paste.** `RFC → METHOD URI` did not show a body that goes missing or gets
+mis-serialised before it reaches `SADT_REST_RFC_ENDPOINT`. Nothing existing
+changes: the channel is off until asked for.
+
+### Added
+
+- `RfcTransport` can be asked to log the wire: a third constructor argument
+  `{ logWire?, maxLoggedBodyChars? }`, off by default, adds the request header
+  fields, the request body and the response body to the debug channel. This is
+  what shows a payload that was mis-serialised before it reached
+  `SADT_REST_RFC_ENDPOINT`. Credential header values (`Authorization`, any
+  `Cookie`, anything matching `token`, `secret`, `password`, `credential` or an
+  API key) are replaced with `[redacted]` — the names are kept — and a body is
+  clipped at `maxLoggedBodyChars`, 2000 by default — `0` logs the size alone,
+  `Infinity` asks for the whole body, and a negative or `NaN` ceiling falls
+  back to the default rather than throwing. Bodies are not redacted, only
+  clipped.
+
+  It is a flag rather than something inferred from the presence of a logger
+  because `ILogger` carries no level predicate: `logger?.debug()` cannot tell
+  an enabled debug channel from one that discards, so without the flag every
+  caller passing a logger would build a copy of every body on the wire and
+  throw it away. `HttpTransport` logs no bodies at any setting.
+
 ## [8.0.1] - 2026-09-08
 
 **Documentation only — 7.0.0 and 8.0.0 shipped without their migration note.**
@@ -1535,6 +1562,7 @@ const connection = createAbapConnection(config, logger);
 - Permission errors (403 with "ExceptionResourceNoAccess") no longer trigger JWT refresh loops
 - Proper separation: base class handles HTTP/session, concrete classes handle auth-specific errors
 [Unreleased]: https://github.com/fr0ster/mcp-abap-connection/compare/v8.0.1...HEAD
+[8.1.0]: https://github.com/fr0ster/mcp-abap-connection/compare/v8.0.1...v8.1.0
 [8.0.1]: https://github.com/fr0ster/mcp-abap-connection/compare/v8.0.0...v8.0.1
 [8.0.0]: https://github.com/fr0ster/mcp-abap-connection/compare/v7.0.0...v8.0.0
 [7.0.0]: https://github.com/fr0ster/mcp-abap-connection/compare/v6.1.0...v7.0.0

package/README.md

@@ -656,6 +656,20 @@ const connection = new AdtOnPremConnector(
 );
 ```
 
+A third argument turns on the wire log, which is off by default:
+
+```typescript
+new RfcTransport(rfcConversationFrom(config), logger, { logWire: true });
+```
+
+It adds three debug lines per request — header fields, request body, response
+body — which is how you see that a payload was mis-serialised before it reached
+`SADT_REST_RFC_ENDPOINT`. Credential header values are replaced with
+`[redacted]` and bodies are clipped at `maxLoggedBodyChars` (2000). The bodies
+themselves are not redacted, so read a captured log before pasting it into an
+issue. `HttpTransport` never logs bodies, so this is the one wire whose debug
+channel can be asked for the payload.
+
 #### `CSRF_CONFIG` and `CSRF_ERROR_MESSAGES`
 
 **New in 0.1.13+:** Exported constants for consistent CSRF token handling across different connection implementations.

package/dist/connection/RfcTransport.d.ts

@@ -26,9 +26,29 @@ export interface IRfcConversation {
     call(fm: string, params: Record<string, unknown>): Promise<Record<string, any>>;
     readonly alive: boolean;
 }
+/** What this wire does beyond carrying the request. */
+export interface IRfcTransportOptions {
+    /**
+     * Whether the debug channel also carries the request headers and both
+     * bodies. Off by default, and deliberately not inferred from the presence
+     * of a logger: `ILogger` has no level predicate, so `logger?.debug()` cannot
+     * tell an enabled debug channel from a discarded one — without this flag
+     * every caller who passes a logger at all would pay to build and throw away
+     * a copy of every body on the wire.
+     */
+    logWire?: boolean;
+    /**
+     * Ceiling on a logged body, in characters. Defaults to 2000. `0` logs the
+     * size and none of the bytes, `Infinity` asks for the whole body, and a
+     * negative or `NaN` value falls back to the default rather than throwing —
+     * a debug option is not worth failing a connection over.
+     */
+    maxLoggedBodyChars?: number;
+}
 export declare class RfcTransport implements IOnPremTransport {
     private readonly connect;
     private readonly logger;
+    private readonly options;
     readonly kind = "rfc";
     /** Which system this wire is for. Read by the compiler, never at runtime. */
     readonly system: "onprem";
@@ -80,7 +100,9 @@ export declare class RfcTransport implements IOnPremTransport {
      * that reached for it in its constructor could not be built at all on a
      * machine without it.
      */
-    constructor(connect: () => IRfcConversation, logger?: ILogger | null);
+    constructor(connect: () => IRfcConversation, logger?: ILogger | null, options?: IRfcTransportOptions);
+    /** Cut a body down to what a log line may carry. */
+    private clipped;
     open(): Promise<void>;
     /** Never throws, and a repeat call finds nothing owed. */
     close(): Promise<void>;

package/dist/connection/RfcTransport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RfcTransport.d.ts","sourceRoot":"","sources":["../../src/connection/RfcTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,oBAAoB,EAEpB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAE5B,sFAAsF;AACtF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,CACF,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAmCD,qBAAa,YAAa,YAAW,gBAAgB;IA+EjD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IA/EzB,QAAQ,CAAC,IAAI,SAAS;IAEtB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAG,QAAQ,CAAU;IAEpC,OAAO,CAAC,YAAY,CAAiC;IACrD,kEAAkE;IAClE,OAAO,CAAC,cAAc,CAAM;IAE5B;;;;;;OAMG;IACH,MAAM,IAAI,IAAI;IAEd,2CAA2C;IAC3C,OAAO,IAAI,IAAI;IAIf;;;;;OAKG;IACG,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAE9D,+BAA+B;IAC/B,SAAS,IAAI,IAAI;IAIjB;;;OAGG;IACH,cAAc,IAAI,IAAI;IAEtB;;;OAGG;IACH,6EAA6E;IAC7E,kBAAkB,IAAI,OAAO;IAI7B,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAQzC,2EAA2E;IAC3E,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC;;;;OAIG;IACH,aAAa,IAAI,IAAI;IAErB;;;;;OAKG;gBAEgB,OAAO,EAAE,MAAM,gBAAgB,EAC/B,MAAM,GAAE,OAAO,GAAG,IAAW;IAG1C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB3B,0DAA0D;IACpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAatB,IAAI,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CA4I1E"}
+{"version":3,"file":"RfcTransport.d.ts","sourceRoot":"","sources":["../../src/connection/RfcTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EACV,oBAAoB,EAEpB,oBAAoB,EACpB,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,oBAAoB,CAAC;AAE5B,sFAAsF;AACtF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,CACF,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAgFD,uDAAuD;AACvD,MAAM,WAAW,oBAAoB;IACnC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAKD,qBAAa,YAAa,YAAW,gBAAgB;IA+EjD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAhF1B,QAAQ,CAAC,IAAI,SAAS;IAEtB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAG,QAAQ,CAAU;IAEpC,OAAO,CAAC,YAAY,CAAiC;IACrD,kEAAkE;IAClE,OAAO,CAAC,cAAc,CAAM;IAE5B;;;;;;OAMG;IACH,MAAM,IAAI,IAAI;IAEd,2CAA2C;IAC3C,OAAO,IAAI,IAAI;IAIf;;;;;OAKG;IACG,SAAS,CAAC,QAAQ,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;IAE9D,+BAA+B;IAC/B,SAAS,IAAI,IAAI;IAIjB;;;OAGG;IACH,cAAc,IAAI,IAAI;IAEtB;;;OAGG;IACH,6EAA6E;IAC7E,kBAAkB,IAAI,OAAO;IAI7B,kBAAkB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAQzC,2EAA2E;IAC3E,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIzC;;;;OAIG;IACH,aAAa,IAAI,IAAI;IAErB;;;;;OAKG;gBAEgB,OAAO,EAAE,MAAM,gBAAgB,EAC/B,MAAM,GAAE,OAAO,GAAG,IAAW,EAC7B,OAAO,GAAE,oBAAyB;IAGrD,oDAAoD;IACpD,OAAO,CAAC,OAAO;IAcT,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB3B,0DAA0D;IACpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAatB,IAAI,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAkK1E"}

package/dist/connection/RfcTransport.js

@@ -48,11 +48,52 @@ function message(e) {
         return JSON.stringify(e);
     return String(e);
 }
+/**
+ * Header names whose VALUE must never reach a log.
+ *
+ * `Authorization` carries the Basic-auth credential in plain (base64, but that
+ * is not encryption) form — and it is not the only one. `request.headers`
+ * reaches this wire verbatim from the caller, so a consumer's `Cookie`
+ * (`SAP_SESSIONID_*`, `MYSAPSSO2`), an `x-csrf-token` or its own `X-Api-Key`
+ * arrives here too. A log line advertised as safe to paste into an issue has
+ * to be safe for the headers nobody here anticipated, so this matches by
+ * pattern rather than by the list we happened to think of.
+ */
+const SECRET_HEADER_PATTERNS = [
+    /authorization/i,
+    /cookie/i,
+    /token/i,
+    /secret/i,
+    /password/i,
+    /credential/i,
+    /api[-_]?key/i,
+];
+/**
+ * The NAME is kept and only the VALUE goes — a redacted header still says it
+ * was sent, which is half of what the log is read for.
+ */
+function redactHeaders(fields) {
+    return fields.map((field) => SECRET_HEADER_PATTERNS.some((pattern) => pattern.test(field.NAME))
+        ? { ...field, VALUE: '[redacted]' }
+        : field);
+}
+/**
+ * How much of a body a log line carries before it is cut. An ADT payload is
+ * an ABAP source or a repository listing: whole ones are megabytes, and a log
+ * sink handed a single line that size is a problem of its own.
+ */
+const DEFAULT_MAX_LOGGED_BODY_CHARS = 2000;
+function clip(text, max) {
+    return text.length <= max
+        ? text
+        : `${text.slice(0, max)}… (+${text.length - max} more chars)`;
+}
 /** Axios's own default, which the classification above this seam is written against. */
 const admits2xx = (status) => status >= 200 && status < 300;
 class RfcTransport {
     connect;
     logger;
+    options;
     kind = 'rfc';
     /** Which system this wire is for. Read by the compiler, never at runtime. */
     system = 'onprem';
@@ -118,9 +159,22 @@ class RfcTransport {
      * that reached for it in its constructor could not be built at all on a
      * machine without it.
      */
-    constructor(connect, logger = null) {
+    constructor(connect, logger = null, options = {}) {
         this.connect = connect;
         this.logger = logger;
+        this.options = options;
+    }
+    /** Cut a body down to what a log line may carry. */
+    clipped(text) {
+        const asked = this.options.maxLoggedBodyChars ?? DEFAULT_MAX_LOGGED_BODY_CHARS;
+        // A nonsense ceiling is a typo in a debug option, and a debug option is
+        // not worth failing a connection over — but it is worth not honouring. A
+        // negative one reaches `slice(0, -n)`, which drops the END of the body
+        // while the line still says the rest was merely clipped: a log that lies
+        // about what it cut is worse than one that cut too much. `NaN` compares
+        // false against every bound, so the test is for the good case.
+        const ceiling = asked >= 0 ? Math.floor(asked) : DEFAULT_MAX_LOGGED_BODY_CHARS;
+        return clip(text, ceiling);
     }
     async open() {
         if (this.conversation?.alive)
@@ -187,6 +241,19 @@ class RfcTransport {
             });
         }
         this.logger?.debug(`RFC → ${method} ${uri}`);
+        // `RFC → METHOD URI` alone was not enough to debug a body that goes
+        // missing or gets mis-serialised on the way to `SADT_REST_RFC_ENDPOINT`
+        // (found chasing a `superPackage` that disappeared before it reached
+        // SAP) — the actual bytes matter, so the debug channel carries them too
+        // when the caller asks for it, redacted and clipped so a captured log is
+        // safe to paste into an issue and small enough to want to.
+        if (this.logger && this.options.logWire) {
+            this.logger.debug(`RFC HEADERS: ${JSON.stringify(redactHeaders(headerFields))}`);
+            // A GET has no body, and `RFC BODY (0 chars):` says nothing.
+            if (body) {
+                this.logger.debug(`RFC BODY (${body.length} chars): ${this.clipped(body)}`);
+            }
+        }
         // `request.timeout` is deliberately not read, and the absence of the word
         // here is what made that look like an oversight (#42).
         //
@@ -252,6 +319,11 @@ class RfcTransport {
             statusText = statusText || 'OK';
         }
         this.logger?.debug(`RFC ← ${status} ${statusText} (${data.length} bytes)`);
+        // The line above already carries the size, so an empty body needs no line
+        // of its own.
+        if (this.logger && this.options.logWire && data) {
+            this.logger.debug(`RFC RESPONSE BODY: ${this.clipped(data)}`);
+        }
         const response = {
             status,
             statusText,

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { HttpTransport } from './connection/HttpTransport.js';
 export type { IAdtEstablishContext, IAdtSessionContext, IAdtTransport, IAdtTransportRequest, IAdtTransportResponse, ICloudTransport, IOnPremTransport, } from './connection/IAdtTransport.js';
 export { LegacyOnPremHttpTransport } from './connection/LegacyOnPremHttpTransport.js';
 export { OnPremHttpTransport } from './connection/OnPremHttpTransport.js';
-export { type IRfcConversation, RfcTransport, } from './connection/RfcTransport.js';
+export { type IRfcConversation, type IRfcTransportOptions, RfcTransport, } from './connection/RfcTransport.js';
 export { type RfcConnectionParams, rfcConversationFrom, rfcParamsFrom, } from './connection/rfcConversation.js';
 export type { ILogger } from './logger.js';
 export { getTimeout, getTimeoutConfig, type TimeoutConfig, } from './utils/timeouts.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAKxF,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,WAAW,EACX,SAAS,EACT,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,YAAY,EACV,cAAc,EACd,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAQxE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,cAAc,GACpB,MAAM,2CAA2C,CAAC;AAEnD,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,YAAY,EACV,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,gBAAgB,GACjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EACL,KAAK,gBAAgB,EACrB,YAAY,GACb,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,KAAK,mBAAmB,EACxB,mBAAmB,EACnB,aAAa,GACd,MAAM,iCAAiC,CAAC;AACzC,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,6BAA6B,EAAE,MAAM,yCAAyC,CAAC;AAKxF,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,WAAW,EACX,SAAS,EACT,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,YAAY,EACV,cAAc,EACd,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAQxE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,cAAc,GACpB,MAAM,2CAA2C,CAAC;AAEnD,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,YAAY,EACV,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,gBAAgB,GACjB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAE,MAAM,2CAA2C,CAAC;AACtF,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,YAAY,GACb,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,KAAK,mBAAmB,EACxB,mBAAmB,EACnB,aAAa,GACd,MAAM,iCAAiC,CAAC;AACzC,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC"}

package/docs/USAGE.md

@@ -794,7 +794,7 @@ establishing, and whatever session state it keeps.
 
 ```text
 new HttpTransport(agentOptions?, logger?, { client?, baseUrl? })
-new RfcTransport(connect: () => IRfcConversation, logger?)
+new RfcTransport(connect: () => IRfcConversation, logger?, { logWire?, maxLoggedBodyChars? })
 ```
 
 `HttpTransport` is the ordinary wire, and you name it because the connector
@@ -804,6 +804,26 @@ what the connectors' type parameters admit. `RfcTransport`
 you build with `rfcConversationFrom(config)`, which derives `ashost` and `sysnr`
 and loads the SAP NW RFC SDK only when a conversation opens.
 
+**`logWire` dumps the wire, and is off.** With it on, `RfcTransport` adds three
+debug lines per request — the header fields, the request body and the response
+body — which is what tells you a payload was mis-serialised before it reached
+`SADT_REST_RFC_ENDPOINT`. Credential header values (`Authorization`, any
+`Cookie`, anything matching `token`, `secret`, `password`, `credential` or an
+API key) are replaced with `[redacted]`, the names are kept, and a body is cut
+at `maxLoggedBodyChars` (2000 by default) so a class source does not arrive as
+one multi-megabyte line — `0` logs the size alone, `Infinity` asks for the
+whole body, and a negative or `NaN` ceiling falls back to the default instead
+of throwing. Read what you captured before pasting it anywhere: a
+body is not redacted, only clipped.
+
+It is a flag and not something inferred from the logger, because `ILogger` has
+no level predicate — `logger?.debug()` cannot tell an enabled debug channel
+from one that discards. Without the flag, every caller who passes a logger at
+all would pay to build a copy of every body on the wire and throw it away.
+`HttpTransport` logs no bodies at any setting, so "turn debug on" means
+different things on the two wires; this is the only one that can be asked for
+the payload.
+
 The two differ in what they have, not in what they are asked:
 
 | | HTTP | RFC |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/connection",
-  "version": "8.0.1",
+  "version": "8.1.0",
   "description": "ABAP connection layer for MCP ABAP ADT server",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",