toolfunnel 0.5.0 → 0.7.0

package/mcp/expose.example.json

@@ -1,30 +1,30 @@
-{
-  "_README": "SAMPLE config — NOT the live expose.json. This wires the bundled demo upstream at mcp/servers/mock-upstream/server.js so the MCP Manager has a real target. TO USE: either (A) copy this file over mcp/expose.json to pre-seed the host (drop the _README key — the loader ignores it, but copy cleanly), OR (B) leave expose.json empty and add the same upstream + expose entries through the MCP Manager UI (Add upstream -> Discover -> tick to expose). The upstream offers ping, add, echo; this sample exposes only TWO (ping, add) to demonstrate curation. IMPORTANT: the args path MUST resolve INSIDE the gateway root — the aggregator's isolation guard rejects any arg path that escapes the sandbox. A relative path like 'mcp/servers/mock-upstream/server.js' is resolved against the gateway root and stays inside it; 'node' in the command slot is the interpreter (not guarded). Do NOT edit the live mcp/expose.json to point outside the gateway root.",
-  "version": 1,
-  "upstreams": [
-    {
-      "id": "mock",
-      "transport": "stdio",
-      "command": "node",
-      "args": ["mcp/servers/mock-upstream/server.js"],
-      "enabled": true,
-      "description": "Bundled demo upstream MCP (zero-dependency, stdio): ping, add, echo. No network, no fs writes, no process mutation."
-    }
-  ],
-  "expose": [
-    {
-      "upstream": "mock",
-      "tool": "ping",
-      "as": "mock_ping",
-      "category": "demo",
-      "enabled": true
-    },
-    {
-      "upstream": "mock",
-      "tool": "add",
-      "as": "mock_add",
-      "category": "demo",
-      "enabled": true
-    }
-  ]
-}
+{
+  "_README": "SAMPLE config - NOT the live expose.json. This wires the bundled demo upstream at mcp/servers/mock-upstream/server.js so the MCP Manager has a real target. TO USE: either (A) copy this file over mcp/expose.json to pre-seed the host (drop the _README key - the loader ignores it, but copy cleanly), OR (B) leave expose.json empty and add the same upstream + expose entries through the MCP Manager UI (Add upstream -> Discover -> tick to expose). The upstream offers ping, add, echo; this sample exposes only TWO (ping, add) to demonstrate curation. IMPORTANT: the args path MUST resolve INSIDE the gateway root - the aggregator's isolation guard rejects any arg path that escapes the sandbox. A relative path like 'mcp/servers/mock-upstream/server.js' is resolved against the gateway root and stays inside it; 'node' in the command slot is the interpreter (not guarded). Do NOT edit the live mcp/expose.json to point outside the gateway root.",
+  "version": 1,
+  "upstreams": [
+    {
+      "id": "mock",
+      "transport": "stdio",
+      "command": "node",
+      "args": ["mcp/servers/mock-upstream/server.js"],
+      "enabled": true,
+      "description": "Bundled demo upstream MCP (zero-dependency, stdio): ping, add, echo. No network, no fs writes, no process mutation."
+    }
+  ],
+  "expose": [
+    {
+      "upstream": "mock",
+      "tool": "ping",
+      "as": "mock_ping",
+      "category": "demo",
+      "enabled": true
+    },
+    {
+      "upstream": "mock",
+      "tool": "add",
+      "as": "mock_add",
+      "category": "demo",
+      "enabled": true
+    }
+  ]
+}

package/mcp/servers/mock-modern/server.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * mcp/servers/mock-modern/server.js
+ *
+ * A tiny, ZERO-DEPENDENCY stdio MCP server that speaks the 2026-07-28 ("modern") protocol -
+ * the companion to mock-upstream (which speaks the legacy 2024-11-05 protocol). It exists to
+ * prove ToolFunnel's DUAL-ERA CLIENT: attach it as an upstream and ToolFunnel negotiates modern
+ * (probes server/discover, skips the initialize handshake, and puts a per-request `_meta` on
+ * every call). Over stdio the modern era needs only `_meta` - the Mcp-* headers are HTTP-only.
+ *
+ * Modern-only, deliberately STRICT so it proves the client is really speaking modern:
+ *   - `initialize`      -> -32601 (removed in the modern era; a modern-only server has no handshake)
+ *   - `server/discover` -> { resultType, supportedVersions:['2026-07-28'], capabilities, _meta
+ *                           (serverInfo), instructions, ttlMs, cacheScope }
+ *   - `tools/list`      -> REQUIRES per-request `_meta` (else -32602); returns resultType + tools
+ *                           + ttlMs/cacheScope
+ *   - `tools/call`      -> REQUIRES per-request `_meta` (else -32602); returns resultType + content
+ *
+ * Tools (real upstream names): ping -> "pong", add {a,b} -> a+b, echo {text} -> text.
+ *
+ * JSON-RPC 2.0 over stdio, newline-delimited (one compact JSON object per line). Node built-ins
+ * only, CommonJS. Built to the RC spec (locked 2026-05-21); reconcile minor final deltas 28 July.
+ */
+
+const MODERN_VERSION = '2026-07-28';
+const SERVER_INFO = { name: 'mock-modern', version: '2.0.0' };
+const META_VERSION = 'io.modelcontextprotocol/protocolVersion';
+const META_SERVERINFO = 'io.modelcontextprotocol/serverInfo';
+
+const TOOLS = [
+  { name: 'ping', description: 'Health check - returns "pong".', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+  { name: 'add', description: 'Add two numbers.', inputSchema: { type: 'object', properties: { a: { type: 'number' }, b: { type: 'number' } }, required: ['a', 'b'], additionalProperties: false } },
+  { name: 'echo', description: 'Echo the given text.', inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'], additionalProperties: false } },
+];
+
+function writeMessage(obj) {
+  try { process.stdout.write(JSON.stringify(obj) + '\n'); } catch (_e) { /* never crash on a write */ }
+}
+
+/** A modern result carries resultType + the server's serverInfo in _meta. */
+function modernResult(extra) {
+  return Object.assign({ resultType: 'complete', _meta: { [META_SERVERINFO]: SERVER_INFO } }, extra);
+}
+
+function textResult(text, isError) {
+  return modernResult({ content: [{ type: 'text', text: String(text) }], isError: isError === true });
+}
+
+/** A modern request MUST carry params._meta with BOTH the EXACT protocol version AND a
+ *  clientCapabilities object - the spec's two per-request MUSTs. Strict on purpose: this
+ *  fixture's job is to catch a client regression in EITHER field (a lax check here would let
+ *  "tools/call works with _meta" pass while the client sent the wrong version or no caps). */
+function hasModernMeta(params) {
+  const meta = params && params._meta;
+  if (!meta || typeof meta !== 'object') return false;
+  if (meta[META_VERSION] !== MODERN_VERSION) return false;
+  const caps = meta['io.modelcontextprotocol/clientCapabilities'];
+  return !!(caps && typeof caps === 'object' && !Array.isArray(caps));
+}
+
+function handleMessage(msg) {
+  if (!msg || typeof msg !== 'object') return;
+  const id = msg.id;
+  const method = msg.method;
+  const params = msg.params || {};
+  if (id === undefined || id === null) return; // notifications are never answered
+
+  switch (method) {
+    case 'server/discover':
+      return writeMessage({
+        jsonrpc: '2.0', id,
+        result: modernResult({
+          supportedVersions: [MODERN_VERSION],
+          capabilities: { tools: {} },
+          instructions: 'A modern (2026-07-28) mock MCP. Tools: ping, add, echo.',
+          ttlMs: 3600000,
+          cacheScope: 'private',
+        }),
+      });
+
+    case 'initialize':
+      // Modern-only: the initialize handshake was removed. Reject so a legacy client fails clearly.
+      return writeMessage({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found: initialize (this is a modern 2026-07-28 server - use server/discover)' } });
+
+    case 'tools/list':
+      if (!hasModernMeta(params)) {
+        return writeMessage({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: modern requests require params._meta with a protocol version' } });
+      }
+      return writeMessage({ jsonrpc: '2.0', id, result: modernResult({ tools: TOOLS, ttlMs: 60000, cacheScope: 'private' }) });
+
+    case 'resources/list':
+      // A CacheableResult surface - proves non-tool forwarding under a wrap (and that the wrap adds
+      // the required ttlMs/cacheScope when the upstream's own hints are absent).
+      if (!hasModernMeta(params)) {
+        return writeMessage({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: modern requests require params._meta with a protocol version' } });
+      }
+      return writeMessage({ jsonrpc: '2.0', id, result: modernResult({ resources: [{ uri: 'mock://modern/example', name: 'example' }] }) });
+
+    case 'tools/call': {
+      if (!hasModernMeta(params)) {
+        return writeMessage({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params: modern requests require params._meta with a protocol version' } });
+      }
+      const name = params.name;
+      const args = params.arguments || {};
+      if (name === 'ping') {
+        // PLUMBING FIXTURE, not conformant behaviour: a real modern server emits notifications
+        // only inside a subscriptions/listen stream, which ToolFunnel's client does not yet open
+        // (28-July item). This unsolicited emission exists solely so BR-A2 can prove the
+        // notification->hook plumbing; the ACK-level honesty (never counting a modern upstream as
+        // able to honour resourceSubscriptions) is asserted by BR-A3.
+        writeMessage({ jsonrpc: '2.0', method: 'notifications/resources/updated', params: { uri: 'mock://modern/example' } });
+        return writeMessage({ jsonrpc: '2.0', id, result: textResult('pong') });
+      }
+      if (name === 'add') {
+        const a = Number(args.a), b = Number(args.b);
+        if (!isFinite(a) || !isFinite(b)) return writeMessage({ jsonrpc: '2.0', id, result: textResult('add requires numeric a and b', true) });
+        return writeMessage({ jsonrpc: '2.0', id, result: textResult(String(a + b)) });
+      }
+      if (name === 'echo') {
+        const text = typeof args.text === 'string' ? args.text : JSON.stringify(args.text);
+        return writeMessage({ jsonrpc: '2.0', id, result: textResult(text) });
+      }
+      return writeMessage({ jsonrpc: '2.0', id, result: textResult('unknown tool: ' + name, true) });
+    }
+
+    default:
+      return writeMessage({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found: ' + method } });
+  }
+}
+
+let buffer = '';
+process.stdin.on('data', (chunk) => {
+  buffer += chunk.toString('utf8');
+  let nl;
+  while ((nl = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, nl).replace(/\r$/, '').trim();
+    buffer = buffer.slice(nl + 1);
+    if (line.length === 0) continue;
+    let msg;
+    try { msg = JSON.parse(line); } catch (_e) { continue; }
+    try { handleMessage(msg); } catch (_e) { /* never take the server down */ }
+  }
+});
+process.stdin.on('end', () => process.exit(0));
+process.stdin.resume();

package/mcp/servers/mock-upstream/server.js

@@ -13,7 +13,7 @@
  * the isolation guard requires it to stay inside the tree):
  *   upstream: { id: "mock", command: "node", args: ["mcp/servers/mock-upstream/server.js"] }
  *
- * Protocol: JSON-RPC 2.0 over stdio with NEWLINE-DELIMITED framing — one compact JSON object per
+ * Protocol: JSON-RPC 2.0 over stdio with NEWLINE-DELIMITED framing - one compact JSON object per
  *   line, "\n"-terminated, the MCP stdio transport every real SDK-based server speaks. We read lines
  *   on stdin and answer in kind on stdout. (This fixture used to parse LSP Content-Length framing,
  *   matching an old client bug; both were corrected together so the mock represents a REAL server.)
@@ -22,24 +22,31 @@
  *   - ping              -> "pong"
  *   - add  { a, b }     -> a + b
  *   - echo { text }     -> text
+ *   - blocks            -> a MULTI-BLOCK result with structuredContent (envelope-fidelity fixture)
  *
- * Replies to `initialize`, ignores `notifications/initialized`, answers `tools/list` and
- * `tools/call`, never crashes on a bad frame, and exits cleanly on stdin EOF.
+ * Replies to `initialize`, ignores `notifications/initialized`, answers `tools/list`,
+ * `tools/call` and `resources/list` (one fixed resource - forward-fidelity fixture),
+ * never crashes on a bad frame, and exits cleanly on stdin EOF.
  *
  * Node built-ins only. CommonJS.
  */
 
 const PROTOCOL_VERSION = '2024-11-05';
-const SERVER_INFO = { name: 'mock-upstream', version: '1.0.0' };
+// `title` is a fidelity fixture: the 2025-06-18 spec added serverInfo.title, and the wrap must
+// deliver it VERBATIM (a whitelist in wrappedIdentity used to eat it - found wire-testing the wrap, 2026-07-17).
+const SERVER_INFO = { name: 'mock-upstream', version: '1.0.0', title: 'Mock Upstream Fixture' };
 
 const TOOLS = [
   {
     name: 'ping',
-    description: 'Health check — returns the string "pong".',
+    description: 'Health check - returns the string "pong".',
     inputSchema: { type: 'object', properties: {}, additionalProperties: false },
   },
   {
+    // title + annotations are fidelity fixtures: real servers ship them (and newer fields), and a
+    // transparent wrap must advertise the def BYTE-IDENTICAL (a projection used to drop both).
     name: 'add',
+    title: 'Add Numbers',
     description: 'Add two numbers and return the sum.',
     inputSchema: {
       type: 'object',
@@ -47,6 +54,7 @@ const TOOLS = [
       required: ['a', 'b'],
       additionalProperties: false,
     },
+    annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
   },
   {
     name: 'echo',
@@ -58,14 +66,39 @@ const TOOLS = [
       additionalProperties: false,
     },
   },
+  {
+    name: 'blocks',
+    description: 'Return a multi-block result with structuredContent (envelope-fidelity fixture).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
   {
     name: 'crash',
-    description: 'Exit the process immediately (simulates an upstream crash — for reconnect testing).',
+    description: 'Exit the process immediately (simulates an upstream crash - for reconnect testing).',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'prog',
+    description: 'Progress fixture: emits two notifications/progress against the request _meta progressToken, then returns.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'slowtool',
+    description: 'In-flight tools/call fixture: replies after 2s - the cancel-translation window for the TOOL path.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'elicit',
+    description: 'Elicitation fixture: sends a server-initiated elicitation/create mid-call, holds the call open, completes from the answer.',
     inputSchema: { type: 'object', properties: {}, additionalProperties: false },
   },
 ];
 
-/** Write one JSON-RPC message as a newline-delimited line — the MCP stdio framing. */
+// Outstanding SERVER->CLIENT requests this mock has issued (elicitation-bridge fixture): id -> callback fed
+// with the client's response ({ result } or { error }).
+const outstandingServerRequests = new Map();
+let nextServerRequestId = 9001;
+
+/** Write one JSON-RPC message as a newline-delimited line - the MCP stdio framing. */
 function writeMessage(msg) {
   process.stdout.write(JSON.stringify(msg) + '\n');
 }
@@ -82,24 +115,141 @@ function handleMessage(msg) {
   const method = msg.method;
   const params = msg.params || {};
 
-  // Notifications carry no id and must never be answered.
-  if (id === undefined || id === null) return;
+  // Era-negotiation fixture: when TF_MOCK_METHOD_LOG is set, RECORD every incoming method in
+  // arrival order. A reconnect test reads the log to prove WHICH negotiation a fresh connection
+  // ran (server/discover probe vs straight initialize) - the wire is the only honest witness.
+  if (typeof method === 'string' && process.env.TF_MOCK_METHOD_LOG) {
+    try {
+      require('node:fs').appendFileSync(process.env.TF_MOCK_METHOD_LOG, method + '\n');
+    } catch (_e) { /* fixture logging must never crash the mock */ }
+  }
+
+  // Notifications carry no id and must never be answered. Cancel-fidelity fixture: when
+  // TF_MOCK_CANCEL_LOG is set, RECORD each received notifications/cancelled requestId - a
+  // gateway test can then prove which id (translated or raw) actually reached this server.
+  if (id === undefined || id === null) {
+    if (method === 'notifications/cancelled' && process.env.TF_MOCK_CANCEL_LOG) {
+      try {
+        require('node:fs').appendFileSync(process.env.TF_MOCK_CANCEL_LOG, String(params.requestId) + '\n');
+      } catch (_e) { /* fixture logging must never crash the mock */ }
+    }
+    return;
+  }
+
+  // A message with an id and NO method is a client RESPONSE - route it to the outstanding
+  // server-initiated request it answers (elicitation-bridge fixture). Unknown ids are dropped.
+  if (method === undefined) {
+    const cb = outstandingServerRequests.get(id);
+    if (cb) {
+      outstandingServerRequests.delete(id);
+      try { cb(msg); } catch (_e) { /* fixture callback must never crash the mock */ }
+    }
+    return;
+  }
 
   switch (method) {
     case 'initialize':
+      // Era-memo self-heal fixture: while the file named by TF_MOCK_INIT_REFUSE_FILE EXISTS,
+      // REFUSE the legacy handshake - the shape of an upstream upgraded to modern-only across a
+      // restart. File-gated (not env-gated) so a test can flip the behaviour BETWEEN respawns of
+      // this same fixture without touching the upstream's configured env.
+      if (process.env.TF_MOCK_INIT_REFUSE_FILE &&
+          require('node:fs').existsSync(process.env.TF_MOCK_INIT_REFUSE_FILE)) {
+        return writeMessage({
+          jsonrpc: '2.0', id,
+          error: { code: -32000, message: 'initialize refused (TF_MOCK_INIT_REFUSE_FILE fixture)' },
+        });
+      }
+      // Identity-mirroring fixture: RECORD the clientInfo each connect presents when
+      // TF_MOCK_CLIENTINFO_LOG is set. A wire test reads the log across a reconnect - first
+      // entry = the gateway's boot identity, last entry = the mirrored downstream client.
+      if (process.env.TF_MOCK_CLIENTINFO_LOG) {
+        try {
+          require('node:fs').appendFileSync(process.env.TF_MOCK_CLIENTINFO_LOG,
+            JSON.stringify((params && params.clientInfo) || null) + '\n');
+        } catch (_e) { /* fixture logging must never crash the mock */ }
+      }
       return writeMessage({
         jsonrpc: '2.0',
         id,
         result: {
           protocolVersion: PROTOCOL_VERSION,
           serverInfo: SERVER_INFO,
-          capabilities: { tools: {} },
+          // resources.subscribe: the per-URI update fixture - a legacy server only emits
+          // resources/updated AFTER a resources/subscribe, which is exactly the channel the
+          // gateway must forward, replay on reconnect, and bridge back.
+          capabilities: { tools: {}, resources: { subscribe: true } },
         },
       });
 
     case 'tools/list':
+      // Era-memo invariant fixture: while the file named by TF_MOCK_LIST_FAIL_FILE EXISTS,
+      // tools/list errors AFTER a successful handshake - the shape of an upstream that half-boots.
+      // File-gated so a test can flip the behaviour between respawns of this same fixture.
+      if (process.env.TF_MOCK_LIST_FAIL_FILE &&
+          require('node:fs').existsSync(process.env.TF_MOCK_LIST_FAIL_FILE)) {
+        return writeMessage({
+          jsonrpc: '2.0', id,
+          error: { code: -32000, message: 'tools/list unavailable (TF_MOCK_LIST_FAIL_FILE fixture)' },
+        });
+      }
       return writeMessage({ jsonrpc: '2.0', id, result: { tools: TOOLS } });
 
+    case 'server/discover':
+      // Era-probe fixture: TF_MOCK_DISCOVER_EMPTY=1 makes this server ACK unknown methods with `{}`
+      // - the "permissive legacy server" shape. A strict dual-era client probe must treat that as
+      // LEGACY (no supportedVersions listing the modern version). Default: honest -32601.
+      if (process.env.TF_MOCK_DISCOVER_EMPTY === '1') {
+        return writeMessage({ jsonrpc: '2.0', id, result: {} });
+      }
+      return writeMessage({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found: ' + method } });
+
+    case 'resources/list':
+      // Forward-fidelity fixture: a distinctive verbatim result so a gateway test can PROVE a
+      // forwarded non-tool method really reached this server (and came back untouched).
+      return writeMessage({
+        jsonrpc: '2.0', id,
+        result: { resources: [{ uri: 'mock://upstream/readme', name: 'readme', mimeType: 'text/plain' }] },
+      });
+
+    case 'resources/subscribe': {
+      // Per-URI update fixture. Ack, RECORD the subscribe when TF_MOCK_SUB_LOG is set (a replay
+      // test counts subscribes across a process swap - a fresh process logging a fresh subscribe
+      // PROVES the gateway replayed it), then emit one resources/updated shortly after.
+      const uri = typeof params.uri === 'string' ? params.uri : '';
+      if (process.env.TF_MOCK_SUB_LOG) {
+        try {
+          require('node:fs').appendFileSync(process.env.TF_MOCK_SUB_LOG, uri + '\n');
+        } catch (_e) { /* fixture logging must never crash the mock */ }
+      }
+      writeMessage({ jsonrpc: '2.0', id, result: {} });
+      setTimeout(() => writeMessage({
+        jsonrpc: '2.0', method: 'notifications/resources/updated', params: { uri },
+      }), 150);
+      return;
+    }
+
+    case 'resources/read': {
+      const uri = params.uri;
+      if (uri === 'mock://upstream/slow') {
+        // In-flight fixture: reply after 2s so a gateway test has a WIDE window to fire a
+        // cancel at a genuinely outstanding forwarded request (400ms made the wire cancel test a flake candidate
+        // on a loaded runner).
+        setTimeout(() => writeMessage({
+          jsonrpc: '2.0', id,
+          result: { contents: [{ uri, mimeType: 'text/plain', text: 'slow done' }] },
+        }), 2000);
+        return;
+      }
+      if (uri === 'mock://upstream/readme') {
+        return writeMessage({
+          jsonrpc: '2.0', id,
+          result: { contents: [{ uri, mimeType: 'text/plain', text: 'mock upstream readme' }] },
+        });
+      }
+      return writeMessage({ jsonrpc: '2.0', id, error: { code: -32602, message: 'Unknown resource: ' + uri } });
+    }
+
     case 'tools/call': {
       const name = params.name;
       const args = params.arguments || {};
@@ -119,12 +269,72 @@ function handleMessage(msg) {
           const text = typeof args.text === 'string' ? args.text : JSON.stringify(args.text);
           return writeMessage({ jsonrpc: '2.0', id, result: textResult(text) });
         }
+        if (name === 'blocks') {
+          // Envelope-fidelity fixture: two content blocks AND structuredContent. A transparent
+          // forward must deliver this envelope VERBATIM - any re-shaping collapses it.
+          return writeMessage({
+            jsonrpc: '2.0', id,
+            result: {
+              content: [
+                { type: 'text', text: 'first block' },
+                { type: 'text', text: 'second block' },
+              ],
+              structuredContent: { first: 'first block', second: 'second block' },
+              isError: false,
+            },
+          });
+        }
         if (name === 'crash') {
           // Simulate an upstream crash: exit WITHOUT replying. The gateway's in-flight request
-          // rejects and its McpClient.onClose fires → the aggregator schedules a background
+          // rejects and its McpClient.onClose fires -> the aggregator schedules a background
           // reconnect. Exercised by reconnect.test.js.
           process.exit(1);
         }
+        if (name === 'slowtool') {
+          // The tool-path twin of mock://upstream/slow: a genuinely outstanding tools/call for
+          // cancel-translation tests.
+          setTimeout(() => writeMessage({ jsonrpc: '2.0', id, result: textResult('slowtool done') }), 2000);
+          return;
+        }
+        if (name === 'elicit') {
+          // elicitation-bridge fixture: ask the CLIENT a question mid-call, hold the tools/call open, and
+          // complete it from the answer - exactly what a real eliciting legacy server does.
+          const reqId = nextServerRequestId++;
+          outstandingServerRequests.set(reqId, (resp) => {
+            const res = resp && resp.result;
+            if (resp && resp.error) {
+              return writeMessage({ jsonrpc: '2.0', id, result: textResult('elicit error: ' + resp.error.message, true) });
+            }
+            const action = res && res.action;
+            if (action === 'accept') {
+              const colour = res.content && res.content.colour;
+              return writeMessage({ jsonrpc: '2.0', id, result: textResult('colour: ' + colour) });
+            }
+            return writeMessage({ jsonrpc: '2.0', id, result: textResult(String(action || 'no action')) });
+          });
+          // NO `mode` field - deliberately. Real pre-MRTR legacy upstreams send only
+          // {message, requestedSchema}; the BRIDGE must inject mode:"form" for the modern shape,
+          // and a fixture that includes it would mask that translation.
+          writeMessage({
+            jsonrpc: '2.0', id: reqId, method: 'elicitation/create',
+            params: {
+              message: 'Pick a colour',
+              requestedSchema: { type: 'object', properties: { colour: { type: 'string' } }, required: ['colour'] },
+            },
+          });
+          return; // the tools/call reply comes from the callback above
+        }
+        if (name === 'prog') {
+          // Progress fixture: a real server correlates progress via the REQUEST's _meta
+          // progressToken. If the gateway stripped _meta on the forward, token is
+          // undefined and no progress is emitted - the test's zero-count is the failure signal.
+          const token = params._meta && params._meta.progressToken;
+          if (token !== undefined) {
+            writeMessage({ jsonrpc: '2.0', method: 'notifications/progress', params: { progressToken: token, progress: 1, total: 2 } });
+            writeMessage({ jsonrpc: '2.0', method: 'notifications/progress', params: { progressToken: token, progress: 2, total: 2 } });
+          }
+          return writeMessage({ jsonrpc: '2.0', id, result: textResult(token !== undefined ? 'prog done (token seen)' : 'prog done (NO token)') });
+        }
         return writeMessage({ jsonrpc: '2.0', id, result: textResult('unknown tool: ' + name, true) });
       } catch (err) {
         return writeMessage({ jsonrpc: '2.0', id, result: textResult('error: ' + ((err && err.message) || err), true) });
@@ -151,7 +361,7 @@ process.stdin.on('data', (chunk) => {
   while ((nl = buffer.indexOf('\n')) !== -1) {
     const line = buffer.slice(0, nl).replace(/\r$/, '').trim();
     buffer = buffer.slice(nl + 1);
-    if (line.length === 0) continue; // blank separator line — ignore
+    if (line.length === 0) continue; // blank separator line - ignore
     let msg;
     try {
       msg = JSON.parse(line);