sap-ai-dev-toolkit 0.4.5 → 0.5.0

package/README.md

@@ -456,9 +456,10 @@ Credentials, cookies, SAP usernames, passwords, and raw BAS destination payloads
 The configuration path is selected in this order:
 
 1. `SAP_AI_DEV_MCP_CONFIG`, when set.
-2. `BAS_VSP_MCP_CONFIG`, when set for compatibility with earlier releases.
-3. An existing MCP user configuration detected automatically.
-4. The default MCP user configuration location.
+2. `SAP_AI_DEV_TOOLKIT_MCP_CONFIG`, when set.
+3. `BAS_VSP_MCP_CONFIG`, when set for compatibility with earlier releases.
+4. An existing MCP user configuration detected automatically.
+5. The default MCP user configuration location.
 
 Set `SAP_AI_DEV_MCP_CONFIG` to use a specific configuration file:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sap-ai-dev-toolkit",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "description": "SAP AI development toolkit for BAS, ABAP, RAP, CAP, HANA Cloud, Fiori, UI5, and MCP",
   "author": "Gurkan Yilmaz",
   "type": "module",

package/src/bas-destination-relay.mjs

@@ -133,7 +133,16 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
   // must keep the BAS .dest route (and its Cloud Connector mapping), so they
   // use HTTP CONNECT through the BAS proxy instead of credentials.host.
   const directBase = directHost ? new URL(String(directHost)) : null;
-  const cookieBase = directBase || (destination.backendUrl ? new URL(String(destination.backendUrl)) : base);
+  const cookieBase = directBase || (destination.backendUrl
+    ? new URL(String(destination.backendUrl))
+    : (() => {
+        const target = new URL(base);
+        // BAS .dest URLs are local HTTP routing aliases for SAP backends that
+        // are commonly HTTPS. Use a secure cookie context when BAS metadata
+        // omits the backend URL so Secure session cookies are not discarded.
+        if (target.protocol === 'http:' && /\.dest$/i.test(target.hostname)) target.protocol = 'https:';
+        return target;
+      })());
   if (directBase) log(`[${destination.name}] BAS relay direct connect active (${directBase.origin}); BAS proxy cookie stripping bypassed`);
   if (tunnelMode) log(`[${destination.name}] BAS relay using a BAS proxy tunnel for the OnPremise destination`);
   // Proxy resolution: an explicitly configured proxy wins (an explicit empty
@@ -262,7 +271,9 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
   async function forward(method, requestUrl, requestHeaders, body, session) {
     const target = resolveTarget(requestUrl);
     const cookieTarget = resolveCookieTarget(target);
-    const sessionCookie = session?.jar ? await cookieHeader(session.jar, cookieTarget) : undefined;
+    const cookieJar = session?.jar || sharedCookieJar;
+    if (!session) await seedRequestCookies(cookieJar, requestHeaders.cookie, cookieTarget);
+    const sessionCookie = await cookieHeader(cookieJar, cookieTarget);
     const headers = authHeaders(headersFrom(requestHeaders, {
       ...(session?.token ? { 'x-csrf-token': session.token } : {}),
       ...(sessionCookie ? { cookie: sessionCookie } : {})
@@ -288,7 +299,8 @@ export function createBasDestinationRelay(destination, { env = process.env, fetc
         : 'received a CSRF token without a session cookie';
       const message = `BAS destination relay ${detail} for ${requestUrl.pathname}; no unsafe request was sent`;
       log(`[${destination.name}] ${message}`);
-      const response = new Response(message, { status: 503, headers: { 'content-type': 'text/plain; charset=utf-8' } });
+      const status = session?.httpStatus >= 400 ? session.httpStatus : 503;
+      const response = new Response(message, { status, headers: { 'content-type': 'text/plain; charset=utf-8' } });
       return { response, body: Buffer.from(message) };
     }
     const { response, body: responseBody } = await forward(method, requestUrl, requestHeaders, body, session);

package/src/bas-discovery.mjs

@@ -122,7 +122,7 @@ function proxyDispatcher(target, env) {
   const url = new URL(target);
   const brandedProxy = brandedEnvValue(env, 'HTTP_PROXY');
   const httpProxy = brandedProxy !== undefined ? String(brandedProxy) : (env.http_proxy ?? env.HTTP_PROXY ?? '');
-  const httpsProxy = env.https_proxy ?? env.HTTPS_PROXY ?? '';
+  const httpsProxy = brandedProxy !== undefined ? String(brandedProxy) : (env.https_proxy ?? env.HTTPS_PROXY ?? '');
   const proxy = url.protocol === 'https:' ? httpsProxy || httpProxy : httpProxy;
   const noProxy = env.no_proxy ?? env.NO_PROXY ?? '';
   if (!proxy || proxyBypasses(url, noProxy)) return undefined;

package/src/launcher.mjs

@@ -60,7 +60,11 @@ async function runDoctor(destinations) {
 
 
   try {
-    const repair = await repairManagedMcpConfig(destinations, { env: runtimeEnv, discoveryComplete: true });
+    const repair = await repairManagedMcpConfig(destinations, {
+      env: runtimeEnv,
+      discoveryComplete: true,
+      packageVersion: pkg.version
+    });
     const detail = repair.skipped
       ? repair.skipped
       : `${repair.repaired} managed BAS entr${repair.repaired === 1 ? 'y' : 'ies'} repaired; ${repair.managedEntries || 0} managed BAS entries recognized`;

package/src/mcp-config.mjs

@@ -322,7 +322,7 @@ export async function installMcpConfig(destinationsOrOptions, options = {}) {
   return { path, servers: generated };
 }
 
-export async function repairManagedMcpConfig(discoveredDestinations, { env = process.env, path, discoveryComplete = false } = {}) {
+export async function repairManagedMcpConfig(discoveredDestinations, { env = process.env, path, discoveryComplete = false, packageVersion } = {}) {
   const configPath = path || await resolveMcpConfigPath(env);
   if (!discoveryComplete) {
     return { path: configPath, changed: false, repaired: 0, skipped: 'Destination discovery was incomplete.' };
@@ -334,6 +334,7 @@ export async function repairManagedMcpConfig(discoveredDestinations, { env = pro
   const config = await readConfig(configPath);
   const managedEntries = Object.values(config.servers).filter(isManagedBasDestinationEntry).length;
   if (!basDestinations.size) return { path: configPath, changed: false, repaired: 0, managedEntries };
+  const localCommand = await resolveMcpServerCommand(env);
   let repaired = 0;
   for (const [serverName, entry] of Object.entries(config.servers)) {
     if (!isManagedBasDestinationEntry(entry)) continue;
@@ -343,9 +344,21 @@ export async function repairManagedMcpConfig(discoveredDestinations, { env = pro
     if (!destination) continue;
     const expected = buildMcpEntries([destination], env)[serverName];
     const nextEnvironment = { ...entry.env, ...expected.env };
+    if (Object.hasOwn(entry.env, 'SAP_ALLOW_TRANSPORTABLE_EDITS')) {
+      nextEnvironment.SAP_ALLOW_TRANSPORTABLE_EDITS = entry.env.SAP_ALLOW_TRANSPORTABLE_EDITS;
+    }
     delete nextEnvironment.BAS_VSP_DESTINATION;
     delete nextEnvironment.BAS_VSP_DESTINATION_SOURCE;
     const nextEntry = { ...entry, type: 'stdio', env: nextEnvironment, BAS_EXT: 'true' };
+    if (entry.command === 'npx') {
+      if (packageVersion && Array.isArray(entry.args)) {
+        nextEntry.args = entry.args.map(argument => typeof argument === 'string' && /^--package=sap-ai-dev-toolkit(?:@[^/]+)?$/.test(argument)
+          ? `--package=sap-ai-dev-toolkit@${packageVersion}`
+          : argument);
+      }
+    } else {
+      nextEntry.command = localCommand;
+    }
     if (JSON.stringify(nextEntry) === JSON.stringify(entry)) continue;
     config.servers[serverName] = nextEntry;
     repaired += 1;

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

@@ -17,7 +17,8 @@ function sapLikeBackend({
   genericForbidden = false,
   partialRefreshCookies = false,
   omitCookies = false,
-  setCookieOnSafeGet = false
+  setCookieOnSafeGet = false,
+  secureSessionCookie = false
 } = {}) {
   const state = { sessionCounter: 0, requests: [] };
   const server = http.createServer((req, res) => {
@@ -35,6 +36,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/>');
@@ -145,6 +147,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
@@ -218,6 +244,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 +324,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,12 +359,13 @@ 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.match(String(post.headers.cookie), /sap-secure=secure-value/, 'Secure SAP cookies must be sent through the HTTPS-backed BAS .dest route');
   assert.ok(connectTargets.length >= 2);
   assert.ok(connectTargets.every(target => target === 'cc-system.dest:80'));
   assert.equal(relay.stats.direct, false);

package/test/discovery.test.mjs

@@ -231,6 +231,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,
@@ -248,7 +248,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/mcp-config-cf.test.mjs

@@ -96,7 +96,9 @@ test('doctor repair updates only discovered toolkit BAS entries and is idempoten
   const path = join(directory, 'mcp.json');
   t.after(() => rm(directory, { recursive: true, force: true }));
   const cf = cfDestination('space-one', 'instance-one', 'cf-key');
+  const strictDestination = { ...bas, name: 'strict', serverName: 'strict', url: 'http://strict.dest' };
   const managed = buildMcpEntries([bas], { H2O_URL: 'http://old-h2o.example' }).shared;
+  const strictManaged = buildMcpEntries([strictDestination], { H2O_URL: 'http://old-h2o.example' }).strict;
   const cfEntry = buildMcpEntries([cf], { H2O_URL: 'http://cf-h2o.example' })[cf.serverName];
   const companion = buildSapDevelopmentMcpEntries(['sap-fiori-tools'])['sap-fiori-tools'];
   const unrelated = { type: 'stdio', command: 'external-server' };
@@ -108,6 +110,7 @@ test('doctor repair updates only discovered toolkit BAS entries and is idempoten
     userFlag: true,
     servers: {
       shared: { ...managed, env: { ...managed.env, H2O_URL: 'http://old-h2o.example' } },
+      strict: { ...strictManaged, env: { ...strictManaged.env, SAP_ALLOW_TRANSPORTABLE_EDITS: 'false' } },
       'temporarily-unavailable': unverifiedManaged,
       [cf.serverName]: cfEntry,
       'sap-fiori-tools': companion,
@@ -116,13 +119,14 @@ test('doctor repair updates only discovered toolkit BAS entries and is idempoten
   };
   await writeFile(path, JSON.stringify(config, null, 2));
 
-  const first = await repairManagedMcpConfig([bas], { env: { H2O_URL: 'http://current-h2o.example' }, path, discoveryComplete: true });
+  const first = await repairManagedMcpConfig([bas, strictDestination], { env: { H2O_URL: 'http://current-h2o.example' }, path, discoveryComplete: true });
   assert.equal(first.changed, true);
-  assert.equal(first.repaired, 1);
+  assert.equal(first.repaired, 2);
   const repaired = await readMcpConfig(path);
   assert.equal(repaired.userFlag, true);
   assert.equal(repaired.servers.shared.env.H2O_URL, 'http://current-h2o.example');
   assert.equal(repaired.servers.shared.env.SAP_ALLOW_TRANSPORTABLE_EDITS, 'true');
+  assert.equal(repaired.servers.strict.env.SAP_ALLOW_TRANSPORTABLE_EDITS, 'false', "doctor must preserve a user's restricted write setting");
   assert.deepEqual(repaired.servers['temporarily-unavailable'], unverifiedManaged);
   assert.deepEqual(repaired.servers[cf.serverName], cfEntry);
   assert.deepEqual(repaired.servers['sap-fiori-tools'], companion);
@@ -130,7 +134,7 @@ test('doctor repair updates only discovered toolkit BAS entries and is idempoten
   assert.equal(repaired.servers.newDestination, undefined, 'repair must not add unselected destinations');
 
   const beforeSecondRepair = await readFile(path, 'utf8');
-  const second = await repairManagedMcpConfig([bas], { env: { H2O_URL: 'http://current-h2o.example' }, path, discoveryComplete: true });
+  const second = await repairManagedMcpConfig([bas, strictDestination], { env: { H2O_URL: 'http://current-h2o.example' }, path, discoveryComplete: true });
   assert.equal(second.changed, false);
   assert.equal(second.repaired, 0);
   assert.equal(await readFile(path, 'utf8'), beforeSecondRepair, 'an already-healed config must not be rewritten');
@@ -162,6 +166,46 @@ test('doctor repair skips config changes if destination discovery is incomplete'
   assert.equal(await readFile(path, 'utf8'), initial);
 });
 
+test('doctor repair refreshes stale toolkit launchers without changing npx behavior', async t => {
+  const directory = await mkdtemp(join(tmpdir(), 'sap-ai-toolkit-doctor-launcher-repair-'));
+  const path = join(directory, 'mcp.json');
+  const bin = join(directory, 'bin');
+  await import('node:fs/promises').then(({ mkdir }) => mkdir(bin));
+  const command = join(bin, 'sap-ai-dev');
+  await writeFile(command, '#!/bin/sh\nexit 0\n', { mode: 0o755 });
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const npx = {
+    ...buildMcpEntries([bas], { H2O_URL: 'http://old-h2o.example' }).shared,
+    command: 'npx',
+    args: ['--yes', '--package=sap-ai-dev-toolkit@0.4.2', 'sap-ai-dev'],
+    env: {
+      ...buildMcpEntries([bas], { H2O_URL: 'http://old-h2o.example' }).shared.env,
+      SAP_AI_DEV_TOOLKIT_DESTINATION: 'shared',
+      OPERATOR_SETTING: 'preserve'
+    }
+  };
+  const direct = {
+    ...buildMcpEntries([bas], { H2O_URL: 'http://old-h2o.example' }).shared,
+    command: 'stale-sap-ai-dev'
+  };
+  await writeFile(path, JSON.stringify({ servers: { shared: npx, other: { ...direct, env: { ...direct.env, SAP_AI_DEV_TOOLKIT_DESTINATION: 'other' } }, userServer: { command: 'other' } } }));
+
+  const result = await repairManagedMcpConfig([bas], {
+    env: { H2O_URL: 'http://current-h2o.example', PATH: bin },
+    path,
+    discoveryComplete: true,
+    packageVersion: '0.4.5'
+  });
+  assert.equal(result.repaired, 1, 'only the entry that maps to the discovered destination is repaired');
+  const repaired = await readMcpConfig(path);
+  assert.equal(repaired.servers.shared.command, 'npx');
+  assert.deepEqual(repaired.servers.shared.args, ['--yes', '--package=sap-ai-dev-toolkit@0.4.5', 'sap-ai-dev']);
+  assert.equal(repaired.servers.shared.env.OPERATOR_SETTING, 'preserve');
+  assert.equal(repaired.servers.shared.env.H2O_URL, 'http://current-h2o.example');
+  assert.equal(repaired.servers.other.command, 'stale-sap-ai-dev', 'unmatched toolkit entry must remain untouched');
+  assert.deepEqual(repaired.servers.userServer, { command: 'other' });
+});
+
 test('extracts key references only from package-managed Cloud Foundry entries', () => {
   const cloudFoundry = buildMcpEntries([
     cfDestination('space-one', 'instance-one', 'destination-key', 'OnPremise')

package/test/mcp-proxy.test.mjs

@@ -275,15 +275,19 @@ test('merges paged tools and routes calls to the selected child', async t => {
 test('routes tools/call using the exact name advertised for a BAS destination', async t => {
   const directory = await mkdtemp(join(tmpdir(), 'bas-namespaced-tool-roundtrip-'));
   const log = join(directory, 'children.log');
+  const logs = [];
   const proxy = new MCPProxy({
     binary: fixture,
     destinations: [{ name: 'ActionS4D_100', url: 'http://ActionS4D_100.dest', client: '100' }],
     env: { ...process.env, SAP_AI_DEV_TOOLKIT_MODE: 'expert', FAKE_LOG: log },
-    log: () => {}
+    log: message => logs.push(message)
   });
   t.after(async () => { await proxy.close(); await rm(directory, { recursive: true, force: true }); });
-  await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } });
+  proxy.start();
+  const initialized = await proxy.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05' } });
+  assert.equal(initialized.error, undefined, `${JSON.stringify(initialized.error)} ${logs.join(' | ')}`);
   const listed = await proxy.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
+  assert.equal(listed.error, undefined, JSON.stringify(listed.error));
   const tool = listed.result.tools.find(candidate => candidate.name === 'actions4d-100__WriteSource');
   assert.ok(tool, 'tools/list must publish the normalized destination namespace');
   const called = await proxy.handle({