Bump a2amcp to 0.1.7

.gitignore

@@ -1,5 +1,6 @@
 node_modules/
 dist/
+.codegraph/
 *.log
 *.tsbuildinfo
 .DS_Store

README.md

@@ -4,6 +4,21 @@ MCP gateway for a2acloud agents. It runs locally as a stdio MCP server and
 exposes deployed A2A agents as tools to Claude Code, Cursor, and other MCP
 clients.
 
+This package is the **local stdio gateway**. It is different from the hosted
+OAuth MCP connector endpoints used by ChatGPT/Claude web connectors:
+
+```text
+Local stdio gateway:        npx -y a2amcp
+Remote standard MCP:        https://<agent>.a2acloud.io/mcp
+Remote connector MCP:       https://<agent>.a2acloud.io/connector-mcp
+Remote orchestrator MCP:    https://api.a2acloud.io/connector-mcp
+```
+
+Use `a2amcp` for editor clients that launch a local MCP server process. Use the
+remote `/connector-mcp` URL for hosted connector UIs that need OAuth login,
+Dynamic Client Registration, async job polling, and structured approval/input
+interrupts.
+
 ## Quickstart
 
 ```bash
@@ -41,3 +56,19 @@ a2amcp logout             # clear local credentials
 ```
 
 Running `a2amcp` with no command starts the MCP gateway over stdio.
+
+## Hosted OAuth Connectors
+
+ChatGPT and Claude-style hosted connectors should not run this stdio gateway.
+Configure them directly with the remote connector URL:
+
+```text
+https://api.a2acloud.io/connector-mcp
+https://<agent>.a2acloud.io/connector-mcp
+```
+
+Choose OAuth authentication. The server advertises protected-resource metadata,
+the client dynamically registers with Keycloak, and the browser consent flow
+issues tokens scoped to MCP access. Long-running connector calls return a
+`job_id`; the client should poll `chat_result` on the orchestrator connector or
+`job_result` on a leaf-agent connector.

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "a2amcp",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "a2amcp",
-      "version": "0.1.6",
+      "version": "0.1.7",
       "license": "Apache-2.0",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.0.4",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "a2amcp",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "MCP gateway for a2acloud agents. Run as a local MCP server; expose any number of deployed A2A agents to Claude Code, Cursor, and other MCP clients.",
   "type": "module",
   "bin": {

src/api.ts

@@ -15,6 +15,7 @@ export interface AgentRow {
   status: string;
   url?: string;
   description?: string;
+  card?: Record<string, any>;
 }
 
 export class ControlPlaneClient {

src/cli.ts

@@ -43,6 +43,30 @@ function fail(msg: string, code = 1): never {
   process.exit(code);
 }
 
+function normalizeMcpPath(path: unknown): string {
+  if (typeof path !== "string" || !path.trim()) return "/mcp";
+  const trimmed = path.trim();
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+function mcpTargetForAgent(
+  row: { name: string; url?: string; card?: Record<string, any> },
+  apiUrl: string,
+): { url?: string; mcpPath: string } {
+  const imported = row.card?.capabilities?.a2a_cloud_import;
+  const mcp = imported?.mcp;
+  if (mcp?.mode === "generated") {
+    return {
+      url: `${apiUrl.replace(/\/+$/, "")}/v1/agents/${encodeURIComponent(row.name)}`,
+      mcpPath: normalizeMcpPath(mcp.path),
+    };
+  }
+  return {
+    url: mcp?.base_url || row.url,
+    mcpPath: normalizeMcpPath(mcp?.path || row.card?.mcp_endpoint),
+  };
+}
+
 async function prompt(label: string, opts: { hidden?: boolean } = {}): Promise<string> {
   const rl = readline.createInterface({ input, output, terminal: true });
   try {
@@ -160,7 +184,9 @@ program
       output.write("(no agents added; try `a2amcp add <name>`)\n");
       return;
     }
-    for (const a of cfg.agents) output.write(`  ${a.name}  ${a.url}\n`);
+    for (const a of cfg.agents) {
+      output.write(`  ${a.name}  ${a.url}${a.mcpPath ?? "/mcp"}\n`);
+    }
   });
 
 program
@@ -171,11 +197,16 @@ program
   .action(
     async (name: string, opts: { url?: string; api?: string }) => {
       let url = opts.url;
+      let mcpPath = "/mcp";
       let description: string | undefined;
       if (!url) {
         try {
-          const row = await (await client(opts.api)).getAgent(name);
-          url = row.url;
+          const creds = await loadCredentials();
+          const apiUrl = resolveApiUrl(opts.api ?? creds?.apiUrl);
+          const row = await new ControlPlaneClient(apiUrl, creds?.token ?? null).getAgent(name);
+          const target = mcpTargetForAgent(row, apiUrl);
+          url = target.url;
+          mcpPath = target.mcpPath;
           description = row.description;
         } catch (err) {
           fail(err instanceof ApiError ? err.message : (err as Error).message);
@@ -185,10 +216,11 @@ program
       await addAgent({
         name,
         url,
+        mcpPath,
         description,
         addedAt: new Date().toISOString(),
       });
-      output.write(`added ${name} -> ${url}\n`);
+      output.write(`added ${name} -> ${url.replace(/\/+$/, "")}${mcpPath}\n`);
       output.write("restart your MCP client to pick up the new tools.\n");
     },
   );
@@ -219,6 +251,7 @@ program
       const u = new UpstreamAgent({
         name: a.name,
         url: a.url,
+        mcpPath: a.mcpPath,
         token: creds?.token ?? null,
       });
       try {

src/config.ts

@@ -12,6 +12,7 @@ import path from "node:path";
 export interface EnabledAgent {
   name: string;
   url: string;
+  mcpPath?: string;
   description?: string;
   addedAt: string;
 }

src/gateway.ts

@@ -11,7 +11,9 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
+  ElicitResultSchema,
   ListToolsRequestSchema,
+  ResultSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 
 import { loadConfig, type EnabledAgent } from "./config.js";
@@ -28,6 +30,10 @@ export interface GatewayOptions {
   agents?: EnabledAgent[];
   /** Override the bearer token (otherwise read from ~/.a2a/credentials.json). */
   token?: string | null;
+  /** Test/advanced override for one-shot upstream JSON-RPC calls. */
+  upstreamRequestTimeoutMs?: number;
+  /** Test/advanced override for idle SSE upstream tools/call streams. */
+  upstreamStreamIdleTimeoutMs?: number;
   /** Optional override for the underlying MCP Server (tests). */
   server?: Server;
 }
@@ -54,8 +60,10 @@ export async function buildGateway(opts: GatewayOptions = {}): Promise<GatewayHa
     upstreams.set(
       a.name,
       new UpstreamAgent({
-        name: a.name, url: a.url, token,
+        name: a.name, url: a.url, mcpPath: a.mcpPath, token,
         cpJwt, cpUrl, bucket,
+        requestTimeoutMs: opts.upstreamRequestTimeoutMs,
+        streamIdleTimeoutMs: opts.upstreamStreamIdleTimeoutMs,
       }),
     );
   }
@@ -130,6 +138,18 @@ export async function buildGateway(opts: GatewayOptions = {}): Promise<GatewayHa
               // best effort
             }
           },
+          onRequest: async (upstreamReq) => {
+            const schema = upstreamReq.method === "elicitation/create"
+              ? ElicitResultSchema
+              : ResultSchema;
+            return extra.sendRequest(
+              {
+                method: upstreamReq.method,
+                params: upstreamReq.params,
+              } as any,
+              schema as any,
+            );
+          },
         },
       );
       // Pass through the upstream's CallToolResult as-is. Upstreams already

src/upstream.ts

@@ -7,11 +7,16 @@
  * header without coupling to a transport class.
  */
 const JSON_RPC = "2.0";
+const DEFAULT_RPC_TIMEOUT_MS = 30_000;
+const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 120_000;
 
 export interface UpstreamConfig {
   name: string;
   url: string;
+  mcpPath?: string;
   token: string | null;
+  requestTimeoutMs?: number;
+  streamIdleTimeoutMs?: number;
   /** Forwarded to the upstream as ``params._meta.cp_jwt`` on tools/call.
    *  Lets the upstream agent act on the caller's behalf (file/agent CRUD
    *  on /v1/me/*) — same path the platform orchestrator uses. */
@@ -39,6 +44,12 @@ export interface UpstreamCallResult {
   isError?: boolean;
 }
 
+export interface UpstreamServerRequest {
+  id: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
 export class UpstreamError extends Error {
   constructor(
     public agent: string,
@@ -52,27 +63,48 @@ export class UpstreamError extends Error {
 
 let _nextId = 1;
 
+function normalizeMcpPath(path: string | undefined): string {
+  if (!path) return "/mcp";
+  const trimmed = path.trim();
+  if (!trimmed) return "/mcp";
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
 export class UpstreamAgent {
   constructor(private cfg: UpstreamConfig) {
     this.cfg.url = cfg.url.replace(/\/+$/, "");
+    this.cfg.mcpPath = normalizeMcpPath(cfg.mcpPath);
   }
 
   get name(): string {
     return this.cfg.name;
   }
 
+  private mcpUrl(): string {
+    return `${this.cfg.url}${this.cfg.mcpPath ?? "/mcp"}`;
+  }
+
   private async rpc<T>(method: string, params: unknown): Promise<T> {
     const id = _nextId++;
+    const timeoutMs = this.cfg.requestTimeoutMs ?? DEFAULT_RPC_TIMEOUT_MS;
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
     const headers: Record<string, string> = {
       "content-type": "application/json",
       accept: "application/json",
     };
     if (this.cfg.token) headers["authorization"] = `Bearer ${this.cfg.token}`;
 
-    const resp = await fetch(`${this.cfg.url}/mcp`, {
+    try {
+      const resp = await fetch(this.mcpUrl(), {
         method: "POST",
         headers,
         body: JSON.stringify({ jsonrpc: JSON_RPC, id, method, params }),
+        signal: controller.signal,
       });
 
       if (!resp.ok) {
@@ -89,6 +121,18 @@ export class UpstreamAgent {
         );
       }
       return env?.result as T;
+    } catch (err) {
+      if (timedOut) {
+        throw new UpstreamError(
+          this.cfg.name,
+          504,
+          `request timed out after ${timeoutMs}ms`,
+        );
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
   }
 
   async listTools(): Promise<UpstreamTool[]> {
@@ -104,6 +148,7 @@ export class UpstreamAgent {
         method: string;
         params?: Record<string, unknown>;
       }) => void | Promise<void>;
+      onRequest?: (req: UpstreamServerRequest) => unknown | Promise<unknown>;
       progressToken?: string | number;
     } = {},
   ): Promise<UpstreamCallResult> {
@@ -114,7 +159,10 @@ export class UpstreamAgent {
     if (opts.progressToken !== undefined) meta.progressToken = opts.progressToken;
     const params: Record<string, unknown> = { name, arguments: arguments_ };
     if (Object.keys(meta).length > 0) params._meta = meta;
-    return this.streamingCallTool(params, opts.onNotification);
+    return this.streamingCallTool(params, {
+      onNotification: opts.onNotification,
+      onRequest: opts.onRequest,
+    });
   }
 
   /**
@@ -123,35 +171,65 @@ export class UpstreamAgent {
    * a deploy + a wait-for-live-card poll), and a plain JSON POST gets
    * killed by ingress idle timeouts (~60s default on traefik). The
    * upstream's SSE response interleaves any elicitation/create requests
-   * and a final tools/call result; here we drain the stream and return
-   * the final result. (Elicit relaying to the MCP client is not wired
-   * yet — any elicit that fires will time out on the upstream side and
-   * the skill will surface a soft error.)
+   * and a final tools/call result; here we relay server-to-client
+   * requests through the MCP client and return the final result.
    */
   private async streamingCallTool(
     params: Record<string, unknown>,
+    handlers: {
       onNotification?: (notif: {
         method: string;
         params?: Record<string, unknown>;
-    }) => void | Promise<void>,
+      }) => void | Promise<void>;
+      onRequest?: (req: UpstreamServerRequest) => unknown | Promise<unknown>;
+    } = {},
   ): Promise<UpstreamCallResult> {
     const id = _nextId++;
+    const idleTimeoutMs =
+      this.cfg.streamIdleTimeoutMs ?? DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+    const controller = new AbortController();
+    let timedOut = false;
+    let idleTimer: ReturnType<typeof setTimeout> | undefined;
+    const resetIdleTimer = () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, idleTimeoutMs);
+    };
+    resetIdleTimer();
     const headers: Record<string, string> = {
       "content-type": "application/json",
       accept: "text/event-stream, application/json",
     };
     if (this.cfg.token) headers["authorization"] = `Bearer ${this.cfg.token}`;
 
-    const resp = await fetch(`${this.cfg.url}/mcp`, {
+    let resp: Response;
+    try {
+      resp = await fetch(this.mcpUrl(), {
         method: "POST",
         headers,
         body: JSON.stringify({
           jsonrpc: JSON_RPC, id, method: "tools/call", params,
         }),
+        signal: controller.signal,
       });
+    } catch (err) {
+      clearTimeout(idleTimer);
+      if (timedOut) {
+        throw new UpstreamError(
+          this.cfg.name,
+          504,
+          `stream idle timeout after ${idleTimeoutMs}ms`,
+        );
+      }
+      throw err;
+    }
+    resetIdleTimer();
 
     if (!resp.ok) {
       const text = await resp.text().catch(() => "");
+      clearTimeout(idleTimer);
       throw new UpstreamError(this.cfg.name, resp.status, text || resp.statusText);
     }
 
@@ -160,15 +238,20 @@ export class UpstreamAgent {
       // Server fell back to JSON (older a2a-pack or non-SSE upstream).
       const env: any = await resp.json();
       if (env?.error) {
+        clearTimeout(idleTimer);
         throw new UpstreamError(
           this.cfg.name, 500,
           `${env.error.code}: ${env.error.message}`,
         );
       }
+      clearTimeout(idleTimer);
       return env?.result as UpstreamCallResult;
     }
 
+    const upstreamSessionId = resp.headers.get("mcp-session-id");
+
     if (!resp.body) {
+      clearTimeout(idleTimer);
       throw new UpstreamError(this.cfg.name, 502, "empty stream body");
     }
 
@@ -177,8 +260,24 @@ export class UpstreamAgent {
     let buf = "";
     try {
       while (true) {
-        const { done, value } = await reader.read();
-        if (value) buf += decoder.decode(value, { stream: true });
+        let done: boolean;
+        let value: Uint8Array | undefined;
+        try {
+          ({ done, value } = await reader.read());
+        } catch (err) {
+          if (timedOut) {
+            throw new UpstreamError(
+              this.cfg.name,
+              504,
+              `stream idle timeout after ${idleTimeoutMs}ms`,
+            );
+          }
+          throw err;
+        }
+        if (value) {
+          resetIdleTimer();
+          buf += decoder.decode(value, { stream: true });
+        }
         let sep = buf.indexOf("\n\n");
         while (sep !== -1) {
           const frame = buf.slice(0, sep);
@@ -189,6 +288,10 @@ export class UpstreamAgent {
           }
           if (dataLines.length > 0) {
             const raw = dataLines.join("\n");
+            if (raw === "[DONE]") {
+              sep = buf.indexOf("\n\n");
+              continue;
+            }
             let msg: any;
             try { msg = JSON.parse(raw); } catch { msg = null; }
             if (msg && msg.id === id) {
@@ -201,19 +304,24 @@ export class UpstreamAgent {
               return msg.result as UpstreamCallResult;
             }
             // Otherwise it's a server→client message. Notifications
-            // (no id) → forward to the MCP client so long-running
-            // skills keep the client's tool-call timer alive. Requests
-            // (has id, has method) — e.g. elicitation/create — are
-            // not relayed yet, so they will time out upstream.
-            if (msg && typeof msg.method === "string" && !("id" in msg) && onNotification) {
+            // (no id) are best-effort. Requests (has id, has method), such
+            // as elicitation/create, must be relayed and answered upstream.
+            if (msg && typeof msg.method === "string" && !("id" in msg) && handlers.onNotification) {
               try {
-                await onNotification({
+                await handlers.onNotification({
                   method: msg.method,
                   params: msg.params as Record<string, unknown> | undefined,
                 });
               } catch {
                 // Best-effort; never break the stream on a notify error.
               }
+            } else if (msg && typeof msg.method === "string" && "id" in msg) {
+              await this.relayServerRequest(upstreamSessionId, {
+                id: msg.id as string | number,
+                method: msg.method,
+                params: msg.params as Record<string, unknown> | undefined,
+              }, handlers.onRequest);
+              resetIdleTimer();
             }
           }
           sep = buf.indexOf("\n\n");
@@ -221,8 +329,58 @@ export class UpstreamAgent {
         if (done) break;
       }
     } finally {
+      clearTimeout(idleTimer);
       try { reader.releaseLock(); } catch { /* ignore */ }
     }
     throw new UpstreamError(this.cfg.name, 502, "stream ended without result");
   }
+
+  private async relayServerRequest(
+    upstreamSessionId: string | null,
+    req: UpstreamServerRequest,
+    onRequest?: (req: UpstreamServerRequest) => unknown | Promise<unknown>,
+  ): Promise<void> {
+    if (!upstreamSessionId) {
+      throw new UpstreamError(
+        this.cfg.name,
+        502,
+        `upstream request ${req.method} missing Mcp-Session-Id`,
+      );
+    }
+    let envelope: Record<string, unknown>;
+    try {
+      if (!onRequest) throw new Error(`no client request relay for ${req.method}`);
+      const result = await onRequest(req);
+      envelope = { jsonrpc: JSON_RPC, id: req.id, result };
+    } catch (err) {
+      envelope = {
+        jsonrpc: JSON_RPC,
+        id: req.id,
+        error: {
+          code: -32603,
+          message: err instanceof Error ? err.message : String(err),
+        },
+      };
+    }
+
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      accept: "application/json",
+      "mcp-session-id": upstreamSessionId,
+    };
+    if (this.cfg.token) headers.authorization = `Bearer ${this.cfg.token}`;
+    const resp = await fetch(this.mcpUrl(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(envelope),
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new UpstreamError(
+        this.cfg.name,
+        resp.status,
+        text || `failed to deliver response for ${req.method}`,
+      );
+    }
+  }
 }

tests/gateway.test.ts

@@ -9,7 +9,7 @@ import {
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 
-import { buildGateway, SEP } from "../src/gateway.js";
+import { buildGateway, SEP, type GatewayOptions } from "../src/gateway.js";
 import type { EnabledAgent } from "../src/config.js";
 
 /**
@@ -70,25 +70,65 @@ function startFakeAgent(opts: {
   });
 }
 
+function startSseAgent(opts: {
+  onCall: (body: any, res: http.ServerResponse) => void;
+}): Promise<{ url: string; close: () => Promise<void>; requests: any[] }> {
+  const requests: any[] = [];
+  return new Promise((resolve) => {
+    const server = http.createServer((req, res) => {
+      if (req.method !== "POST" || req.url !== "/mcp") {
+        res.statusCode = 404;
+        res.end();
+        return;
+      }
+      const chunks: Buffer[] = [];
+      req.on("data", (c) => chunks.push(c));
+      req.on("end", () => {
+        const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        requests.push({ body });
+        if (body.method !== "tools/call") {
+          res.setHeader("content-type", "application/json");
+          res.end(JSON.stringify({ jsonrpc: "2.0", id: body.id, result: {} }));
+          return;
+        }
+        res.writeHead(200, { "content-type": "text/event-stream" });
+        opts.onCall(body, res);
+      });
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address() as AddressInfo;
+      resolve({
+        url: `http://127.0.0.1:${port}`,
+        requests,
+        close: () => new Promise((r) => server.close(() => r())),
+      });
+    });
+  });
+}
+
 /** Drive an in-process gateway Server via the SDK's request handlers. */
 async function callGateway(
   agents: EnabledAgent[],
   token: string | null,
   method: "tools/list" | "tools/call",
   params: any,
+  opts: {
+    gateway?: Partial<Omit<GatewayOptions, "agents" | "token" | "server">>;
+    extra?: any;
+  } = {},
 ) {
   const mcpServer = new Server(
     { name: "test", version: "0.0.0" },
     { capabilities: { tools: { listChanged: false } } },
   );
-  await buildGateway({ agents, token, server: mcpServer });
+  await buildGateway({ agents, token, server: mcpServer, ...opts.gateway });
   // Reach into the server's registered handlers — the SDK exposes them via
   // a private map, so we route through the public schema-keyed lookup we
   // know is wired up.
   const schema = method === "tools/list" ? ListToolsRequestSchema : CallToolRequestSchema;
   const handler = (mcpServer as any)._requestHandlers.get(schema.shape.method.value);
   if (!handler) throw new Error("handler not registered");
-  return handler({ method, params }, {} as any);
+  return handler({ method, params }, opts.extra ?? ({} as any));
 }
 
 test("tools/list aggregates upstream tools with agent prefix", async () => {
@@ -209,3 +249,168 @@ test("tools/call surfaces upstream JSON-RPC error as soft error", async () => {
     await upstream.close();
   }
 });
+
+test("tools/call forwards upstream SSE progress notifications", async () => {
+  const upstream = await startSseAgent({
+    onCall: (body, res) => {
+      res.write(
+        `data: ${JSON.stringify({
+          jsonrpc: "2.0",
+          method: "notifications/progress",
+          params: { progressToken: "p1", message: "halfway" },
+        })}\n\n`,
+      );
+      res.end(
+        `data: ${JSON.stringify({
+          jsonrpc: "2.0",
+          id: body.id,
+          result: {
+            content: [{ type: "text", text: "done" }],
+            isError: false,
+          },
+        })}\n\n`,
+      );
+    },
+  });
+  const notifications: any[] = [];
+  try {
+    const result = await callGateway(
+      [{ name: "streamer", url: upstream.url, addedAt: "now" }],
+      null,
+      "tools/call",
+      { name: `streamer${SEP}build`, arguments: {} },
+      {
+        extra: {
+          requestId: "req-1",
+          sendNotification: async (notification: any) => {
+            notifications.push(notification);
+          },
+        },
+      },
+    );
+    assert.equal(result.isError, false);
+    assert.deepEqual(notifications, [
+      {
+        method: "notifications/progress",
+        params: { progressToken: "p1", message: "halfway" },
+      },
+    ]);
+  } finally {
+    await upstream.close();
+  }
+});
+
+test("tools/call reports upstream SSE idle timeout", async () => {
+  const upstream = await startSseAgent({
+    onCall: (_body, res) => {
+      res.write(": connected\n\n");
+    },
+  });
+  try {
+    const result = await callGateway(
+      [{ name: "slow", url: upstream.url, addedAt: "now" }],
+      null,
+      "tools/call",
+      { name: `slow${SEP}build`, arguments: {} },
+      { gateway: { upstreamStreamIdleTimeoutMs: 25 } },
+    );
+    assert.equal(result.isError, true);
+    assert.match(result.content[0].text, /stream idle timeout/);
+  } finally {
+    await upstream.close();
+  }
+});
+
+test("tools/call relays upstream elicitation requests", async () => {
+  let resolveResponse: (() => void) | undefined;
+  const responseSeen = new Promise<void>((resolve) => { resolveResponse = resolve; });
+  let upstreamResponse: any = null;
+  const requests: any[] = [];
+  const server = http.createServer((req, res) => {
+    if (req.method !== "POST" || req.url !== "/mcp") {
+      res.statusCode = 404;
+      res.end();
+      return;
+    }
+    const chunks: Buffer[] = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      requests.push({ headers: req.headers, body });
+      if (body.method === "tools/call") {
+        res.writeHead(200, {
+          "content-type": "text/event-stream",
+          "Mcp-Session-Id": "sess-1",
+        });
+        res.write(
+          `data: ${JSON.stringify({
+            jsonrpc: "2.0",
+            id: "ask-1",
+            method: "elicitation/create",
+            params: { message: "Name?", requestedSchema: { type: "object" } },
+          })}\n\n`,
+        );
+        void responseSeen.then(() => {
+          res.end(
+            `data: ${JSON.stringify({
+              jsonrpc: "2.0",
+              id: body.id,
+              result: {
+                content: [{ type: "text", text: upstreamResponse.result.content.answer }],
+                isError: false,
+              },
+            })}\n\n`,
+          );
+        });
+        return;
+      }
+      if (body.id === "ask-1" && req.headers["mcp-session-id"] === "sess-1") {
+        upstreamResponse = body;
+        res.statusCode = 202;
+        res.end();
+        resolveResponse?.();
+        return;
+      }
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify({ jsonrpc: "2.0", id: body.id, result: {} }));
+    });
+  });
+  const upstream = await new Promise<{ url: string; close: () => Promise<void> }>((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address() as AddressInfo;
+      resolve({
+        url: `http://127.0.0.1:${port}`,
+        close: () => new Promise((r) => server.close(() => r())),
+      });
+    });
+  });
+  const clientRequests: any[] = [];
+  try {
+    const result = await callGateway(
+      [{ name: "human", url: upstream.url, addedAt: "now" }],
+      null,
+      "tools/call",
+      { name: `human${SEP}run_demo`, arguments: {} },
+      {
+        extra: {
+          requestId: "req-elicitation",
+          sendNotification: async () => {},
+          sendRequest: async (request: any) => {
+            clientRequests.push(request);
+            return { action: "accept", content: { answer: "Alice" } };
+          },
+        },
+      },
+    );
+    assert.equal(result.isError, false);
+    assert.equal(result.content[0].text, "Alice");
+    assert.equal(clientRequests[0].method, "elicitation/create");
+    assert.deepEqual(upstreamResponse.result, {
+      action: "accept",
+      content: { answer: "Alice" },
+    });
+    assert.ok(requests.some((r) => r.body.id === "ask-1"));
+  } finally {
+    await upstream.close();
+  }
+});