sap-ai-dev-toolkit 0.4.5 → 0.5.5

package/src/setup.mjs

@@ -167,8 +167,9 @@ function printConnectionInstructions(output, result) {
   print(output, '');
   print(output, colorText('📡 MCP servers now available:', 'cyan', output));
   for (const [name, entry] of servers) {
-    const detail = entry.env?.BAS_VSP_DESTINATION
-      ? `destination: ${entry.env.BAS_VSP_DESTINATION}`
+    const destinationName = entry.env?.SAP_AI_DEV_TOOLKIT_DESTINATION || entry.env?.BAS_VSP_DESTINATION;
+    const detail = destinationName
+      ? `destination: ${destinationName}`
       : (entry.displayName ? `tool server: ${entry.displayName}` : 'tool server');
     print(output, `  • ${name} — ${detail}`);
   }

package/test/bas-destination-relay.test.mjs

@@ -17,11 +17,21 @@ function sapLikeBackend({
   genericForbidden = false,
   partialRefreshCookies = false,
   omitCookies = false,
-  setCookieOnSafeGet = false
+  setCookieOnSafeGet = false,
+  secureSessionCookie = false,
+  postOnlyPaths = [],
+  acceptTokenWithoutCookies = false
 } = {}) {
   const state = { sessionCounter: 0, requests: [] };
   const server = http.createServer((req, res) => {
     state.requests.push({ method: req.method, path: req.url, headers: { ...req.headers } });
+    // POST-only services (ADT data preview among them) reject every GET,
+    // including CSRF token fetches, the way real SAP does.
+    if (req.method === 'GET' && postOnlyPaths.some(prefix => req.url.startsWith(prefix))) {
+      res.writeHead(405, { allow: 'POST' });
+      res.end('<method-not-allowed/>');
+      return;
+    }
     if (req.method === 'GET' && req.headers['x-csrf-token'] === 'Fetch') {
       state.sessionCounter += 1;
       const headers = { 'x-csrf-token': `token-${state.sessionCounter}` };
@@ -35,6 +45,7 @@ function sapLikeBackend({
             ? 'sap-stale=delete-me; path=/'
             : 'sap-stale=; Expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/');
         }
+        if (secureSessionCookie) headers['set-cookie'].push('sap-secure=secure-value; Secure; Path=/');
       }
       res.writeHead(200, headers);
       res.end('<ok/>');
@@ -61,12 +72,16 @@ function sapLikeBackend({
       const match = String(token || '').match(/^token-(\d+)$/);
       // Without rotation any still-live token+cookie pair is accepted; with
       // rotation only the newest issued session remains valid, matching SAP
-      // server-side session invalidation.
-      const valid = match
-        && cookie.includes(`sap-session-${match[1]}=`)
-        && (!rotateOnFetch || Number(match[1]) === state.sessionCounter)
-        && (!partialRefreshCookies || cookie.includes('sap-usercontext=sap-client=100'))
-        && (!partialRefreshCookies || Number(match[1]) === 1 || !cookie.includes('sap-stale='));
+      // server-side session invalidation. acceptTokenWithoutCookies models a
+      // BAS proxy route where Set-Cookie is stripped yet the backend honors
+      // the token on the proxy-established Basic-auth session.
+      const valid = acceptTokenWithoutCookies
+        ? Boolean(match)
+        : match
+          && cookie.includes(`sap-session-${match[1]}=`)
+          && (!rotateOnFetch || Number(match[1]) === state.sessionCounter)
+          && (!partialRefreshCookies || cookie.includes('sap-usercontext=sap-client=100'))
+          && (!partialRefreshCookies || Number(match[1]) === 1 || !cookie.includes('sap-stale='));
       if (!valid) {
         res.writeHead(403, { 'x-csrf-token': 'Required' });
         res.end('CSRF token validation failed');
@@ -133,6 +148,22 @@ test('pairs CSRF token with its session cookies so unsafe requests succeed', asy
   });
 });
 
+test('fetches the CSRF token from a GET-capable endpoint when the target is POST-only (ADT data preview)', async () => {
+  await withBackend({ postOnlyPaths: ['/sap/bc/adt/datapreview'] }, async ({ relayUrl, state }) => {
+    const response = await relayFetch(relayUrl, '/sap/bc/adt/datapreview/freestyle', {
+      method: 'POST',
+      headers: { accept: 'application/xml' },
+      body: '<query/>'
+    });
+    assert.equal(response.status, 201, `expected 201, got ${response.status}: ${response.body}`);
+    const tokenFetch = state.requests.find(request => request.headers['x-csrf-token'] === 'Fetch');
+    assert.equal(tokenFetch.path, '/sap/bc/adt/discovery', 'token must be fetched from the GET-capable discovery endpoint');
+    const post = state.requests.find(request => request.method === 'POST');
+    assert.match(post.headers['x-csrf-token'], /^token-\d+$/);
+    assert.match(String(post.headers.cookie), /sap-session-\d+=/);
+  });
+});
+
 test('reuses the cached CSRF session for subsequent unsafe requests', async () => {
   await withBackend(null, async ({ relay, relayUrl, state }) => {
     await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
@@ -145,6 +176,30 @@ test('reuses the cached CSRF session for subsequent unsafe requests', async () =
   });
 });
 
+test('coalesces concurrent CSRF token fetches for the same ADT endpoint', async () => {
+  await withBackend(null, async ({ relayUrl, state }) => {
+    const responses = await Promise.all([
+      relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' }),
+      relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<y/>' })
+    ]);
+    assert.deepEqual(responses.map(response => response.status), [201, 201]);
+    assert.equal(state.requests.filter(request => request.headers['x-csrf-token'] === 'Fetch').length, 1);
+    assert.equal(state.requests.filter(request => request.method === 'POST').length, 2);
+  });
+});
+
+test('seeds the relay cookie jar from the incoming MCP request cookie', async () => {
+  await withBackend(null, async ({ relayUrl, state }) => {
+    await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', {
+      method: 'POST',
+      headers: { cookie: 'sap-initial-session=from-vsp' },
+      body: '<x/>'
+    });
+    const tokenFetch = state.requests.find(request => request.headers['x-csrf-token'] === 'Fetch');
+    assert.match(String(tokenFetch.headers.cookie), /sap-initial-session=from-vsp/);
+  });
+});
+
 test('self-heals when SAP rotates the session: refetches token and cookies', async () => {
   await withBackend({ rotateOnFetch: true }, async ({ relay, relayUrl, state }) => {
     // A first POST establishes session token-1. SAP then invalidates it
@@ -190,12 +245,22 @@ test('does not retry generic authorization failures as CSRF errors', async () =>
   });
 });
 
-test('does not repeat a CSRF failure when SAP returns a token without session cookies', async () => {
+test('sends a cookie-less token once and surfaces the rejection without retrying', async () => {
   await withBackend({ omitCookies: true }, async ({ relayUrl, relay, state }) => {
     const response = await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
-    assert.equal(response.status, 503, `unsafe calls must fail closed without a paired session, got ${response.status}`);
-    assert.equal(state.requests.filter(request => request.method === 'POST').length, 0);
-    assert.equal(relay.stats.csrfRetries, 0);
+    assert.equal(response.status, 403, `a cookie-less session must surface SAP's verdict, got ${response.status}`);
+    assert.equal(state.requests.filter(request => request.method === 'POST').length, 1);
+    assert.equal(relay.stats.csrfRetries, 0, 'a cookie-less route cannot be fixed by a retry');
+  });
+});
+
+test('completes unsafe requests with a token-only session when the route strips cookies (BAS proxy)', async () => {
+  await withBackend({ omitCookies: true, acceptTokenWithoutCookies: true }, async ({ relayUrl, relay, state }) => {
+    const response = await relayFetch(relayUrl, '/sap/bc/adt/datapreview/freestyle', { method: 'POST', body: '<query/>' });
+    assert.equal(response.status, 201, `expected 201, got ${response.status}: ${response.body}`);
+    const post = state.requests.find(request => request.method === 'POST');
+    assert.match(post.headers['x-csrf-token'], /^token-\d+$/);
+    assert.equal(relay.stats.csrfSessionFailures, 0);
   });
 });
 
@@ -218,6 +283,17 @@ test('honors the configured bounded CSRF retry count', async () => {
   });
 });
 
+test('uses the default for invalid retry settings and caps excessive retry counts', async () => {
+  await withBackend({ neverAcceptUnsafe: true, env: { SAP_AI_DEV_TOOLKIT_MAX_CSRF_RETRIES: '1.5' } }, async ({ relayUrl, state }) => {
+    await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
+    assert.equal(state.requests.filter(request => request.method === 'POST').length, 4, 'invalid values use the default of three retries');
+  });
+  await withBackend({ neverAcceptUnsafe: true, env: { SAP_AI_DEV_TOOLKIT_MAX_CSRF_RETRIES: '100' } }, async ({ relayUrl, state }) => {
+    await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
+    assert.equal(state.requests.filter(request => request.method === 'POST').length, 11, 'retry counts are capped at ten');
+  });
+});
+
 test('prefers the documented branded proxy setting including an explicit direct-connection override', async t => {
   let dispatchedWithProxy = false;
   const relay = createBasDestinationRelay(
@@ -287,7 +363,7 @@ test('falls back to a proxy tunnel when the absolute-form request is refused', a
 });
 
 test('keeps OnPremise Basic auth on a BAS proxy tunnel and verifies the CSRF session', async t => {
-  const { state, server } = sapLikeBackend();
+  const { state, server } = sapLikeBackend({ secureSessionCookie: true });
   const backendPort = await startServer(server);
   const connectTargets = [];
   const proxy = http.createServer();
@@ -322,13 +398,16 @@ test('keeps OnPremise Basic auth on a BAS proxy tunnel and verifies the CSRF ses
   });
 
   const probe = await relay.probeCsrfSession();
-  assert.deepEqual(probe, { httpStatus: 200, tokenReceived: true, cookieCount: 2, sessionUsable: true });
+  assert.deepEqual(probe, { httpStatus: 200, tokenReceived: true, cookieCount: 3, sessionUsable: true });
   const response = await relayFetch(relayUrl, '/sap/bc/adt/oo/classes', { method: 'POST', body: '<x/>' });
   assert.equal(response.status, 201, `expected a paired CSRF session, got ${response.status}: ${response.body}`);
   const post = state.requests.find(request => request.method === 'POST');
   assert.match(post.headers.authorization, /^Basic /);
   assert.match(String(post.headers.cookie), /sap-session-\d+=/);
-  assert.ok(connectTargets.length >= 2);
+  assert.match(String(post.headers.cookie), /sap-secure=secure-value/, 'Secure SAP cookies must be sent through the HTTPS-backed BAS .dest route');
+  // The POST reuses the probe's cached CSRF session (tokens are shared across
+  // paths), so a single pooled tunnel connection can carry both requests.
+  assert.ok(connectTargets.length >= 1, 'upstream traffic must reach the backend through the BAS proxy tunnel');
   assert.ok(connectTargets.every(target => target === 'cc-system.dest:80'));
   assert.equal(relay.stats.direct, false);
   assert.equal(relay.stats.proxyTunnel, true);

package/test/cf-runtime.test.mjs

@@ -298,7 +298,7 @@ test('routes a PrincipalPropagation MCP call through CF Connectivity to the SAP
   }, [], [
     { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } },
     { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} },
-    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'pp-target__GetSystemInfo', arguments: {} } }
+    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'sap_system_pp-target_get_system_info', arguments: {} } }
   ]);
   assert.equal(result.code, 0, `${result.stdout}\\n${result.stderr}`);
   const responses = result.stdout.trim().split('\n').map(line => JSON.parse(line));
@@ -455,7 +455,7 @@ test('overrides CF Basic OnPremise backend auth while retaining the HTTP Connect
   }, [], [
     { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } },
     { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} },
-    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'basic-onprem__GetSystemInfo', arguments: {} } }
+    { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'sap_system_basic-onprem_get_system_info', arguments: {} } }
   ]);
 
   assert.equal(result.code, 0, `${result.stdout}\n${result.stderr}`);

package/test/discovery.test.mjs

@@ -47,6 +47,31 @@ test('accepts the previous destination environment variable during upgrades', as
   });
   assert.deepEqual(destinations.map(destination => destination.name), ['legacy-system']);
 });
+
+test('probes destinations concurrently while preserving order', async () => {
+  const body = [{ Name: 'c-system' }, { Name: 'a-system' }, { Name: 'b-system' }];
+  const started = [];
+  const release = [];
+  const probeImpl = url => new Promise(resolve => {
+    started.push(url);
+    release.push(() => resolve({ status: 200 }));
+  });
+  const discovery = discoverDestinations({ body, env: {}, probeImpl });
+  await new Promise(resolve => setTimeout(resolve, 100));
+  assert.equal(started.length, 3, 'all probes must be in flight at once');
+  assert.deepEqual(started, [
+    'http://a-system.dest/sap/bc/adt/discovery',
+    'http://b-system.dest/sap/bc/adt/discovery',
+    'http://c-system.dest/sap/bc/adt/discovery'
+  ], 'probes start in sorted destination order');
+  for (const resolve of release) resolve();
+  const destinations = await discovery;
+  assert.deepEqual(destinations.map(destination => [destination.name, destination.probe.status]), [
+    ['a-system', 'available'],
+    ['b-system', 'available'],
+    ['c-system', 'available']
+  ]);
+});
 test('parses sample-style destination records and enables every ADT heartbeat response', async () => {
   const body = [
     {
@@ -231,6 +256,26 @@ test('fetches BAS destination lists through configured HTTP and HTTPS proxies',
   assert.equal(proxyRequests.length, 2);
 });
 
+test('branded HTTP proxy takes precedence over HTTPS_PROXY for secure BAS discovery', async () => {
+  let capturedDispatcher = 'not-called';
+  const body = await fetchDestinationList('https://bas.example', {
+    env: {
+      SAP_AI_DEV_TOOLKIT_HTTP_PROXY: '',
+      HTTPS_PROXY: 'http://127.0.0.1:1',
+      https_proxy: 'http://127.0.0.1:1'
+    },
+    fetchImpl: async (_url, options) => {
+      capturedDispatcher = options.dispatcher;
+      return new Response(JSON.stringify([{ Name: 'secure-system' }]), {
+        status: 200,
+        headers: { 'content-type': 'application/json' }
+      });
+    }
+  });
+  assert.deepEqual(body, [{ Name: 'secure-system' }]);
+  assert.equal(capturedDispatcher, undefined, 'explicit branded empty proxy must disable inherited HTTPS_PROXY too');
+});
+
 test('redacts credential-bearing diagnostics without exposing payloads', () => {
   const value = redact({ name: 'dev', password: 'secret', authorization: 'Bearer abc', nested: { cookie: 'x', ok: 'visible' } });
   assert.deepEqual(value, { name: 'dev', password: '[redacted]', authorization: '[redacted]', nested: { cookie: '[redacted]', ok: 'visible' } });

package/test/fixtures/fake-vsp.mjs

@@ -9,7 +9,7 @@ const destination = url.replace(/^https?:\/\//, '').replace(/\.dest$/, '');
 const logPath = process.env.FAKE_LOG;
 function log(entry) { if (logPath) appendFileSync(logPath, `${JSON.stringify({ destination, ...entry })}\n`); }
 function reply(id, result) { process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id, result })}\n`); }
-function requestADTThroughProxy(targetUrl, proxyUrl, { method = 'GET', body = '' } = {}) {
+function requestADTThroughProxy(targetUrl, proxyUrl, { method = 'GET', body = '', bypassProxyForLoopback = false } = {}) {
   const target = new URL(targetUrl);
   const proxy = new URL(proxyUrl);
   if (target.protocol !== 'http:') throw new Error('fixture ADT request supports HTTP only');
@@ -18,7 +18,7 @@ function requestADTThroughProxy(targetUrl, proxyUrl, { method = 'GET', body = ''
   if (process.env.SAP_USER && process.env.SAP_PASSWORD) {
     headers.authorization = `Basic ${Buffer.from(`${process.env.SAP_USER}:${process.env.SAP_PASSWORD}`).toString('base64')}`;
   }
-  const loopback = ['127.0.0.1', 'localhost'].includes(target.hostname);
+  const loopback = bypassProxyForLoopback && ['127.0.0.1', 'localhost'].includes(target.hostname);
   return new Promise((resolve, reject) => {
     const requestOptions = loopback ? {
       hostname: target.hostname,
@@ -222,6 +222,9 @@ process.stdin.on('data', async chunk => {
           params: { level: 'info', logger: 'fake-vsp', data: 'fixture log notification' }
         })}\n`);
       }
+      if (message.params?.arguments?.emitListChanged) {
+        process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'notifications/tools/list_changed' })}\n`);
+      }
       const transportTools = [
         'ListTransports', 'GetTransport', 'GetUserTransports', 'GetTransportInfo',
         'CreateTransport', 'ReleaseTransport', 'DeleteTransport'
@@ -248,7 +251,7 @@ process.stdin.on('data', async chunk => {
         try {
           const target = new URL('/sap/bc/adt/datapreview/freestyle', url);
           const proxy = process.env.HTTP_PROXY || process.env.http_proxy;
-          const adt = await requestADTThroughProxy(target.href, proxy, { method: 'POST', body: '<probe/>' });
+          const adt = await requestADTThroughProxy(target.href, proxy, { method: 'POST', body: '<probe/>', bypassProxyForLoopback: true });
           reply(message.id, { content: [{ type: 'text', text: `fixture ADT HTTP ${adt.status}: ${adt.body}` }], isError: adt.status < 200 || adt.status >= 300 });
         } catch {
           reply(message.id, { content: [{ type: 'text', text: 'fixture ADT write failed' }], isError: true });

package/test/launcher.test.mjs

@@ -169,15 +169,16 @@ test('doctor preflights the failing ADT endpoint through the runtime relay and r
       }]));
       return;
     }
+    if (requestPath === '/sap/bc/adt/discovery' && request.method === 'GET' && request.headers['x-csrf-token'] === 'Fetch') {
+      // Real SAP issues CSRF tokens from GET-capable endpoints only.
+      response.writeHead(200, {
+        'x-csrf-token': 'doctor-token',
+        'set-cookie': 'sap-session=doctor-session; Path=/'
+      });
+      response.end('<ok/>');
+      return;
+    }
     if (requestPath === '/sap/bc/adt/datapreview/freestyle') {
-      if (request.method === 'GET' && request.headers['x-csrf-token'] === 'Fetch') {
-        response.writeHead(200, {
-          'x-csrf-token': 'doctor-token',
-          'set-cookie': 'sap-session=doctor-session; Path=/'
-        });
-        response.end('<ok/>');
-        return;
-      }
       if (request.method === 'POST'
         && request.headers['x-csrf-token'] === 'doctor-token'
         && String(request.headers.cookie).includes('sap-session=doctor-session')) {
@@ -217,14 +218,14 @@ test('doctor preflights the failing ADT endpoint through the runtime relay and r
   assert.ok(report.checks.some(check => check.stage === 'SAP system check' && check.status === 'passed'));
   assert.ok(report.checks.some(check => check.stage === 'MCP config repair' && check.status === 'passed' && /1 managed BAS entry repaired/.test(check.detail)));
   assert.ok(report.checks.some(check => check.stage === 'MCP tools/list' && /total MCP tools returned; chat-picker binding is host-managed/.test(check.detail)));
-  assert.ok(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/datapreview/freestyle' && request.csrf === 'Fetch'));
+  assert.ok(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/discovery' && request.csrf === 'Fetch'));
   assert.ok(requests.some(request => request.method === 'POST' && request.path === '/sap/bc/adt/datapreview/freestyle' && request.csrf === 'doctor-token' && String(request.cookie).includes('sap-session=doctor-session')));
   const repairedConfig = JSON.parse(await readFile(configPath, 'utf8'));
   assert.equal(repairedConfig.servers['doctor-system'].env.H2O_URL, `http://127.0.0.1:${server.address().port}`);
   assert.deepEqual(repairedConfig.servers.ActionS4D_100, config.servers.ActionS4D_100);
 });
 
-test('doctor stops before GetSystemInfo when the runtime CSRF preflight has no session cookie', async t => {
+test('doctor stops before GetSystemInfo when the runtime CSRF preflight receives no token', async t => {
   const directory = await mkdtemp(join(tmpdir(), 'bas-doctor-csrf-missing-cookie-'));
   const configPath = join(directory, 'mcp.json');
   await writeFile(configPath, JSON.stringify({ servers: {} }));
@@ -245,8 +246,9 @@ test('doctor stops before GetSystemInfo when the runtime CSRF preflight has no s
       }]));
       return;
     }
-    if (requestPath === '/sap/bc/adt/datapreview/freestyle') {
-      response.writeHead(200, { 'x-csrf-token': 'orphan-token' });
+    if (requestPath === '/sap/bc/adt/discovery' && request.method === 'GET' && request.headers['x-csrf-token'] === 'Fetch') {
+      // Issues no token at all: the relay must fail closed before any write.
+      response.writeHead(200);
       response.end('<ok/>');
       return;
     }
@@ -276,7 +278,7 @@ test('doctor stops before GetSystemInfo when the runtime CSRF preflight has no s
   assert.equal(report.ok, false);
   assert.ok(report.checks.some(check => check.stage === 'BAS relay CSRF preflight' && check.status === 'failed' && /cookies=0; usableSession=false/.test(check.detail)));
   assert.ok(report.checks.some(check => check.stage === 'SAP system check' && check.status === 'skipped' && /validated BAS proxy tunnel credential override/.test(check.detail)));
-  assert.equal(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/datapreview/freestyle' && request.csrf === 'Fetch'), true);
+  assert.equal(requests.some(request => request.method === 'GET' && request.path === '/sap/bc/adt/discovery' && request.csrf === 'Fetch'), true);
   assert.equal(requests.some(request => request.method === 'POST' && request.path === '/sap/bc/adt/datapreview/freestyle'), false, 'doctor must not call GetSystemInfo after a failed preflight');
 });
 

package/test/live-s4h.test.mjs

@@ -6,11 +6,13 @@ import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { slugifyDestination } from '../src/bas-discovery.mjs';
+import { snakeCaseName, TOOL_NAME_PREFIX } from '../src/mcp-proxy.mjs';
 
 const launcher = fileURLToPath(new URL('../src/launcher.mjs', import.meta.url));
 const LIVE = /^(1|true|yes)$/iu.test(process.env.SAP_AI_DEV_LIVE_S4H || '');
 const DESTINATION = process.env.SAP_AI_DEV_LIVE_DESTINATION || 'S4H';
-const SLUG = process.env.SAP_AI_DEV_LIVE_DESTINATION_SLUG || DESTINATION.toLowerCase().replace(/[^a-z0-9_-]+/gu, '-');
+const SLUG = process.env.SAP_AI_DEV_LIVE_DESTINATION_SLUG || slugifyDestination(DESTINATION);
 const REQUEST_TIMEOUT_MS = Number(process.env.SAP_AI_DEV_LIVE_TIMEOUT_MS || 45_000);
 
 async function readConfiguredServer() {
@@ -29,7 +31,7 @@ async function readConfiguredServer() {
     } catch {
       continue;
     }
-    const server = parsed?.servers?.[DESTINATION];
+    const server = parsed?.servers?.[SLUG] || parsed?.servers?.[DESTINATION];
     if (server?.command) return { path, server };
   }
   return null;
@@ -131,7 +133,7 @@ async function withLiveClient(t) {
   t.after(() => client.close());
   const initialized = await client.request('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'sap-ai-dev-live-test', version: '1.0.0' } });
   client.notify('notifications/initialized');
-  assert.equal(initialized.serverInfo.name, DESTINATION);
+  assert.equal(initialized.serverInfo.name, SLUG);
   return client;
 }
 
@@ -140,7 +142,7 @@ test('live S4H MCP exposes a curated ABAP lifecycle surface under 60 tools', { s
   const listed = await client.request('tools/list', {});
   const tools = listed.tools || [];
   const names = new Set(tools.map(tool => tool.name));
-  const prefix = `${SLUG}__`;
+  const prefix = `${TOOL_NAME_PREFIX}${SLUG}_`;
 
   assert.ok(tools.length > 25, `expected a useful ABAP lifecycle surface, got ${tools.length}`);
   assert.ok(tools.length < 60, `curated destination tool count must stay below 60, got ${tools.length}`);
@@ -154,24 +156,24 @@ test('live S4H MCP exposes a curated ABAP lifecycle surface under 60 tools', { s
     'GetTransport', 'GetTransportInfo', 'ListTransports', 'CreateTransport',
     'GetApplicationLog', 'PrepareABAPChangeSet', 'ApplyABAPChangeSet', 'CheckTransportReadiness', 'PlanABAPCloudMigration'
   ]) {
-    assert.ok(names.has(`${prefix}${required}`), `expected curated lifecycle tool ${required}`);
+    assert.ok(names.has(`${prefix}${snakeCaseName(required)}`), `expected curated lifecycle tool ${required}`);
   }
 
   for (const hidden of [
     'SAP', 'ReleaseTransport', 'DeleteTransport', 'DeleteObject', 'ExecuteABAP', 'CallRFC',
     'ListSQLTraces', 'AnalyzeABAPCode', 'CreateObject', 'CreateClassWithTests', 'WriteClass', 'UpdateSource'
   ]) {
-    assert.equal(names.has(`${prefix}${hidden}`), false, `broad/destructive tool ${hidden} must remain hidden`);
+    assert.equal(names.has(`${prefix}${snakeCaseName(hidden)}`), false, `broad/destructive tool ${hidden} must remain hidden`);
   }
 });
 
 test('live S4H MCP handles safe local and read-only SAP calls', { skip: LIVE ? false : 'set SAP_AI_DEV_LIVE_S4H=1 to run against a live BAS/S4H destination' }, async t => {
   const client = await withLiveClient(t);
-  const prefix = `${SLUG}__`;
+  const prefix = `${TOOL_NAME_PREFIX}${SLUG}_`;
   await client.request('tools/list', {});
 
   const lint = await client.request('tools/call', {
-    name: `${prefix}LintABAP`,
+    name: `${prefix}lint_abap`,
     arguments: { files: [{ filename: 'zlive_probe.prog.abap', source: "REPORT zlive_probe.\nWRITE / 'ok'.\n" }] }
   });
   const lintJson = JSON.parse(textPayload(lint));
@@ -183,19 +185,19 @@ test('live S4H MCP handles safe local and read-only SAP calls', { skip: LIVE ? f
     ['GetFeatures', {}],
     ['GetInstalledComponents', {}]
   ]) {
-    const result = await client.request('tools/call', { name: `${prefix}${tool}`, arguments: args });
+    const result = await client.request('tools/call', { name: `${prefix}${snakeCaseName(tool)}`, arguments: args });
     assert.notEqual(result.isError, true, `${tool} returned an MCP tool error: ${textPayload(result)}`);
   }
 
   const query = await client.request('tools/call', {
-    name: `${prefix}RunQuery`,
+    name: `${prefix}run_query`,
     arguments: { sql_query: 'SELECT * FROM T000', max_rows: 1 }
   });
   assert.notEqual(query.isError, true, `RunQuery returned an MCP tool error: ${textPayload(query)}`);
   assert.match(textPayload(query), /T000|MANDT|client|rows|\[/iu);
 
   const appLog = await client.request('tools/call', {
-    name: `${prefix}GetApplicationLog`,
+    name: `${prefix}get_application_log`,
     arguments: { max_results: 1 }
   });
   assert.notEqual(appLog.isError, true, `GetApplicationLog returned an MCP tool error: ${textPayload(appLog)}`);