sap-adt-mcp 0.8.42 → 0.8.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sap-adt-mcp",
-  "version": "0.8.42",
+  "version": "0.8.44",
   "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",

package/src/object-create.js

@@ -201,6 +201,48 @@ export function buildCreateRequest({
   }
 }
 
+// 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).
+export function mediaTypeFallbacks(contentType) {
+  const m = /^(.*\.)v(\d+)(\+xml)$/.exec(contentType);
+  if (!m) return [contentType];
+  const [, prefix, ver, suffix] = m;
+  const chain = [];
+  for (let v = Number(ver); v >= 1; v--) {
+    chain.push(`${prefix}v${v}${suffix}`);
+  }
+  return chain;
+}
+
+// POST a create request, retrying with successively lower media-type versions
+// when the server rejects the content-type with 415. Returns
+// { res, text, contentType } for the first attempt that is not a 415 — or the
+// last attempt if every version is rejected. The body is read once here so
+// callers must use the returned `text` rather than calling res.text() again.
+export async function postCreate(client, { path, contentType, body, query }) {
+  const types = mediaTypeFallbacks(contentType);
+  let res;
+  let text;
+  let used;
+  for (let i = 0; i < types.length; i++) {
+    used = types[i];
+    res = await client.request({
+      method: "POST",
+      path,
+      query,
+      headers: { "Content-Type": used },
+      body,
+    });
+    text = await res.text();
+    if (res.status !== 415 || i === types.length - 1) break;
+  }
+  return { res, text, contentType: used };
+}
+
 function xmlDecl() {
   return `<?xml version="1.0" encoding="UTF-8"?>`;
 }

package/src/object-uris.js

@@ -73,8 +73,21 @@ export function normalizeType(input) {
   return aliased ?? upper;
 }
 
+// ADT types arrive either as a bare key (CLAS, SRVD) or in TADIR-style
+// TYPE/SUBTYPE form (SRVD/SRV, CLAS/OC, DDLS/DF). The subtype only changes the
+// endpoint for function-group members (FUGR/FF module, FUGR/I include); for
+// every other kind it is decoration, so collapse X/Y to its base type X. Without
+// this, a TYPE/SUBTYPE input misses the dispatch table and throws "Unsupported
+// object type".
+function collapseSubtype(t) {
+  if (t.includes("/") && t !== "FUGR/FF" && t !== "FUGR/I") {
+    return t.split("/")[0];
+  }
+  return t;
+}
+
 export function objectUri({ type, name, group }) {
-  const t = normalizeType(type);
+  const t = collapseSubtype(normalizeType(type));
   if (typeof name !== "string" || name.length === 0) {
     throw new Error("Object name is required");
   }
@@ -145,7 +158,7 @@ export const METADATA_XML_ACCEPT = {
 };
 
 export function sourceUri({ type, name, group, include }) {
-  const t = normalizeType(type);
+  const t = collapseSubtype(normalizeType(type));
   const base = objectUri({ type: t, name, group });
 
   if (t === "CLAS") {

package/src/tools/cds.js

@@ -1,7 +1,7 @@
 import { objectUri } from "../object-uris.js";
 import { parseDataPreview } from "../data-preview.js";
 import { parseObjectReferences } from "../object-references.js";
-import { errorResult, jsonResult } from "../result.js";
+import { errorResult, jsonResult, textResult } from "../result.js";
 import { SYSTEM_HINT } from "./_shared.js";
 
 const CDS_PREVIEW_PATH = "/sap/bc/adt/datapreview/cds";
@@ -86,12 +86,21 @@ export const tools = [
 export function register({ getClient }) {
   return {
     adt_cds_data_preview: async (args) => {
+      // `entity` is the documented field, but callers reach for `name`/`cdsName`;
+      // accept those too and fail cleanly rather than throwing on `.toUpperCase`.
+      const entity = args.entity ?? args.name ?? args.cdsName;
+      if (typeof entity !== "string" || entity.length === 0) {
+        return textResult(
+          "adt_cds_data_preview: `entity` is required (the CDS view/entity name, e.g. 'I_CompanyCode').",
+          true
+        );
+      }
       const { client, name: sys } = getClient(args.system);
       const max = Math.min(args.maxRows ?? DEFAULT_MAX_ROWS, HARD_CAP_ROWS);
       const res = await client.request({
         method: "POST",
         path: CDS_PREVIEW_PATH,
-        query: { ddlSourceName: args.entity.toUpperCase(), rowNumber: String(max) },
+        query: { ddlSourceName: entity.toUpperCase(), rowNumber: String(max) },
         accept: "application/xml",
       });
       const text = await res.text();
@@ -100,12 +109,12 @@ export function register({ getClient }) {
       try {
         parsed = parseDataPreview(text);
       } catch (err) {
-        return jsonResult({ system: sys, entity: args.entity, parseError: err.message, raw: text.slice(0, 8000) });
+        return jsonResult({ system: sys, entity, parseError: err.message, raw: text.slice(0, 8000) });
       }
       const rowCount = parsed.rows.length;
       return jsonResult({
         system: sys,
-        entity: args.entity.toUpperCase(),
+        entity: entity.toUpperCase(),
         rowCount,
         truncated: rowCount >= max,
         totalRows: parsed.totalRows,
@@ -116,8 +125,15 @@ export function register({ getClient }) {
     },
 
     adt_cds_dependencies: async (args) => {
+      const entity = args.entity ?? args.name ?? args.cdsName;
+      if (typeof entity !== "string" || entity.length === 0) {
+        return textResult(
+          "adt_cds_dependencies: `entity` is required (the CDS view/entity name, e.g. 'I_CompanyCode').",
+          true
+        );
+      }
       const { client, name: sys } = getClient(args.system);
-      const uri = objectUri({ type: "ddls", name: args.entity });
+      const uri = objectUri({ type: "ddls", name: entity });
       const res = await client.request({ path: GRAPHDATA_PATH, query: { uri }, accept: "application/xml" });
       const text = await res.text();
       if (!res.ok) return errorResult(sys, res.status, text, res.headers.get("content-type"), { stage: "graphdata" });
@@ -131,7 +147,7 @@ export function register({ getClient }) {
       }
       return jsonResult({
         system: sys,
-        entity: args.entity.toUpperCase(),
+        entity: entity.toUpperCase(),
         uri,
         dependencyCount: refs.length,
         dependencies: refs,

package/src/tools/discovery.js

@@ -315,8 +315,9 @@ export function register({ getClient }) {
 
     adt_list_packages: async (args) => {
       // `package` is the field name on the sibling adt_browse_package tool, so
-      // callers reach for it here too — accept it as an alias for `root`.
-      const rootArg = args.root ?? args.package;
+      // callers reach for it here too — accept it (and a bare `name`) as an
+      // alias for `root`.
+      const rootArg = args.root ?? args.package ?? args.name;
       if (typeof rootArg !== "string" || rootArg.length === 0) {
         return textResult(
           "adt_list_packages: `root` is required (the root package to walk from, e.g. 'ZFLEET').",

package/src/tools/lifecycle.js

@@ -1,7 +1,7 @@
 import { objectUri, normalizeType } from "../object-uris.js";
 import { escapeXml } from "../xml.js";
 import { acquireLock, releaseLock } from "../lock.js";
-import { buildCreateRequest } from "../object-create.js";
+import { buildCreateRequest, postCreate } from "../object-create.js";
 import { errorResult, jsonResult, textResult } from "../result.js";
 import { OBJECT_TYPE_HINT, SYSTEM_HINT } from "./_shared.js";
 
@@ -199,14 +199,12 @@ export function register({ getClient }) {
       }
       const query = {};
       if (args.transport) query.corrNr = args.transport;
-      const res = await client.request({
-        method: "POST",
+      const { res, text } = await postCreate(client, {
         path: req.path,
-        query,
-        headers: { "Content-Type": req.contentType },
+        contentType: req.contentType,
         body: req.body,
+        query,
       });
-      const text = await res.text();
       if (!res.ok) return errorResult(sys, res.status, text, res.headers.get("content-type"));
       const newUri = objectUri({
         type: args.type,

package/src/tools/rap.js

@@ -1,4 +1,4 @@
-import { buildCreateRequest } from "../object-create.js";
+import { buildCreateRequest, postCreate } from "../object-create.js";
 import { sourceUri } from "../object-uris.js";
 import { acquireLock, releaseLock } from "../lock.js";
 import { escapeXml } from "../xml.js";
@@ -159,15 +159,13 @@ function createInfoFor(artifact, spec) {
 
 async function createAndWrite(client, artifact, spec) {
   const info = createInfoFor(artifact, spec);
-  // 1) create the object
-  const createRes = await client.request({
-    method: "POST",
+  // 1) create the object (retrying with lower media-type versions on 415)
+  const { res: createRes, text: createText } = await postCreate(client, {
     path: info.path,
-    headers: { "Content-Type": info.contentType },
-    query: spec.transport ? { corrNr: spec.transport } : undefined,
+    contentType: info.contentType,
     body: info.body,
+    query: spec.transport ? { corrNr: spec.transport } : undefined,
   });
-  const createText = await createRes.text();
   if (!createRes.ok) {
     return { name: artifact.name, stage: "create", status: createRes.status, error: createText.slice(0, 400) };
   }

package/src/tools/source.js

@@ -286,13 +286,26 @@ export function register({ getClient }) {
         return textResult("adt_get_source: `type` is required (e.g. 'class', 'program', 'dataelement').", true);
       }
       const { client, name: sys } = getClient(args.system);
-      const t = normalizeType(args.type);
-      const path = sourceUri({
-        type: args.type,
-        name: args.object,
-        group: args.group,
-        include: args.include,
-      });
+      let t;
+      let path;
+      try {
+        t = normalizeType(args.type);
+        path = sourceUri({
+          type: args.type,
+          name: args.object,
+          group: args.group,
+          include: args.include,
+        });
+      } catch (err) {
+        // Unknown/unsupported object types (e.g. WAPA) reach the dispatch
+        // tables and throw. Return that as a clean tool error with an escape
+        // hatch hint instead of letting it surface as a crash.
+        return textResult(
+          `adt_get_source: ${err.message}. If this type has no high-level mapping yet, ` +
+            `fetch it with adt_request against its ADT source URI.`,
+          true
+        );
+      }
 
       // DDIC primitives (data element / domain / message class) have no
       // plain-text source — fetch their XML metadata with the right media type