sap-adt-mcp 0.8.49 → 0.8.51

package/README.md

@@ -198,9 +198,12 @@ so on startup. There are three channels:
    missing capability) via the **`adt_report_issue`** tool.
 
 What is sent: the sap-adt-mcp version, Node version, OS, the tool name, and the
-error/finding with a fingerprint for de-duplication. Before anything leaves your
-machine it is scrubbed of **hostnames, users, passwords, tokens, IPs, and
-emails**; tool arguments and free-text fields are redacted the same way. Reports
+error/finding with a fingerprint for de-duplication, plus an **anonymous install
+id** (random bytes, cached at `~/.sap-adt-mcp/install-id`) that lets repeat
+reports from the same install be grouped for triage — it identifies neither you
+nor your system. Before anything leaves your machine it is scrubbed of
+**hostnames, users, passwords, tokens, IPs, and emails**; tool arguments and
+free-text fields are redacted the same way. Reports
 go to a relay the maintainer owns, which files/de-dups a GitHub issue — the
 relay holds the GitHub credentials, never this package.
 
@@ -310,8 +313,8 @@ or rejecting credentials. Run this first when troubleshooting.
 
 | Tool | Purpose | Notes |
 | --- | --- | --- |
-| `adt_get_source` | Fetch ABAP source by object name + type. | Returns plain text. For classes, pick the include via `include`: `main` (default), `definitions`, `implementations`, `macros`, `testclasses`. Function modules require `group`. |
-| `adt_set_source` | Replace source. Orchestrates lock → PUT → unlock. | Optional `transport` parameter assigns the change to a TR (`corrNr`). Optional `lockHandle` to reuse an externally-acquired lock. Refused under `readOnly: true`. |
+| `adt_get_source` | Fetch ABAP source by object name + type. | Returns plain text. For classes, pick the include via `include`: `main` (default), `definitions`, `implementations`, `macros`, `testclasses`. Function modules require `group`. For large objects, pass `outputFile` to write the source straight to disk (response omits inline `source`). |
+| `adt_set_source` | Replace source. Orchestrates lock → PUT → unlock. | Supply the new source inline via `source`, or via `sourceFile` (a local path the MCP reads itself) for large objects that exceed the per-call I/O cap. Optional `transport` assigns the change to a TR (`corrNr`); optional `lockHandle` reuses an externally-acquired lock. Refused under `readOnly: true`. |
 | `adt_create_object` | Create a new ABAP object in a package. | Supported types: program, class, interface, include, functiongroup, function, cds, accesscontrol, metadataext, behaviordef, messageclass. After creation, set the source body with `adt_set_source` and activate. Refused under `readOnly: true`. |
 | `adt_delete_object` | Delete an object. | Acquires lock and DELETEs. Refused under `readOnly: true`. |
 | `adt_activate` | Activate one or more objects. | Pass `objects: [{ name, type, group? }]`. |
@@ -608,6 +611,25 @@ sticky-lock pattern:
 The `lockHandle` parameter on `adt_set_source` skips internal lock/unlock
 when present.
 
+### Large objects (thousands of lines)
+
+A multi-thousand-line class or program can exceed the per-call I/O cap, so its
+source cannot be passed inline. Keep the content on disk instead — it never
+enters the agent context:
+
+```text
+1.  adt_get_source { object: "ZCL_BIG", type: "class",
+                     outputFile: "/tmp/zcl_big.abap" }   → writes the file, no inline source
+2.  (edit /tmp/zcl_big.abap locally)
+3.  adt_set_source { object: "ZCL_BIG", type: "class",
+                     sourceFile: "/tmp/zcl_big.abap",
+                     transport: "E4DK900123" }           → MCP reads the file and PUTs it
+```
+
+Note: assigning to a transport works headless, but TR *creation*
+(`adt_create_transport`) routes through a GUI dialog on some systems and can
+fail with a 500 — pass an existing TR id instead.
+
 ## Caveats
 
 - **NetWeaver release variation.** A few ADT endpoints (especially around

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sap-adt-mcp",
-  "version": "0.8.49",
+  "version": "0.8.51",
   "mcpName": "io.github.yzonur/sap-adt-mcp",
   "description": "MCP server giving Claude live access to SAP systems via ADT (ABAP Development Tools) REST. Read source, search, run syntax checks, and edit ABAP objects from any MCP-compatible client.",
   "type": "module",
@@ -21,7 +21,7 @@
   },
   "scripts": {
     "start": "node src/server.js",
-    "test": "node --test test/adt-error.test.js test/atc-bulk.test.js test/audit.test.js test/cds.test.js test/config.test.js test/data-preview.test.js test/diff.test.js test/dump-feed.test.js test/grep-source.test.js test/jobs.test.js test/lifecycle-activate.test.js test/lock.test.js test/mcp-bug-fixes.test.js test/node-structure.test.js test/notes.test.js test/object-create.test.js test/object-references.test.js test/object-uris.test.js test/panel.test.js test/prompts.test.js test/provenance.test.js test/rap-scaffold.test.js test/reporter.test.js test/security.test.js test/source-chunked.test.js test/source-guard.test.js test/source-pagination.test.js test/syntax-context.test.js test/tools-shape.test.js test/versions.test.js test/worklist.test.js",
+    "test": "node --test test/adt-error.test.js test/atc-bulk.test.js test/audit.test.js test/cds.test.js test/config.test.js test/data-preview.test.js test/diff.test.js test/dump-feed.test.js test/grep-source.test.js test/jobs.test.js test/lifecycle-activate.test.js test/lock.test.js test/mcp-bug-fixes.test.js test/node-structure.test.js test/notes.test.js test/object-create.test.js test/object-references.test.js test/object-uris.test.js test/panel.test.js test/prompts.test.js test/provenance.test.js test/query-blank.test.js test/rap-scaffold.test.js test/reporter.test.js test/security.test.js test/source-chunked.test.js test/source-file-io.test.js test/source-guard.test.js test/source-pagination.test.js test/syntax-context.test.js test/tools-shape.test.js test/versions.test.js test/worklist.test.js",
     "lint": "eslint src test"
   },
   "keywords": [

package/src/adt-client.js

@@ -108,7 +108,9 @@ export class AdtClient {
         path: resolvedPath,
         status: res.status,
         ok: res.ok,
-        ...(query?.corrNr ? { transport: String(query.corrNr) } : {}),
+        ...(query?.corrNr && String(query.corrNr).trim()
+          ? { transport: String(query.corrNr).trim() }
+          : {}),
       });
     }
 
@@ -285,7 +287,15 @@ export class AdtClient {
     }
     if (query) {
       for (const [k, v] of Object.entries(query)) {
-        url.searchParams.set(k, String(v));
+        // A null/undefined/blank value is never a meaningful ADT query param, and
+        // a whitespace-only one is actively harmful: a transport passed as " "
+        // reaches the CTS backend as corrNr=%20 and 500s the request (#68). Skip
+        // empties uniformly so every corrNr-bearing tool (set_source, chunked,
+        // activate/delete, rap) is covered at one point.
+        if (v == null) continue;
+        const s = String(v);
+        if (s.trim() === "") continue;
+        url.searchParams.set(k, s);
       }
     }
     return url.toString();

package/src/object-create.js

@@ -201,20 +201,32 @@ export function buildCreateRequest({
   }
 }
 
+// The ADT object-create framework accepts a wildcard content type on the POST;
+// abap-adt-api (the reference client) creates *every* object type with exactly
+// this, never a resource-specific media type. It is our universal last resort.
+export const GENERIC_CREATE_MEDIA_TYPE = "application/*";
+
 // Most ADT create endpoints version their media type (…v2+xml, …v3+xml). The
 // shapes above target the newest version a modern stack accepts, but older
 // systems only know an earlier one and answer the newer media type with
 // 415 ExceptionUnsupportedMediaType. Given a content-type, return the chain to
-// try: the requested version first, then every lower version down to v1.
-// A content-type with no `.vN+xml` segment is returned unchanged (single item).
+// try: the requested version first, then every lower version down to v1, then
+// the generic wildcard as a final catch-all — some systems register neither
+// versioned type for a given object (e.g. DDLS/CDS create 415'd on both v2 and
+// v1, #64), but the create framework always honours application/*.
 export function mediaTypeFallbacks(contentType) {
   const m = /^(.*\.)v(\d+)(\+xml)$/.exec(contentType);
-  if (!m) return [contentType];
+  if (!m) {
+    return contentType === GENERIC_CREATE_MEDIA_TYPE
+      ? [contentType]
+      : [contentType, GENERIC_CREATE_MEDIA_TYPE];
+  }
   const [, prefix, ver, suffix] = m;
   const chain = [];
   for (let v = Number(ver); v >= 1; v--) {
     chain.push(`${prefix}v${v}${suffix}`);
   }
+  chain.push(GENERIC_CREATE_MEDIA_TYPE);
   return chain;
 }
 

package/src/object-references.js

@@ -18,6 +18,29 @@ export function parseObjectReferences(xml) {
   return out;
 }
 
+// The where-used / usageReferences response nests the referencing object inside
+// <usageReferences:adtObject adtcore:name=… adtcore:type=… …> rather than the
+// flat <adtcore:objectReference/> element the search endpoints use, so
+// parseObjectReferences finds nothing in it. Extract each adtObject's adtcore
+// attributes (prefix-agnostic — the server chooses the namespace prefix).
+const ADTOBJ_RE = /<(?:[\w]+:)?adtObject\b([^>]*)>/gi;
+
+export function parseUsageReferences(xml) {
+  if (typeof xml !== "string") return [];
+  const out = [];
+  for (const m of xml.matchAll(ADTOBJ_RE)) {
+    const attrs = {};
+    for (const a of m[1].matchAll(ATTR_RE)) {
+      const key = a[1].replace(/^adtcore:/, "");
+      attrs[key] = decodeEntities(a[2]);
+    }
+    if (attrs.name || attrs.uri) out.push(attrs);
+  }
+  // Older systems emit the flat objectReference shape here too — fall back so a
+  // response in either form is parsed.
+  return out.length ? out : parseObjectReferences(xml);
+}
+
 function decodeEntities(s) {
   return s
     .replace(/&lt;/g, "<")

package/src/object-uris.js

@@ -86,6 +86,15 @@ function collapseSubtype(t) {
   return t;
 }
 
+// The canonical base type: normalize aliases, then collapse a decorative
+// TADIR subtype (DOMA/DD → DOMA) the same way objectUri/sourceUri do internally.
+// Callers that dispatch on the type (e.g. the metadata-XML Accept lookup) must
+// use this, not the raw normalizeType output — a subtype like "DOMA/DD" otherwise
+// misses the table and falls through to a text/plain fetch that 406s (#66).
+export function baseType(input) {
+  return collapseSubtype(normalizeType(input));
+}
+
 export function objectUri({ type, name, group }) {
   const t = collapseSubtype(normalizeType(type));
   if (typeof name !== "string" || name.length === 0) {

package/src/reporter.js

@@ -14,7 +14,9 @@
 // Opt out with `"reporting": { "enabled": false }` in config, or SAP_ADT_MCP_REPORT=0.
 
 import crypto from "node:crypto";
+import fs from "node:fs";
 import os from "node:os";
+import path from "node:path";
 import { BUILD_FINGERPRINT } from "./tools/_shared.js";
 
 // Filled in by the maintainer after deploying the relay Worker. Overridable per
@@ -147,6 +149,33 @@ function hash16(s) {
   return crypto.createHash("sha256").update(s).digest("hex").slice(0, 16);
 }
 
+// --- Install identity --------------------------------------------------------
+
+// A stable, ANONYMOUS per-install identifier. It is random bytes — never derived
+// from any machine, user, or config attribute — so it groups repeat reports from
+// the same install for triage without identifying the person or their system.
+// Generated once and cached at ~/.sap-adt-mcp/install-id, reused thereafter.
+// Only touched when reporting is enabled. Best-effort: any fs failure falls back
+// to an ephemeral id so a report is never blocked.
+function resolveInstallId() {
+  const dir = path.join(os.homedir(), ".sap-adt-mcp");
+  const file = path.join(dir, "install-id");
+  try {
+    const existing = fs.readFileSync(file, "utf8").trim();
+    if (/^[0-9a-f]{16}$/i.test(existing)) return existing;
+  } catch {
+    // Not created yet (or unreadable) — fall through and mint one.
+  }
+  const id = crypto.randomBytes(8).toString("hex");
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, id + "\n", { mode: 0o600 });
+  } catch {
+    // Couldn't persist — return an ephemeral id for this run rather than fail.
+  }
+  return id;
+}
+
 function normalizeText(s) {
   return String(s ?? "")
     .replace(/0x[0-9a-f]+/gi, "")
@@ -242,6 +271,9 @@ export function createReporter(config, pkg) {
   const allowManual = rep.allowManual !== false;
   const redact = makeRedactor(collectSecrets(config.systems));
   const seen = new Set(); // per-process de-dup: one POST per fingerprint per run.
+  // Only mint/read the install-id when reporting is on, so an opted-out install
+  // writes nothing and sends nothing.
+  const installId = enabled ? resolveInstallId() : null;
 
   // source = the x-report-source header (crash/adt-error use "sap-adt-mcp";
   // agent-initiated reports use "sap-adt-mcp-manual"). The relay routes on it.
@@ -265,6 +297,7 @@ export function createReporter(config, pkg) {
     return {
       kind,
       fingerprint,
+      install: installId,
       build: BUILD_FINGERPRINT,
       version: pkg.version,
       node: process.version,

package/src/tools/discovery.js

@@ -1,6 +1,6 @@
 import { objectUri, sourceUri } from "../object-uris.js";
 import { fetchPackageNodes } from "../node-structure.js";
-import { parseObjectReferences } from "../object-references.js";
+import { parseObjectReferences, parseUsageReferences } from "../object-references.js";
 import { errorResult, jsonResult, textResult } from "../result.js";
 import { OBJECT_TYPE_HINT, SYSTEM_HINT } from "./_shared.js";
 
@@ -279,23 +279,34 @@ export function register({ getClient }) {
 
     adt_where_used: async (args) => {
       const { client, name: sys } = getClient(args.system);
-      const uri = objectUri({ type: args.type, name: args.object, group: args.group });
+      let uri;
+      try {
+        uri = objectUri({ type: args.type, name: args.object, group: args.group });
+      } catch (err) {
+        // e.g. a function module (FUGR/FF) passed without its group — objectUri
+        // throws. Return a clean tool error instead of crashing (#74).
+        return textResult(`adt_where_used: ${err.message}`, true);
+      }
+      // The endpoint requires a real request body with a <usageReferenceRequest>
+      // root; the previous empty POST 400'd with "System expected the element
+      // usageReferenceRequest" on every object (#73). An empty <affectedObjects/>
+      // means "all usages of <uri>". Mirrors the reference client (abap-adt-api).
+      const body =
+        `<?xml version="1.0" encoding="UTF-8"?>` +
+        `<usagereferences:usageReferenceRequest xmlns:usagereferences="http://www.sap.com/adt/ris/usageReferences">` +
+        `<usagereferences:affectedObjects/>` +
+        `</usagereferences:usageReferenceRequest>`;
       const res = await client.request({
         method: "POST",
         path: "/sap/bc/adt/repository/informationsystem/usageReferences",
         query: { uri },
-        // Without this the server rejects the POST with 400 "Content type
-        // missing" — it hits DDIC objects (tables, structures) where the tool
-        // sent no request entity. The typed (empty) body is what ADT expects to
-        // mean "all usages of <uri>".
-        headers: {
-          "Content-Type":
-            "application/vnd.sap.adt.repository.usageReferences.request.v1+xml",
-        },
+        headers: { "Content-Type": "application/*" },
+        accept: "application/*",
+        body,
       });
       const text = await res.text();
       if (!res.ok) return errorResult(sys, res.status, text, res.headers.get("content-type"));
-      const refs = parseObjectReferences(text);
+      const refs = parseUsageReferences(text);
       return jsonResult({
         system: sys,
         object: args.object,

package/src/tools/quality.js

@@ -156,10 +156,17 @@ async function runAtcWorklist(client, sys, { uris, checkVariant, maxResults }) {
 }
 
 // Normalize a caller-supplied include context into an ADT object URI. Accepts a
-// full ADT path as-is; treats a bare token as a program name.
+// full ADT path as-is; treats anything else as a program name.
+//
+// A real ADT object URI begins with the ADT path prefix. A *namespaced* ABAP
+// name (e.g. "/FGLR/R_PO_ASSET_CREATE") also begins with "/", so keying on a
+// leading slash alone misclassified it as a ready-made URI and produced an
+// unmappable ?context= → 500 uriMappingError (#67). Only the ADT-path prefix
+// marks a ready URI; every other value — bare or namespaced — is a program name
+// whose slashes must be percent-encoded into the programs URI.
 export function toContextUri(input) {
   const s = String(input).trim();
-  if (s.startsWith("/")) return s;
+  if (s.startsWith("/sap/bc/adt/")) return s;
   return `/sap/bc/adt/programs/programs/${encodeURIComponent(s.toLowerCase())}`;
 }
 

package/src/tools/source.js

@@ -1,8 +1,36 @@
-import { sourceUri, objectUri, normalizeType, METADATA_XML_ACCEPT } from "../object-uris.js";
+import fs from "node:fs";
+import path from "node:path";
+import { sourceUri, objectUri, normalizeType, baseType, METADATA_XML_ACCEPT } from "../object-uris.js";
 import { acquireLock, releaseLock } from "../lock.js";
 import { errorResult, jsonResult, textResult } from "../result.js";
 import { OBJECT_TYPE_HINT, SYSTEM_HINT } from "./_shared.js";
 
+// Read a local file for a write. The MCP process reads it directly, so a large
+// object's source never has to travel back through the agent's per-call I/O cap
+// (#39). fs errors become a clean { ok:false } instead of a crash.
+function readLocalFile(p) {
+  try {
+    return { ok: true, content: fs.readFileSync(p, "utf8") };
+  } catch (err) {
+    const why = err.code === "ENOENT" ? "file not found" : err.message;
+    return { ok: false, error: why };
+  }
+}
+
+// Write fetched source straight to disk (symmetric to readLocalFile) so a big
+// read → edit → write round-trip can stay entirely on the filesystem. Creates
+// the parent directory if needed.
+function writeLocalFile(p, content) {
+  try {
+    const dir = path.dirname(p);
+    if (dir) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(p, content);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
 const TOP_LEVEL_KEYWORDS = [
   "CLASS",
   "INTERFACE",
@@ -120,7 +148,7 @@ export const tools = [
   {
     name: "adt_get_source",
     description:
-      "Fetch the ABAP source of an object (program, class, interface, function module, include, CDS, table). Returns plain text. DDIC primitives without plain-text source (data element, domain, message class) return their ADT XML metadata instead (format: 'xml'). For sources larger than the MCP per-call output cap (~64 KB), use firstLine/lastLine to paginate or onlyMethod to slice a single method body.",
+      "Fetch the ABAP source of an object (program, class, interface, function module, include, CDS, table). Returns plain text. DDIC primitives without plain-text source (data element, domain, message class) return their ADT XML metadata instead (format: 'xml'). For sources larger than the MCP per-call output cap (~64 KB), use firstLine/lastLine to paginate or onlyMethod to slice a single method body — or pass `outputFile` to write the full source straight to disk (then edit it and write it back with adt_set_source `sourceFile`, keeping large objects entirely off the agent's I/O path).",
     inputSchema: {
       type: "object",
       properties: {
@@ -152,6 +180,11 @@ export const tools = [
           description:
             "Return only the METHOD <name> ... ENDMETHOD block (case-insensitive). Returns metadata about the slice (startLine, endLine). Convenient for inspecting one method of a large class without paginating manually.",
         },
+        outputFile: {
+          type: "string",
+          description:
+            "Local file path to write the source to instead of returning it inline. The response carries metadata (bytesWritten, totalLines) but omits `source`, so an arbitrarily large object can be fetched without hitting the output cap. Respects firstLine/lastLine/onlyMethod when set (otherwise writes the full source).",
+        },
       },
       required: ["object", "type"],
     },
@@ -159,7 +192,7 @@ export const tools = [
   {
     name: "adt_set_source",
     description:
-      "Replace the ABAP source of an object. The supplied `source` is the FULL text of the include — it ATOMICALLY REPLACES the entire include on the server. Passing a partial chunk or diff will delete the rest of the include. Orchestrates lock → PUT → unlock automatically. Requires read-only mode to be off for the target system.",
+      "Replace the ABAP source of an object. The new source is the FULL text of the include — it ATOMICALLY REPLACES the entire include on the server. Passing a partial chunk or diff will delete the rest of the include. Supply the source inline via `source`, OR — for a large object that would blow the per-call I/O cap — via `sourceFile` (a local path the MCP process reads itself). Orchestrates lock → PUT → unlock automatically. Requires read-only mode to be off for the target system.",
     inputSchema: {
       type: "object",
       properties: {
@@ -175,7 +208,12 @@ export const tools = [
         source: {
           type: "string",
           description:
-            "New ABAP source code — FULL text of the include. Atomic replace. Do not pass a partial diff.",
+            "New ABAP source code — FULL text of the include. Atomic replace. Do not pass a partial diff. Mutually exclusive with `sourceFile`.",
+        },
+        sourceFile: {
+          type: "string",
+          description:
+            "Local file path whose contents become the new FULL source. The MCP process reads the file, so there is no size ceiling — use this for large objects (e.g. a multi-thousand-line class) that cannot be passed inline. Mutually exclusive with `source`.",
         },
         transport: {
           type: "string",
@@ -193,7 +231,7 @@ export const tools = [
             "Set to true to bypass the partial-source guard (e.g. when writing a content-free or fragment include intentionally). The guard rejects sources whose first non-comment line does not start with a recognized top-level ABAP construct keyword.",
         },
       },
-      required: ["object", "type", "source"],
+      required: ["object", "type"],
     },
   },
   {
@@ -273,23 +311,35 @@ export function register({ getClient }) {
   return {
     adt_get_source: async (args) => {
       if (typeof args.object !== "string" || args.object.length === 0) {
-        const hint =
-          args.name !== undefined
-            ? " (you passed `name` — the field is `object`)"
-            : "";
+        const wrong =
+          args.object_name !== undefined
+            ? "object_name"
+            : args.name !== undefined
+              ? "name"
+              : null;
+        const hint = wrong ? ` (you passed \`${wrong}\` — the field is \`object\`)` : "";
         return textResult(
           `adt_get_source: \`object\` is required${hint}. Also use \`firstLine\`/\`lastLine\` (not \`line\`/\`endLine\`) to paginate.`,
           true
         );
       }
       if (typeof args.type !== "string" || args.type.length === 0) {
-        return textResult("adt_get_source: `type` is required (e.g. 'class', 'program', 'dataelement').", true);
+        const hint =
+          args.object_type !== undefined
+            ? " (you passed `object_type` — the field is `type`)"
+            : "";
+        return textResult(
+          `adt_get_source: \`type\` is required${hint} (e.g. 'class', 'program', 'dataelement').`,
+          true
+        );
       }
       const { client, name: sys } = getClient(args.system);
       let t;
       let path;
       try {
-        t = normalizeType(args.type);
+        // Collapse decorative subtypes (DOMA/DD → DOMA) so the metadata-XML
+        // Accept lookup below matches; sourceUri collapses internally already.
+        t = baseType(args.type);
         path = sourceUri({
           type: args.type,
           name: args.object,
@@ -315,17 +365,24 @@ export function register({ getClient }) {
         const res = await client.request({ path, accept: metaAccept });
         const text = await res.text();
         if (!res.ok) return errorResult(sys, res.status, text, res.headers.get("content-type"));
-        return jsonResult({
+        const xmlMeta = {
           system: sys,
           object: args.object,
           type: t,
           path,
           format: "xml",
-          source: text,
           bytes: text.length,
           totalLines: text.split(/\r?\n/).length,
           note: `${t} has no plain-text source; returning ADT XML metadata (${metaAccept.split("+")[0]}+xml).`,
-        });
+        };
+        if (args.outputFile) {
+          const w = writeLocalFile(args.outputFile, text);
+          if (!w.ok) {
+            return errorResult(sys, 500, `Could not write outputFile ${JSON.stringify(args.outputFile)}: ${w.error}`, "text/plain", { stage: "output" });
+          }
+          return jsonResult({ ...xmlMeta, outputFile: args.outputFile, bytesWritten: text.length });
+        }
+        return jsonResult({ ...xmlMeta, source: text });
       }
 
       const res = await client.request({ path, accept: "text/plain" });
@@ -374,12 +431,11 @@ export function register({ getClient }) {
       }
 
       const slice = allLines.slice(sliceFirst - 1, sliceLast).join("\n");
-      return jsonResult({
+      const meta = {
         system: sys,
         object: args.object,
         type: normalizeType(args.type),
         path,
-        source: slice,
         bytes: slice.length,
         lines: sliceLast - sliceFirst + 1,
         totalLines,
@@ -388,13 +444,70 @@ export function register({ getClient }) {
         lastLine: sliceLast,
         scope,
         truncated: scope !== "full",
-      });
+      };
+      if (args.outputFile) {
+        const w = writeLocalFile(args.outputFile, slice);
+        if (!w.ok) {
+          return errorResult(sys, 500, `Could not write outputFile ${JSON.stringify(args.outputFile)}: ${w.error}`, "text/plain", { stage: "output" });
+        }
+        return jsonResult({ ...meta, outputFile: args.outputFile, bytesWritten: slice.length });
+      }
+      return jsonResult({ ...meta, source: slice });
     },
 
     adt_set_source: async (args) => {
       const { client, name: sys } = getClient(args.system);
-      if (!args.acknowledgePartial) {
-        const partialReason = detectPartialSource(args.source);
+
+      // Resolve the new source from either inline `source` or a local
+      // `sourceFile` (read here by the MCP, so large objects bypass the agent's
+      // I/O cap — #39). Exactly one of the two must be supplied.
+      const hasInline = typeof args.source === "string";
+      const hasFile = typeof args.sourceFile === "string" && args.sourceFile.length > 0;
+      if (hasInline && hasFile) {
+        return textResult("adt_set_source: pass either `source` or `sourceFile`, not both.", true);
+      }
+      if (!hasInline && !hasFile) {
+        return textResult(
+          "adt_set_source: `source` (inline full text) or `sourceFile` (local path) is required.",
+          true
+        );
+      }
+      let source = args.source;
+      if (hasFile) {
+        const rd = readLocalFile(args.sourceFile);
+        if (!rd.ok) {
+          return textResult(
+            `adt_set_source: could not read sourceFile ${JSON.stringify(args.sourceFile)}: ${rd.error}.`,
+            true
+          );
+        }
+        source = rd.content;
+      }
+
+      let metaType = null;
+      let objUri;
+      let srcPath;
+      try {
+        // DDIC primitives (domain / data element / message class) are edited as
+        // XML metadata, so their PUT uses the resource media type, not text/plain.
+        metaType = METADATA_XML_ACCEPT[baseType(args.type)] ?? null;
+        objUri = objectUri({ type: args.type, name: args.object, group: args.group });
+        srcPath = sourceUri({
+          type: args.type,
+          name: args.object,
+          group: args.group,
+          include: args.include,
+        });
+      } catch (err) {
+        // Bad/unknown type, or a function module without its group — return a
+        // clean error instead of crashing (cf. #65/#74).
+        return textResult(`adt_set_source: ${err.message}`, true);
+      }
+
+      // The partial-source guard only makes sense for plain ABAP text; XML
+      // metadata (metaType set) never starts with an ABAP keyword, so skip it.
+      if (!metaType && !args.acknowledgePartial) {
+        const partialReason = detectPartialSource(source);
         if (partialReason) {
           return errorResult(sys, 422, partialReason, "text/plain", {
             stage: "validate",
@@ -402,17 +515,6 @@ export function register({ getClient }) {
           });
         }
       }
-      const objUri = objectUri({
-        type: args.type,
-        name: args.object,
-        group: args.group,
-      });
-      const srcPath = sourceUri({
-        type: args.type,
-        name: args.object,
-        group: args.group,
-        include: args.include,
-      });
 
       const externalLock = typeof args.lockHandle === "string" && args.lockHandle.length > 0;
       let handle = args.lockHandle;
@@ -435,10 +537,10 @@ export function register({ getClient }) {
           path: srcPath,
           query: putQuery,
           headers: {
-            "Content-Type": "text/plain; charset=utf-8",
+            "Content-Type": metaType ? metaType : "text/plain; charset=utf-8",
             "X-sap-adt-sessiontype": "stateful",
           },
-          body: args.source,
+          body: source,
         });
         const putText = await putRes.text();
         if (!putRes.ok) {

package/src/tools/transports.js

@@ -42,7 +42,7 @@ export const tools = [
   {
     name: "adt_create_transport",
     description:
-      "Create a new transport request. Returns the new TR number. Subject to read-only mode.",
+      "Create a new transport request. Returns the new TR number. Subject to read-only mode. Note: on some systems TR *creation* routes through a SAP GUI dialog and fails headless with a 500 (SAPLSTRD/SAPLSPO4 'No window system type'). Assigning changes to an EXISTING request works headless — pass that TR id as `transport` to adt_lock / adt_set_source instead.",
     inputSchema: {
       type: "object",
       properties: {
@@ -118,10 +118,18 @@ export function register({ getClient }) {
     adt_create_transport: async (args) => {
       const { client, name: sys, profile } = getClient(args.system);
       const trType = args.type ?? "K";
+      // Only emit tm:target when a real target is given. Sending tm:target=""
+      // (the old default) makes some systems reject the create with an opaque
+      // 500 — the same blank-value hazard as a whitespace corrNr (#68/#63).
+      // Omitting it lets CTS apply the connection's default consolidation route.
+      const targetAttr =
+        typeof args.target === "string" && args.target.trim()
+          ? ` tm:target="${escapeXml(args.target.trim())}"`
+          : "";
       const xml =
         `<?xml version="1.0" encoding="UTF-8"?>` +
         `<tm:root xmlns:tm="http://www.sap.com/cts/adt/tm" tm:useraction="newrequest">` +
-        `<tm:request tm:desc="${escapeXml(args.description)}" tm:type="${trType}" tm:target="${escapeXml(args.target ?? "")}" tm:cliDep="X">` +
+        `<tm:request tm:desc="${escapeXml(args.description)}" tm:type="${trType}"${targetAttr} tm:cliDep="X">` +
         `<tm:user tm:name="${escapeXml(profile.user.toUpperCase())}"/>` +
         `</tm:request>` +
         `</tm:root>`;