@mcp-abap-adt/connection 8.0.0 → 8.1.0

package/CHANGELOG.md

@@ -7,6 +7,54 @@ 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.**
+
+Both majors are already on npm, and `docs/` travels in the tarball, so the
+installed package described the pre-7.0.0 connection: no request id, no
+profiling, no `flushGoodbye`, and no word on what a consumer on 6.x must
+change. This release carries the documentation those two releases owed and
+changes no code.
+
+### Documentation
+
+- `docs/MIGRATION-8.0.md` (new): what a consumer on 6.x does about the
+  `IAdtWireResponse` return of `makeAdtRequest`, the capability atoms the
+  class now declares, and the two headers every request now carries.
+- `docs/STATEFUL_SESSION_GUIDE.md`: the session type is the connection's —
+  `x-sap-adt-sessiontype: stateful` is added by the transport, not by a
+  caller's headers — and `flushGoodbye` is how a caller waits for the
+  goodbye.
+- `README.md` and `docs/INDEX.md` point at both.
+
 ## [8.0.0] - 2026-09-08
 
 **A consumer holding the contract can now do what the connection could always do.**
@@ -1513,7 +1561,9 @@ const connection = createAbapConnection(config, logger);
 - JWT token refresh now properly handles connection errors (401/403 during initial connect)
 - 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.0...HEAD
+[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
 [6.0.1]: https://github.com/fr0ster/mcp-abap-connection/compare/v6.0.0...v6.0.1

package/README.md

@@ -34,7 +34,9 @@ The package uses a clean separation of concerns:
 
 - **`AbstractAbapConnection`** (abstract, internal only):
   - Common HTTP request logic
-  - Session lifecycle: `connect()` / `disconnect()`, admission, lock windows, teardown draining
+  - Session lifecycle: `connect()` / `disconnect()` / `flushGoodbye()`, admission, lock windows, teardown draining
+  - Capability atoms a consumer narrows to, rather than casting to a connector class:
+    `ISessionLifecycleAware`, `ICriticalSection`, `IRequestProfiling`
   - Session management (cookies, CSRF tokens)
   - CSRF token fetching with retry
   - Auth-agnostic - knows nothing about Basic or JWT
@@ -654,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/INDEX.md

@@ -15,6 +15,7 @@ mcp-abap-connection/
 │   ├── INSTALLATION.md             # Setup and installation guide
 │   ├── USAGE.md                    # API documentation and examples
 │   ├── MIGRATION-2.0.md            # Moving to the explicit session lifecycle
+│   ├── MIGRATION-8.0.md            # request headers leave the stateful branch; onto interfaces 39; flushGoodbye
 │   ├── MIGRATION-6.0.md            # the factory and the per-credential classes go; RFC is a transport
 │   ├── MIGRATION-4.0.md            # JWT error classification: 401 refreshes, 403 propagates
 │   ├── SCOPE.md                    # What this package does and does not own
@@ -44,6 +45,7 @@ mcp-abap-connection/
 - 🔑 [JWT Auth Tools](./JWT_AUTH_TOOLS.md) - CLI tool for browser-based authentication
 
 ### Upgrading
+- 🚚 [Migrating to 7.0.0 and 8.0.0](./MIGRATION-8.0.md) - `sap-adt-request-id` and `X-sap-adt-profiling` on every request, `x-sap-security-session: use` on cloud, the contracts floor at 39, and `flushGoodbye()`
 - 🚚 [Migrating to 6.0.0](./MIGRATION-6.0.md) - the factory and the per-credential classes are removed; the RFC wire is a transport you hand to the on-prem connector
 - 🧱 [Migrating to 4.0.0](./MIGRATION-4.0.md) - JWT error classification: a 401 refreshes, a 403 propagates with the server's message
 - 🧱 [Migrating to 2.0.0](./MIGRATION-2.0.md) - The explicit session lifecycle: `connect()` is required

package/docs/MIGRATION-8.0.md

@@ -0,0 +1,171 @@
+# Migration to 7.0 and 8.0
+
+Two majors, and **no code of yours has to change for either**. One alters what
+goes on the wire; the other moves the contracts floor and makes methods you
+already had reachable through the types you already hold.
+
+If you build against `@mcp-abap-adt/interfaces` and never cast to a connector
+class, there is nothing to do but install.
+
+## 7.0 — headers that belong to the request stop belonging to the session
+
+Three headers used to be written together, inside the stateful branch:
+
+```ts
+if (this.sessionMode === 'stateful') {
+  requestHeaders['x-sap-adt-sessiontype'] = 'stateful';
+  requestHeaders['sap-adt-request-id'] = randomUUID().replace(/-/g, '');
+  requestHeaders['X-sap-adt-profiling'] = 'server-time';
+}
+```
+
+Only the first belongs there. A request id identifies the **request**, and
+asking the server to report its own processing time is not a property of the
+session either. Eclipse sends both on everything — measured on ADT 3.60.0, a
+stateless source `PUT` carries them and no session type at all.
+
+It stayed invisible while every write ran inside a lock window. Once
+`@mcp-abap-adt/adt-clients` narrowed stateful to the `LOCK` and the `UNLOCK`,
+the writes silently lost two headers: of 792 requests in a full run, 99 carried
+a request id and **693 carried neither**.
+
+### What changed for you
+
+| | |
+|---|---|
+| `sap-adt-request-id` | now on every request, fresh each time |
+| `X-sap-adt-profiling` | now on every request, from a settable default |
+| `x-sap-security-session: use` | **cloud only**, on every request once a session exists |
+| `x-sap-adt-sessiontype` | unchanged — still the only one that varies with the mode |
+
+Nothing in the type surface moved. The major is for the wire: every request
+looks different in an SAP trace, and a system that reacts badly to either should
+be findable by version rather than by reading a dump.
+
+### Your own headers win
+
+Both new headers are **defaults**. A caller who names either in
+`options.headers` keeps their value, matched without case:
+
+```ts
+await conn.makeAdtRequest({
+  url, method: 'GET', timeout: 30_000,
+  headers: { 'sap-adt-request-id': myCorrelationId },   // kept, not replaced
+});
+```
+
+That is not hypothetical: `adt-clients` passes its own id to
+`getDiscovery({ requestId })` so the id it logs is the id on the wire.
+
+### Turning the profiling off
+
+```ts
+conn.setProfilingRequest(null);          // ask for nothing
+conn.setProfilingRequest('server-time'); // the default, and what Eclipse asks for
+```
+
+Nothing in this package reads the `server-time=…` that comes back. An
+investigation does, though — the unit is **microseconds**, which a trial's
+unpublish job settled by answering `server-time=132512547` on a request that
+takes about 133 seconds.
+
+## 8.0 — onto interfaces 39.0.0, and the atoms are declared
+
+### The floor
+
+`@mcp-abap-adt/interfaces` moves from `^21.0.0` to `^39.0.0`. Install it
+alongside; a consumer pinned below 39 cannot have both.
+
+Seventeen majors, and the whole migration inside this package was eight compiler
+errors in one file — `makeAdtRequest` returning `IAdtWireResponse<T, D>` rather
+than `IAdtResponse<T, D>`, and `isNetworkError` coming home because interfaces
+stopped emitting code in 29.0.0.
+
+**If you deduplicate nothing else, deduplicate this.** Two copies of the
+contracts in one graph are structurally identical and do not compare equal, so
+they produce errors that read as impossible.
+
+```
+npm ls @mcp-abap-adt/interfaces     # should print one version, deduped
+```
+
+### `flushGoodbye()` — the half of `disconnect()` that was missing
+
+`disconnect()` dispatches the logoff and does not await it, on purpose: a
+goodbye carries no request timeout, and a server that never answers must not
+hold a teardown open.
+
+That is right for a teardown and wrong for a **reconnect**:
+
+```ts
+await conn.disconnect();
+await conn.flushGoodbye();   // give the goodbye its budget to finish first
+await conn.connect();
+```
+
+Without the middle line, the next session opens while the previous one's goodbye
+is still being assembled and the server keeps both. Measured on E19 through a
+test harness that recycled the session after each test: **a new ABAP session
+every one to two seconds for a whole run, none released**, each living to its
+own thirty-minute idle timeout.
+
+**The budget bounds the waiting, not the overlap.** If the goodbye finishes in
+time there is no overlap; if it does not, you proceed and it stays outstanding
+for as long as it takes. A return is not a confirmation and not even of
+dispatch.
+
+Calling `disconnect()` twice is **not** a substitute — a repeat call does not
+wait either.
+
+### Reaching the controls through the contract
+
+`beginCriticalSection()`, `setProfilingRequest()` and `flushGoodbye()` all
+existed before. What changed is that a consumer can reach them without a cast:
+`AbapConnection` is `IAbapConnection`, and these now live on capability atoms
+that this connection declares.
+
+```ts
+import type {
+  IAbapConnection,
+  ICriticalSection,
+  IRequestProfiling,
+  ISessionLifecycleAware,
+} from '@mcp-abap-adt/interfaces';
+
+function protectTheWindow(conn: IAbapConnection & ICriticalSection) {
+  conn.beginCriticalSection();
+  try {
+    // the ordinary per-request deadline does not apply in here
+  } finally {
+    conn.endCriticalSection();
+  }
+}
+```
+
+`flushGoodbye` is a member of `ISessionLifecycleAware`, not an atom of its own:
+waiting for the goodbye is not a separate capability from sending it.
+
+### One thing to know about `implements`
+
+TypeScript is structural. Removing an atom from a class's `implements` list
+changes nothing for a consumer — the class still has the methods and narrowing
+still succeeds. What the clause buys is the compiler checking the class *against*
+the contract in the other direction: remove `beginCriticalSection` itself and it
+is `TS2420`.
+
+Worth knowing before writing a guard that tests the clause rather than the
+method.
+
+### `IRenewableCredential` is an atom now
+
+Not this package's change, but it lands with the floor. Renewing is something a
+credential can also do, not a kind of credential, so a guard that narrowed to
+`IRenewableCredential` alone now hands the caller something that renews and
+cannot authenticate:
+
+```ts
+// before
+function isRenewable(c: IAuthProvider): c is IRenewableCredential
+// after
+function isRenewable(c: IAuthProvider): c is IAuthProvider & IRenewableCredential
+```

package/docs/STATEFUL_SESSION_GUIDE.md

@@ -120,6 +120,22 @@ authentication answer. A 403 never did this: it is an authorization answer, not
 If you decide the refusal meant a stale token, `renew()` and reconnect are yours to call — and a
 reconnect is a NEW session, so do it outside a lock window rather than inside one.
 
+**Wait for the goodbye before opening the next one.** `disconnect()` dispatches the logoff and does
+not await it, so a reconnect otherwise opens the next session while the previous one's goodbye is
+still being assembled, and the server keeps both:
+
+```typescript
+await conn.disconnect();
+await conn.flushGoodbye();   // give the goodbye its budget to finish first
+await conn.connect();
+```
+
+Measured on E19 through a harness that recycled the session after each test: a new ABAP session
+every one to two seconds for a whole run, none released, each living to its own thirty-minute idle
+timeout. The budget bounds the waiting, not the overlap — if the goodbye finishes in time there is
+none, and if it does not you proceed while it stays outstanding. Calling `disconnect()` again is not
+a substitute: a repeat call does not wait either.
+
 ---
 
 ## Interaction With ADT Clients
@@ -189,6 +205,13 @@ lock is still very much held. That — not any teardown — is why
 `beginCriticalSection()` raises the effective timeout to a large ceiling for the
 duration of a `lock → modify → unlock` chain.
 
+Since 8.0.0 you reach it through the contract rather than the class: it is
+`ICriticalSection` in `@mcp-abap-adt/interfaces`, which this connection declares.
+What it promises is narrow and worth stating exactly — inside a section the
+*ordinary* per-request deadline does not apply. Not that no request can be cut
+short: the ceiling is `SAP_TIMEOUT_CRITICAL`, ten minutes by default, and a
+socket ends a request whatever a contract says.
+
 ### Two sessions, and they are not the same thing
 
 There are two sessions here, and they are not the same thing:

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.0",
+  "version": "8.1.0",
   "description": "ABAP connection layer for MCP ABAP ADT server",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",