@mcp-abap-adt/adt-clients 35.0.0 → 36.0.0

package/README.md

@@ -15,6 +15,12 @@ TypeScript clients for SAP ABAP Development Tools (ADT).
 >
 > **From 18.x?** Read [`docs/usage/MIGRATION-19.md`](docs/usage/MIGRATION-19.md)
 > first: 19.0.0 is where members became one endpoint call each.
+>
+> **From 35.x?** 36.0.0 (on `interfaces-adt` ^20.0.0) makes a request's
+> `Accept` and `Content-Type` yours: 32 members take them as the required
+> `options.headers` and send exactly that pair. See
+> [A request's own headers](#a-requests-own-headers) and
+> [`docs/usage/MIGRATION-36.md`](docs/usage/MIGRATION-36.md).
 
 ## Features
 
@@ -91,7 +97,7 @@ This package interacts with external packages **ONLY through interfaces**:
 
   | package | what this package takes from it |
   |---|---|
-  | [`@mcp-abap-adt/interfaces-adt`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-adt) `^18.0.0` | the capability atoms, every object's config, `IAdtResponse`, `IAnalyse`, `IAdtAnalyseOptions`, `IResultStrategy`, `ADT_NO_FAILURE`, `ADT_TASK_TYPE` |
+  | [`@mcp-abap-adt/interfaces-adt`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-adt) `^20.0.0` | the capability atoms, every object's config, `IAdtResponse`, `IAnalyse`, `IAdtAnalyseOptions`, `IAdtHeaders`, `IResultStrategy`, `ADT_NO_FAILURE`, `ADT_TASK_TYPE` |
   | [`@mcp-abap-adt/interfaces-adt-connection`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-adt-connection) `^3.0.0` | `IAbapConnection`, `IAdtWireResponse`, `IAbapRequestOptions`, the connection capability atoms, `ADT_SESSION_ERROR` |
   | [`@mcp-abap-adt/interfaces-network`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-network) `^2.0.1` | `IWebSocketTransport` and its four companions, `HttpError` |
   | [`@mcp-abap-adt/interfaces-utils`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-utils) `^1.1.1` | `ILogger`, `LogLevel`, `XmlNode` |
@@ -132,7 +138,7 @@ npm install @mcp-abap-adt/adt-clients
    - Factory pattern: `client.getClass()`, `client.getProgram()`, etc.
    - Every answer is a contract — a result or a failure, never a throw
    - Utility functions via `client.getUtils()`
-   - Example: `await client.getClass().create({...})` — the POST, and nothing else
+   - Example: `await client.getClass().create({...}, { headers })` — the POST, and nothing else
 
 2. **AdtRuntimeClient**
    - Stable runtime operations for traces, dumps, logs, feeds, ATC check runs, and more
@@ -153,7 +159,7 @@ npm install @mcp-abap-adt/adt-clients
    - `createAdtExecutor(connection)` picks `AdtExecutor` or `AdtExecutorLegacy` by system version, like `createAdtClient`; the legacy one differs only in the test runner
 
 4. **AdtAbapGitClient**
-   - Standalone: `new AdtAbapGitClient(connection, logger, options?, results?)`
+   - Standalone: `new AdtAbapGitClient(connection, logger?, results?)` (the options argument, `contentTypeVersion`, was removed in 36.0.0)
    - `link`, `pull`, `unlink({ repositoryId })`, `listRepos`, `getErrorLog(logLink)`, `checkExternalRepo` — one request each; `pull` does not wait
 
 5. **AdtClientsWS**
@@ -255,11 +261,16 @@ const client = new AdtClient(connection, console);
 
 // One member, one request: this is the POST that makes the class shell.
 // Writing its source and activating it are calls of your own, below.
-await client.getClass().create({
-  className: 'ZCL_TEST',
-  packageName: 'ZPACKAGE',
-  description: 'Test class'
-});
+// The request's Accept and Content-Type are yours (see "A request's own
+// headers" for the pairs).
+await client.getClass().create(
+  {
+    className: 'ZCL_TEST',
+    packageName: 'ZPACKAGE',
+    description: 'Test class',
+  },
+  { headers: CLASS_DOCUMENT },
+);
 
 // The lock window is yours: lock, write, unlock, activate — in the order you
 // choose, each answering its own contract. Deleting works the same way:
@@ -269,10 +280,12 @@ const locked = await client.getClass().lock(target);
 if (locked.ok) {
   // The handle SAP sent — '' if it sent none, which is yours to judge.
   const lockHandle = locked.getResult().value;
-  await client.getClass().update(target, { source, lockHandle });
+  await client
+    .getClass()
+    .update(target, { headers: SOURCE, source, lockHandle });
   await client.getClass().unlock(target, lockHandle);
 }
-await client.getClass().activate(target);
+await client.getClass().activate(target, { headers: ACTIVATION });
 
 // Every member answers a contract: a result or a failure, and the compiler
 // makes you say which you are reading. What the result *is* was chosen when
@@ -296,10 +309,10 @@ if (found.ok) {
 // because they are three requests — and what to do when a system has no
 // /usageReferences/scope sub-resource (some S/4 releases 404 it) is a decision
 // about your system, so it is yours rather than a fallback hidden in here.
-const scope = await utils.getWhereUsedScope({
-  object_name: 'ZMY_TABLE',
-  object_type: 'table',
-});
+const scope = await utils.getWhereUsedScope(
+  { object_name: 'ZMY_TABLE', object_type: 'table' },
+  { headers: WHERE_USED_SCOPE },
+);
 if (!scope.ok) {
   // A refusal is an answer, not an exception flying past. `origin` says which
   // remedy applies: restore the channel, or ask the server something else —
@@ -312,11 +325,10 @@ const narrowed = utils.modifyWhereUsedScope(scope.getResult().value, {
   enableOnly: ['TABL/DS', 'TABL/DT'],  // or disable: ['CLAS/OC']
 });
 
-const answer = await utils.getWhereUsed({
-  object_name: 'ZMY_TABLE',
-  object_type: 'table',
-  scopeXml: narrowed,
-});
+const answer = await utils.getWhereUsed(
+  { object_name: 'ZMY_TABLE', object_type: 'table', scopeXml: narrowed },
+  { headers: WHERE_USED },
+);
 
 // `utilWhereUsedReferences` above is the shape the old member returned,
 // offered by name rather than imposed. Without it, this is the document.
@@ -366,6 +378,7 @@ const programs = executor.getProgramExecutor({
   scheduled: traceSchedulingProfilerId,
 });
 const scheduled = await programs.scheduleTrace({
+  headers: TRACE_PARAMETERS,
   allProceduralUnits: true,
   sqlTrace: true,
   allDbEvents: true,
@@ -397,7 +410,7 @@ import { analyseUnitTest, analyseUnitTestStart, unitTestRunId } from '@mcp-abap-
 const locked = await client.getClass().lock({ className: 'ZCL_UNDER_TEST' });
 await client.getLocalTestClass().update(
   { className: 'ZCL_UNDER_TEST', source: testSource },
-  { lockHandle: locked.getResult().value },
+  { headers: SOURCE, lockHandle: locked.getResult().value },
 );
 await client.getClass().unlock({ className: 'ZCL_UNDER_TEST' }, locked.getResult().value);
 
@@ -466,11 +479,10 @@ import { AdtClient } from '@mcp-abap-adt/adt-clients';
 
 const client = new AdtClient(connection);
 
-await client.getClass().create({
-  className: 'ZCL_TEST',
-  packageName: 'ZPACKAGE',
-  description: 'Test class'
-});
+await client.getClass().create(
+  { className: 'ZCL_TEST', packageName: 'ZPACKAGE', description: 'Test class' },
+  { headers: CLASS_DOCUMENT },
+);
 
 // Ask the server to hold the read until the object is available. Where the
 // system honours it, this replaces an arbitrary sleep; where it does not, it
@@ -515,7 +527,7 @@ const edited = addAMethod(String(current.getResult().value));
 const locked = await cls.lock(target);
 if (!locked.ok) throw new Error(locked.getError().message);
 const lockHandle = locked.getResult().value;
-await cls.update(target, { source: edited, lockHandle });
+await cls.update(target, { headers: SOURCE, source: edited, lockHandle });
 await cls.unlock(target, lockHandle);
 ```
 
@@ -554,11 +566,14 @@ await client.getBehaviorImplementation().create(
     behaviorDefinition: 'ZOK_I_CDS_TEST',
     description: 'Behavior Implementation for ZOK_I_CDS_TEST',
     transportRequest: 'DEVK900001'
-  }
+  },
+  { headers: CLASS_DOCUMENT },
 );
 // The class shell exists. Its `source/main` — the generated binding to the
 // behavior definition — is `updateMain()`, and activation is `activate()`.
-await client.getBehaviorImplementation().activate({ className: 'ZBP_OK_I_CDS_TEST' });
+await client
+  .getBehaviorImplementation()
+  .activate({ className: 'ZBP_OK_I_CDS_TEST' }, { headers: ACTIVATION });
 ```
 
 ## Developer Tools
@@ -623,11 +638,10 @@ never neither. `client.getUtils()` did since 17.0.0; the per-type handlers do
 now:
 
 ```typescript
-const answer = await client.getClass().create({
-  className: 'ZCL_X',
-  packageName: 'ZP',
-  description: 'x',
-});
+const answer = await client.getClass().create(
+  { className: 'ZCL_X', packageName: 'ZP', description: 'x' },
+  { headers: CLASS_DOCUMENT },
+);
 
 if (answer.ok) {
   answer.getResult().value;   // whatever the reading makes of it
@@ -732,7 +746,10 @@ const requests = client.getRequest({
 // Error strategy: per call.
 await client
   .getPackage()
-  .delete({ packageName: 'ZPKG' }, { analyse: analyseDeletion });
+  .delete(
+    { packageName: 'ZPKG' },
+    { headers: DELETION, analyse: analyseDeletion },
+  );
 ```
 
 ### The reading is yours, and you choose it once
@@ -815,11 +832,14 @@ A member answers one value — what the reading made of the answer — and a fai
 in the other half:
 
 ```typescript
-const answer = await client.getFunctionModule().create({
-  functionGroupName: 'ZFGROUP',
-  functionModuleName: 'ZFM_TEST',
-  description: 'Test FM',
-});
+const answer = await client.getFunctionModule().create(
+  {
+    functionGroupName: 'ZFGROUP',
+    functionModuleName: 'ZFM_TEST',
+    description: 'Test FM',
+  },
+  { headers: FUNCTION_MODULE_DOCUMENT },
+);
 
 if (!answer.ok) throw new Error(answer.getError().message);
 console.log(answer.getResult().value);   // the create's document, by default
@@ -828,39 +848,124 @@ console.log(answer.getResult().value);   // the create's document, by default
 There is no chain behind it: `create()` is the POST, and the lock, write,
 unlock and activation around it are calls of your own, each with its own answer.
 
-### Accept Negotiation
-
-Some ADT endpoints return `406` when the `Accept` header does not match the
-system's supported media types. The client retries once with a type the `406`
-names, and remembers it for that endpoint.
-
-**It is off unless you turn it on** (since 35.0.0) — per client, or for the
-process. Without a switch a `406` or `415` is the call's answer and nothing is
-sent again:
+### A request's own headers
+
+Since 36.0.0 (`@mcp-abap-adt/interfaces-adt` 19.0.0) a member whose request
+sets both `Accept` and `Content-Type` takes them from you, as
+`options.headers: IAdtHeaders` (`{ accept, contentType }`, both required). The
+member sends exactly that pair: it keeps no type of its own for that request,
+and nothing is merged in, defaulted or replaced. The options are required with
+it, and a positional parameter before them that was optional is now
+`T | undefined` — pass `undefined` explicitly.
+
+The 32 members: `link`, `pull`, `checkExternalRepo` (abapGit); `create`,
+`update`, `updateMetadata`, `delete`, `checkDeletion`, `check`, `activate` (the
+object handlers); `checkState` (feature toggle); `removeObject`, `addObject`,
+`createTask`, `changeTaskType`, `moveObjects` (transport request);
+`getWhereUsed`, `getWhereUsedScope`, `getVirtualFoldersContents`,
+`fetchNodeStructure`, `activateObjectsGroup`, `checkDeletionGroup`,
+`deleteObjectsGroup`, `getSqlQuery`, `getTableContents` (`getUtils()`);
+`scheduleTrace` (executors); `setBreakpoints`, `getChildVariables`,
+`getVariables`, `syncBreakpoints`, `setDebuggerSettings` (`AbapDebugger`);
+`getDataPreview` (`AmdpDebugger`). Every other member is unchanged, and a read
+still takes an optional `accept` (`IReadOptions`).
+
+- Members that sent only one of the two before — `create` of a function group,
+  message class and message class message, `update` of a feature toggle and a
+  message class message, `updateMetadata` of a message class, `delete` of a
+  metadata extension and a transport request — send the whole pair now. So do
+  the requests that sent neither: a transport request's `checkDeletion`, and
+  the direct `DELETE` of the legacy client's class, interface, program, DDL
+  source, function group and function module.
+- A message class message's `create`, `update` and `delete` are a chain (read,
+  two locks, the `PUT`, two unlocks): the pair is the `PUT`'s; the chain's own
+  requests keep their types.
+- `AdtContentTypesBase` / `AdtContentTypesModern` still answer pairs for some
+  creates (`classCreate()`, `programCreate()`, …), which you can pass as
+  `headers`; the members themselves no longer read the `contentTypes` option
+  for them. It (and `unicode`) still decides the artifact type inside a
+  check-run document and a class's `readMetadata` `Accept`. abapGit's
+  `contentTypeVersion` option is removed.
+
+The pairs 35.0.0 chose for itself, for the samples below (a modern system):
 
 ```typescript
-import { AdtClient } from '@mcp-abap-adt/adt-clients';
+import type { IAdtHeaders } from '@mcp-abap-adt/interfaces-adt';
 
-const client = new AdtClient(connection, console, {
-  enableAcceptCorrection: true,
-});
+const CLASS_DOCUMENT: IAdtHeaders = {
+  accept: 'application/vnd.sap.adt.oo.classes.v4+xml',
+  contentType: 'application/vnd.sap.adt.oo.classes.v4+xml',
+};
+const SOURCE: IAdtHeaders = {
+  accept: 'text/plain',
+  contentType: 'text/plain; charset=utf-8',
+};
+const ACTIVATION: IAdtHeaders = {
+  accept: 'application/xml',
+  contentType: 'application/vnd.sap.adt.activation+xml',
+};
+const CHECK_RUN: IAdtHeaders = {
+  accept: 'application/vnd.sap.adt.checkmessages+xml',
+  contentType: 'application/vnd.sap.adt.checkobjects+xml',
+};
+const DELETION: IAdtHeaders = {
+  accept: 'application/vnd.sap.adt.deletion.response.v1+xml',
+  contentType: 'application/vnd.sap.adt.deletion.request.v1+xml',
+};
+const WHERE_USED_SCOPE: IAdtHeaders = {
+  accept: 'application/vnd.sap.adt.repository.usagereferences.scope.response.v1+xml',
+  contentType: 'application/vnd.sap.adt.repository.usagereferences.scope.request.v1+xml',
+};
+const WHERE_USED: IAdtHeaders = {
+  accept: 'application/vnd.sap.adt.repository.usagereferences.result.v1+xml',
+  contentType: 'application/vnd.sap.adt.repository.usagereferences.request.v1+xml',
+};
+const TRACE_PARAMETERS: IAdtHeaders = {
+  accept: 'application/xml',
+  contentType: 'application/xml',
+};
+const FUNCTION_MODULE_DOCUMENT: IAdtHeaders = {
+  accept: 'application/vnd.sap.adt.functions.fmodules+xml',
+  contentType: 'application/vnd.sap.adt.functions.fmodules+xml',
+};
 ```
 
-```bash
-ADT_ACCEPT_CORRECTION=true npm test
-```
+### Accept Negotiation (removed in 36.0.0)
+
+A refused request is the call's answer: SAP's `406` (its `Accept` not served)
+or `415` (its `Content-Type` not accepted) comes back like any other status,
+and nothing is corrected, sent again or remembered for a later request.
+**Accept negotiation was removed in 36.0.0** — the retry, the per-connection
+caches, the `enableAcceptCorrection` option, `setAcceptCorrectionEnabled` /
+`getAcceptCorrectionEnabled`, `ADT_ACCEPT_CORRECTION`, `clearAcceptCache`,
+`cachedAccept`, `rememberAccept`, `exemptFromAcceptNegotiation` and
+`getBaseRequest`. A member sends exactly the request it was given, `headers`
+included.
+
+To correct a request yourself, read what SAP named and send it again with the
+pair you choose. Two pure functions over the error are exported:
 
-The variable turns it on only when it is exactly `true`. To correct requests
-yourself instead, read a `406` with `extractSupportedAccept(error)` and keep
-the result in the connection's cache with `rememberAccept(connection, request,
-accept)`; `cachedAccept(connection, request)` reads it back, whatever the
-switch says. See [batch](docs/usage/BATCH.md).
+- `extractSupportedAccept(error)` — the list SAP writes into its `406` body,
+  `Accepted content types: …` (often empty; measured on an on-premise system).
+  It reads no header and no other text.
+- `extractSupportedContentType(error)` — the types a `415` names (its headers
+  and body; unchanged).
+
+```typescript
+import { extractSupportedAccept } from '@mcp-abap-adt/adt-clients';
+
+const first = await cls.check(config, undefined, { headers: CHECK_RUN });
+if (!first.ok && first.getError().response?.status === 406) {
+  const accepted = extractSupportedAccept(first.getError());
+  if (accepted.length > 0) {
+    await cls.check(config, undefined, {
+      headers: { ...CHECK_RUN, accept: accepted.join(', ') },
+    });
+  }
+}
+```
 
-**The state is the connection's** since 23.0.0: the remembered types and the
-switch live on the connection object. They used to be module globals, so a
-header learned on one system was sent to every other, and one client's switch
-changed it for all. Two connections to two systems in one process no longer
-share anything.
+What you learn is yours to keep: nothing in this package stores it.
 
 ### Handler classes exported directly
 
@@ -912,7 +1017,7 @@ everything else is not.
 
 ### Single Definition Site: the contract packages
 
-Since **7.5.0**, every contract type is **defined once**, in the contract packages — today `@mcp-abap-adt/interfaces-adt` (`^18.0.0`) for the ADT contracts and `@mcp-abap-adt/interfaces-adt-connection` (`^3.0.0`) for the connection. This package declares no copies of its own — every `IXxxConfig`, the capability atoms, the option and response types and the cross-cutting shared types all live there.
+Since **7.5.0**, every contract type is **defined once**, in the contract packages — today `@mcp-abap-adt/interfaces-adt` (`^20.0.0`) for the ADT contracts and `@mcp-abap-adt/interfaces-adt-connection` (`^3.0.0`) for the connection. This package declares no copies of its own — every `IXxxConfig`, the capability atoms, the option and response types and the cross-cutting shared types all live there.
 
 **Import them from the package that owns them:**
 
@@ -1029,6 +1134,7 @@ See [Architecture Documentation](docs/architecture/ARCHITECTURE.md#type-system-a
 One document per breaking release, each written for a consumer on the contract
 before it:
 
+- **[35.x → 36.0.0](docs/usage/MIGRATION-36.md)** — a request's `Accept` and `Content-Type` are the caller's: 32 members take the required `options.headers` and send exactly that pair.
 - **[34.x → 35.0.0](docs/usage/MIGRATION-35.md)** — accept negotiation is off by default: a `406`/`415` is the call's answer unless you switch it on.
 - **[33.x → 34.0.0](docs/usage/MIGRATION-34.md)** — a batch corrects and resends nothing: a part's `406`/`415` is that call's answer.
 - **[32.x → 33.0.0](docs/usage/MIGRATION-33.md)** — a credential the provider refused before SAP was asked rejects with the connection's refusal as it came; a `401` SAP refused it with comes back carrying that response.
@@ -1168,9 +1274,9 @@ See [domain and debugger examples](docs/usage/BATCH.md).
 
 `execute()` also sends follow-up envelopes for requests member continuations
 record during settlement (up to 100 envelopes, then all remaining requests
-reject). Nothing in a batch is corrected or sent again: a batch connection is
-exempt from accept negotiation, so a part's `401`, `406` or `415` is that call's
-answer, and a `406`/`415` to the envelope reaches `execute()` as it came. The
+reject). Nothing in a batch is corrected or sent again — nothing anywhere is,
+since 36.0.0 — so a part's `401`, `406` or `415` is that call's answer, and a
+`406`/`415` to the envelope reaches `execute()` as it came. The
 connection's own handling of the envelope request — credential renewal, CSRF
 recovery, session — stays. Explicit session switches apply to the next recording;
 LOCK/UNLOCK run in stateful envelopes; other ordinary members run stateless.

package/dist/batch/AdtBatchConnection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AdtBatchConnection.d.ts","sourceRoot":"","sources":["../../src/batch/AdtBatchConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAU9D,KAAK,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAQxC,sFAAsF;AACtF,qBAAa,kBAAmB,YAAW,eAAe;IAOtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAS;gBAEP,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE;QACxB,QAAQ,EAAE,eAAe,GAAG,UAAU,CAAC;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;IAWH,OAAO,CAAC,cAAc;IAWtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAGxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAG7B,YAAY,IAAI,MAAM,GAAG,IAAI;IAG7B,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAGnC,cAAc,IAAI,OAAO;IAGzB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuBlC,OAAO,CAAC,WAAW;IAkBnB,6EAA6E;IACvE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAmH3C"}
+{"version":3,"file":"AdtBatchConnection.d.ts","sourceRoot":"","sources":["../../src/batch/AdtBatchConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAM9D,KAAK,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAQxC,sFAAsF;AACtF,qBAAa,kBAAmB,YAAW,eAAe;IAOtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAS;gBAEP,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE;QACxB,QAAQ,EAAE,eAAe,GAAG,UAAU,CAAC;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;IAQH,OAAO,CAAC,cAAc;IAWtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAGxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAG7B,YAAY,IAAI,MAAM,GAAG,IAAI;IAG7B,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAGnC,cAAc,IAAI,OAAO;IAGzB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuBlC,OAAO,CAAC,WAAW;IAkBnB,6EAA6E;IACvE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAiH3C"}

package/dist/batch/AdtBatchConnection.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdtBatchConnection = void 0;
 const objects_1 = require("../endpoints/objects");
-const acceptNegotiation_1 = require("../utils/acceptNegotiation");
 const adtResponse_1 = require("../utils/adtResponse");
 const requestTrace_1 = require("../utils/requestTrace");
 const wire_1 = require("./wire");
@@ -23,9 +22,6 @@ class AdtBatchConnection {
         this.defaultSession =
             options.endpoint === 'debugger' ? 'stateful' : 'stateless';
         this.session = this.defaultSession;
-        // What SAP answers to a recorded request is the caller's: no member's
-        // accept negotiation corrects or resends through this connection.
-        (0, acceptNegotiation_1.exemptFromAcceptNegotiation)(this);
     }
     wrappedSession() {
         const connection = this.connection;
@@ -108,11 +104,9 @@ class AdtBatchConnection {
                     endpoint: this.options.endpoint,
                     parts: active.length,
                 });
-                // Not through accept negotiation: when an `AdtClient` wrapped the
-                // connection, it would answer a 406/415 to the envelope by sending it
-                // again. A batch is the caller's, and so is what SAP answered to it.
-                // The connection's own handling (credential, CSRF, session) stays.
-                response = await (0, acceptNegotiation_1.getBaseRequest)(this.connection)({
+                // Sent once. What SAP answers to the envelope — a 406/415 included —
+                // is the caller's, as is every part's answer.
+                response = await this.connection.makeAdtRequest({
                     url: objects_1.BATCH[this.options.endpoint],
                     method: 'POST',
                     timeout: 0,

package/dist/clients/AdtAbapGitClient.d.ts

@@ -3,14 +3,14 @@
  *
  * Standalone top-level class — NOT a factory on AdtClient (which is
  * reserved for IAdtObject<Config, State> implementations only).
- * Consumers instantiate directly: new AdtAbapGitClient(connection, logger, options).
+ * Consumers instantiate directly: new AdtAbapGitClient(connection, logger, results?).
  *
  * Implements IAdtAbapGitClient. HTTP operations are delegated to
  * low-level functions in ./abapGit/*; this class owns the options,
  * enforces the public contract, and keeps the call sites cast-free
  * by implementing the specialized interface.
  */
-import type { IAbapGitExternalRepoCredentials, IAbapGitLinkArgs, IAbapGitPullArgs, IAbapGitUnlinkArgs, IAdtAbapGitClient, IAdtAbapGitClientOptions, IAdtAnalyseOptions, IAdtError, IAdtResponse } from '@mcp-abap-adt/interfaces-adt';
+import type { IAbapGitExternalRepoCredentials, IAbapGitLinkArgs, IAbapGitPullArgs, IAbapGitUnlinkArgs, IAdtAbapGitClient, IAdtAnalyseOptions, IAdtError, IAdtHeaders, IAdtResponse } from '@mcp-abap-adt/interfaces-adt';
 import type { IAbapConnection } from '@mcp-abap-adt/interfaces-adt-connection';
 import type { ILogger } from '@mcp-abap-adt/interfaces-utils';
 import { abapGitDocuments, type IAbapGitResults } from './abapGit/types';
@@ -27,11 +27,12 @@ import { abapGitDocuments, type IAbapGitResults } from './abapGit/types';
 export declare class AdtAbapGitClient<R extends IAbapGitResults = typeof abapGitDocuments> implements IAdtAbapGitClient<ReturnType<R['repos']>, ReturnType<R['errorLog']>, ReturnType<R['pulled']>, ReturnType<R['externalRepo']>> {
     private readonly connection;
     private readonly logger?;
-    private readonly contentTypeVersion;
     private readonly results;
-    constructor(connection: IAbapConnection, logger?: ILogger, options?: IAdtAbapGitClientOptions, results?: R);
+    constructor(connection: IAbapConnection, logger?: ILogger, results?: R);
     /** Link a package to a repository. */
-    link<E extends IAdtError = IAdtError>(args: IAbapGitLinkArgs, options?: IAdtAnalyseOptions<E>): Promise<IAdtResponse<void, E>>;
+    link<E extends IAdtError = IAdtError>(args: IAbapGitLinkArgs, options: {
+        headers: IAdtHeaders;
+    } & IAdtAnalyseOptions<E>): Promise<IAdtResponse<void, E>>;
     /**
      * Start a pull. One POST, to the link `listRepos` reported.
      *
@@ -39,7 +40,9 @@ export declare class AdtAbapGitClient<R extends IAbapGitResults = typeof abapGit
      * deciding how long to allow and what to do when it does not, and reading
      * `getErrorLog` when the status says to — all of that is the caller's.
      */
-    pull<E extends IAdtError = IAdtError>(args: IAbapGitPullArgs, options?: IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['pulled']>, E>>;
+    pull<E extends IAdtError = IAdtError>(args: IAbapGitPullArgs, options: {
+        headers: IAdtHeaders;
+    } & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['pulled']>, E>>;
     /** Remove a repository link, by the key `listRepos` reported. */
     unlink<E extends IAdtError = IAdtError>(args: IAbapGitUnlinkArgs, options?: IAdtAnalyseOptions<E>): Promise<IAdtResponse<void, E>>;
     /** Every repository this system has linked. */
@@ -47,6 +50,8 @@ export declare class AdtAbapGitClient<R extends IAbapGitResults = typeof abapGit
     /** A run's error log, from the log link `listRepos` reported. */
     getErrorLog<E extends IAdtError = IAdtError>(logLink: string, options?: IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['errorLog']>, E>>;
     /** What an external repository offers, before linking anything to it. */
-    checkExternalRepo<E extends IAdtError = IAdtError>(args: IAbapGitExternalRepoCredentials, options?: IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['externalRepo']>, E>>;
+    checkExternalRepo<E extends IAdtError = IAdtError>(args: IAbapGitExternalRepoCredentials, options: {
+        headers: IAdtHeaders;
+    } & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['externalRepo']>, E>>;
 }
 //# sourceMappingURL=AdtAbapGitClient.d.ts.map

package/dist/clients/AdtAbapGitClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AdtAbapGitClient.d.ts","sourceRoot":"","sources":["../../src/clients/AdtAbapGitClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,+BAA+B,EAC/B,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,EAClB,SAAS,EACT,YAAY,EAGb,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAO9D,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGzE;;;;;;;;;GASG;AACH,qBAAa,gBAAgB,CAC3B,CAAC,SAAS,eAAe,GAAG,OAAO,gBAAgB,CACnD,YACE,iBAAiB,CACf,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EACtB,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EACzB,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EACvB,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAC9B;IAEH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAc;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAI;gBAG1B,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,wBAAwB,EAElC,OAAO,GAAE,CAAoC;IAQ/C,sCAAsC;IAChC,IAAI,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACxC,IAAI,EAAE,gBAAgB,EACtB,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAWjC;;;;;;OAMG;IACG,IAAI,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACxC,IAAI,EAAE,gBAAgB,EACtB,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IASpD,iEAAiE;IAC3D,MAAM,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC1C,IAAI,EAAE,kBAAkB,EACxB,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAWjC,+CAA+C;IACzC,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC7C,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQnD,iEAAiE;IAC3D,WAAW,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC/C,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQtD,yEAAyE;IACnE,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACrD,IAAI,EAAE,+BAA+B,EACrC,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAS3D"}
+{"version":3,"file":"AdtAbapGitClient.d.ts","sourceRoot":"","sources":["../../src/clients/AdtAbapGitClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,+BAA+B,EAC/B,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,SAAS,EACT,WAAW,EACX,YAAY,EAGb,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAO9D,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGzE;;;;;;;;;GASG;AACH,qBAAa,gBAAgB,CAC3B,CAAC,SAAS,eAAe,GAAG,OAAO,gBAAgB,CACnD,YACE,iBAAiB,CACf,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EACtB,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EACzB,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EACvB,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAC9B;IAEH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAU;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAI;gBAG1B,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAIhB,OAAO,GAAE,CAAoC;IAO/C,sCAAsC;IAChC,IAAI,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACxC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE;QAAE,OAAO,EAAE,WAAW,CAAA;KAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACxD,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAWjC;;;;;;OAMG;IACG,IAAI,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACxC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE;QAAE,OAAO,EAAE,WAAW,CAAA;KAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACxD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IASpD,iEAAiE;IAC3D,MAAM,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC1C,IAAI,EAAE,kBAAkB,EACxB,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IAWjC,+CAA+C;IACzC,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC7C,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQnD,iEAAiE;IAC3D,WAAW,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC/C,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQtD,yEAAyE;IACnE,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACrD,IAAI,EAAE,+BAA+B,EACrC,OAAO,EAAE;QAAE,OAAO,EAAE,WAAW,CAAA;KAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACxD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAS3D"}

package/dist/clients/AdtAbapGitClient.js

@@ -4,7 +4,7 @@
  *
  * Standalone top-level class — NOT a factory on AdtClient (which is
  * reserved for IAdtObject<Config, State> implementations only).
- * Consumers instantiate directly: new AdtAbapGitClient(connection, logger, options).
+ * Consumers instantiate directly: new AdtAbapGitClient(connection, logger, results?).
  *
  * Implements IAdtAbapGitClient. HTTP operations are delegated to
  * low-level functions in ./abapGit/*; this class owns the options,
@@ -34,20 +34,20 @@ const unlink_1 = require("./abapGit/unlink");
 class AdtAbapGitClient {
     connection;
     logger;
-    contentTypeVersion;
     results;
-    constructor(connection, logger, options, 
+    constructor(connection, logger, 
+    // The options (`contentTypeVersion`, which chose what `link` and `pull`
+    // sent) are gone since 36.0.0: those members send the caller's `headers`.
     // The one cast in this file, and it is on the default. See AdtClass.
     results = types_1.abapGitDocuments) {
         this.connection = connection;
         this.logger = logger;
-        this.contentTypeVersion = options?.contentTypeVersion ?? 'v3';
         this.results = results;
     }
     /** Link a package to a repository. */
     async link(args, options) {
         this.logger?.debug?.(`AdtAbapGitClient.link: package=${args.package} url=${args.url}`);
-        return (0, adtResponse_1.answering)(() => (0, link_1.linkRepo)(this.connection, args, this.contentTypeVersion), this.results.linked, options?.analyse);
+        return (0, adtResponse_1.answering)(() => (0, link_1.linkRepo)(this.connection, options.headers, args), this.results.linked, options?.analyse);
     }
     /**
      * Start a pull. One POST, to the link `listRepos` reported.
@@ -58,7 +58,7 @@ class AdtAbapGitClient {
      */
     async pull(args, options) {
         this.logger?.debug?.(`AdtAbapGitClient.pull: package=${args.package}`);
-        return (0, adtResponse_1.answering)(() => (0, pull_1.pullRepo)(this.connection, args, this.contentTypeVersion), this.results.pulled, options?.analyse);
+        return (0, adtResponse_1.answering)(() => (0, pull_1.pullRepo)(this.connection, options.headers, args), this.results.pulled, options?.analyse);
     }
     /** Remove a repository link, by the key `listRepos` reported. */
     async unlink(args, options) {
@@ -75,7 +75,7 @@ class AdtAbapGitClient {
     }
     /** What an external repository offers, before linking anything to it. */
     async checkExternalRepo(args, options) {
-        return (0, adtResponse_1.answering)(() => (0, checkExternalRepo_1.checkExternalRepo)(this.connection, args), this.results.externalRepo, options?.analyse);
+        return (0, adtResponse_1.answering)(() => (0, checkExternalRepo_1.checkExternalRepo)(this.connection, options.headers, args), this.results.externalRepo, options?.analyse);
     }
 }
 exports.AdtAbapGitClient = AdtAbapGitClient;