@cursor/july 0.1.20 → 0.1.21

package/src/internal/cursor/account-mcp.test.ts

@@ -0,0 +1,807 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { httpChannel } from "../../channels.js";
+import type { AgentProject, ConnectionTransport } from "../../types.js";
+import {
+  CursorAccountMcpBridge,
+  collectCursorAccountConnections,
+  cursorAccountMcpPath,
+  diagnoseConnectorError,
+  formatServerStatusSummary,
+  resolveCursorAccountConnections,
+} from "./account-mcp.js";
+import { CursorBackendClient } from "./backend-client.js";
+
+function makeProject(
+  name: string,
+  connections: Array<{ name: string; transport: ConnectionTransport }> = []
+): AgentProject {
+  return {
+    rootDir: `/tmp/account-fixture-${name}`,
+    agentDir: `/tmp/account-fixture-${name}/agent`,
+    name,
+    agent: {
+      name,
+      runtime: "local",
+      tools: [],
+      skills: [],
+      connections,
+      subagents: [],
+      seedFiles: [],
+    },
+    httpChannel: httpChannel(),
+    channels: [],
+    schedules: [],
+    hooks: [],
+    abs: [],
+    diagnostics: [],
+  };
+}
+
+function fakeJwt(): string {
+  const claims = Buffer.from(
+    JSON.stringify({ exp: Math.floor(Date.now() / 1000) + 3600 })
+  ).toString("base64url");
+  return `header.${claims}.signature`;
+}
+
+/** A stubbed backend client whose listings/executions come from `handlers`. */
+function stubClient(handlers: {
+  list?: (serverIdentifiers: readonly string[]) => unknown;
+  execute?: (body: {
+    serverIdentifier: string;
+    toolName: string;
+    args: Record<string, unknown>;
+  }) => unknown;
+  onList?: () => void;
+}): CursorBackendClient {
+  const fetchImpl = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = String(input);
+    if (url.endsWith("/auth/exchange_user_api_key")) {
+      return Response.json({ accessToken: fakeJwt(), refreshToken: "r" });
+    }
+    const body = JSON.parse(String(init?.body ?? "{}")) as Record<
+      string,
+      unknown
+    >;
+    if (url.endsWith("/ListSandMcpTools")) {
+      handlers.onList?.();
+      return Response.json(
+        handlers.list?.((body.serverIdentifiers as string[]) ?? []) ?? {
+          servers: [],
+        }
+      );
+    }
+    if (url.endsWith("/ExecuteSandMcpTool")) {
+      return Response.json(
+        handlers.execute?.(
+          body as {
+            serverIdentifier: string;
+            toolName: string;
+            args: Record<string, unknown>;
+          }
+        ) ?? { result: { error: { error: "no execute stub" } } }
+      );
+    }
+    return new Response("{}", { status: 404 });
+  }) as typeof fetch;
+  return new CursorBackendClient({
+    backendUrl: "https://backend.example",
+    apiKey: "crsr_key",
+    fetchImpl,
+  });
+}
+
+const CONNECTED_LINEAR = {
+  servers: [
+    {
+      serverIdentifier: "Linear",
+      status: "connected",
+      tools: [
+        {
+          name: "Linear-list_issues",
+          description: "List issues.",
+          inputSchema: { type: "object" },
+        },
+      ],
+    },
+  ],
+};
+
+function rpcRequest(secret: string, body: unknown): Request {
+  return new Request("http://127.0.0.1:3000/v1/cursor-account/cursor/mcp", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json, text/event-stream",
+      authorization: `Bearer ${secret}`,
+    },
+    body: JSON.stringify(body),
+  });
+}
+
+describe("collectCursorAccountConnections", () => {
+  it("groups account MCP connections by mount slug and keeps filters", () => {
+    const mounts = [
+      {
+        slug: "bugbot",
+        project: makeProject("bugbot", [
+          {
+            name: "cursor",
+            transport: { cursorAccount: true, servers: ["Linear"] },
+          },
+          { name: "linear", transport: { url: "https://mcp.example/mcp" } },
+        ]),
+      },
+      { slug: "plain", project: makeProject("plain") },
+    ];
+    const collected = collectCursorAccountConnections(mounts);
+    expect([...collected.keys()]).toEqual(["bugbot"]);
+    expect(collected.get("bugbot")).toEqual([
+      { name: "cursor", servers: ["Linear"] },
+    ]);
+  });
+});
+
+describe("resolveCursorAccountConnections", () => {
+  it("resolves loopback bridge URLs with the boot secret and no cloudUrl", () => {
+    const resolved = resolveCursorAccountConnections({
+      refs: [{ name: "cursor" }],
+      serverUrl: "http://127.0.0.1:4100",
+      basePath: "/bugbot",
+      bridgeSecret: "s3cret",
+    });
+    expect(resolved).toEqual([
+      {
+        name: "cursor",
+        localUrl: `http://127.0.0.1:4100/bugbot${cursorAccountMcpPath("cursor")}`,
+        headers: { authorization: "Bearer s3cret" },
+      },
+    ]);
+    expect(resolved[0]).not.toHaveProperty("cloudUrl");
+  });
+
+  it("resolves cloudUrl from publicUrl so cloud turns use the filtered bridge", () => {
+    const resolved = resolveCursorAccountConnections({
+      refs: [{ name: "cursor", servers: ["Linear"] }],
+      serverUrl: "http://127.0.0.1:4100",
+      basePath: "/bugbot",
+      bridgeSecret: "s3cret",
+      publicUrl: "https://agents.example.com",
+    });
+    expect(resolved[0]?.cloudUrl).toBe(
+      `https://agents.example.com/bugbot${cursorAccountMcpPath("cursor")}`
+    );
+  });
+
+  it("uses the serve bind host for localUrl when not loopback", () => {
+    const resolved = resolveCursorAccountConnections({
+      refs: [{ name: "cursor" }],
+      serverUrl: "http://192.168.1.50:4100",
+      basePath: "",
+      bridgeSecret: "s3cret",
+    });
+    expect(resolved[0]?.localUrl).toBe(
+      `http://192.168.1.50:4100${cursorAccountMcpPath("cursor")}`
+    );
+  });
+});
+
+describe("CursorAccountMcpBridge auth", () => {
+  const request = (secret?: string): Request =>
+    new Request("http://127.0.0.1:3000/v1/cursor-account/cursor/mcp", {
+      method: "POST",
+      ...(secret === undefined
+        ? {}
+        : { headers: { authorization: `Bearer ${secret}` } }),
+    });
+
+  it("admits only loopback callers presenting the boot secret by default", async () => {
+    const bridge = new CursorAccountMcpBridge({ client: stubClient({}) });
+    const policy = bridge.authPolicy();
+
+    expect(
+      await policy(request(bridge.secret), { requestIp: "127.0.0.1" })
+    ).toMatchObject({ principalType: "runtime" });
+    // Without a publicUrl the bridge is never remotely reachable — even
+    // with the secret.
+    expect(
+      await policy(request(bridge.secret), { requestIp: "203.0.113.9" })
+    ).toBeNull();
+    expect(
+      await policy(request("wrong-secret"), { requestIp: "127.0.0.1" })
+    ).toBeNull();
+    expect(await policy(request(), { requestIp: "127.0.0.1" })).toBeNull();
+  });
+
+  it("admits remote callers with the secret when publicUrl exposure is on", async () => {
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({}),
+      allowRemoteCallers: true,
+    });
+    const policy = bridge.authPolicy();
+
+    expect(
+      await policy(request(bridge.secret), { requestIp: "203.0.113.9" })
+    ).toMatchObject({ principalType: "runtime" });
+    expect(
+      await policy(request("wrong-secret"), { requestIp: "203.0.113.9" })
+    ).toBeNull();
+  });
+});
+
+describe("CursorAccountMcpBridge MCP surface", () => {
+  it("forwards every account connector when servers is omitted", async () => {
+    const requested: string[][] = [];
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: (serverIdentifiers) => {
+          requested.push([...serverIdentifiers]);
+          return {
+            servers: [
+              {
+                serverIdentifier: "Linear",
+                status: "connected",
+                tools: [
+                  {
+                    name: "Linear-list_issues",
+                    description: "List issues.",
+                    inputSchema: { type: "object" },
+                  },
+                ],
+              },
+              {
+                serverIdentifier: "Notion",
+                status: "connected",
+                tools: [
+                  {
+                    name: "Notion-search",
+                    description: "Search pages.",
+                    inputSchema: { type: "object" },
+                  },
+                ],
+              },
+            ],
+          };
+        },
+      }),
+    });
+    const ref = { name: "cursor" };
+
+    const listResponse = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/list",
+        params: {},
+      }),
+      ref
+    );
+    expect(listResponse.status).toBe(200);
+    expect(requested).toEqual([[]]);
+    const listBody = (await listResponse.json()) as {
+      result: { tools: Array<{ name: string }> };
+    };
+    expect(listBody.result.tools.map((tool) => tool.name).sort()).toEqual([
+      "Linear-list_issues",
+      "Notion-search",
+    ]);
+  });
+
+  it("lists connector tools and executes them on the backend", async () => {
+    const executions: Array<{ serverIdentifier: string; toolName: string }> =
+      [];
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: (serverIdentifiers) => {
+          expect(serverIdentifiers).toEqual(["Linear"]);
+          return CONNECTED_LINEAR;
+        },
+        execute: (body) => {
+          executions.push(body);
+          return {
+            result: {
+              success: {
+                content: [{ text: { text: "2 open issues" } }],
+                isError: false,
+              },
+            },
+          };
+        },
+      }),
+    });
+    const ref = { name: "cursor", servers: ["Linear"] };
+
+    const listResponse = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/list",
+        params: {},
+      }),
+      ref
+    );
+    expect(listResponse.status).toBe(200);
+    const listBody = (await listResponse.json()) as {
+      result: { tools: Array<{ name: string; inputSchema: unknown }> };
+    };
+    expect(listBody.result.tools).toEqual([
+      {
+        name: "Linear-list_issues",
+        description: "List issues.",
+        inputSchema: { type: "object" },
+      },
+    ]);
+
+    const callResponse = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: { name: "Linear-list_issues", arguments: { query: "open" } },
+      }),
+      ref
+    );
+    expect(callResponse.status).toBe(200);
+    const callBody = (await callResponse.json()) as {
+      result: { content: Array<{ type: string; text: string }> };
+    };
+    expect(callBody.result.content).toEqual([
+      { type: "text", text: "2 open issues" },
+    ]);
+    expect(executions).toHaveLength(1);
+    expect(executions[0]).toMatchObject({
+      serverIdentifier: "Linear",
+      toolName: "Linear-list_issues",
+      args: { query: "open" },
+    });
+  });
+
+  it("sanitizes exotic connector tool names and maps them back for execution", async () => {
+    const executed: string[] = [];
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => ({
+          servers: [
+            {
+              serverIdentifier: "My Wiki",
+              status: "connected",
+              tools: [
+                { name: "My Wiki-search pages" },
+                { name: "My Wiki-search_pages" },
+              ],
+            },
+          ],
+        }),
+        execute: (body) => {
+          executed.push(body.toolName);
+          return {
+            result: { success: { content: [{ text: { text: "ok" } }] } },
+          };
+        },
+      }),
+    });
+    const ref = { name: "cursor" };
+
+    const listResponse = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/list",
+        params: {},
+      }),
+      ref
+    );
+    const listBody = (await listResponse.json()) as {
+      result: { tools: Array<{ name: string }> };
+    };
+    // Both sanitize to the same base; the collision gets a suffix.
+    expect(listBody.result.tools.map((tool) => tool.name)).toEqual([
+      "My_Wiki-search_pages",
+      "My_Wiki-search_pages_2",
+    ]);
+
+    await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: { name: "My_Wiki-search_pages_2", arguments: {} },
+      }),
+      ref
+    );
+    // The backend receives the original fully-qualified name.
+    expect(executed).toEqual(["My Wiki-search_pages"]);
+  });
+
+  it("returns a tool error (not a crash) for unknown tools", async () => {
+    let listCalls = 0;
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => CONNECTED_LINEAR,
+        onList: () => {
+          listCalls++;
+        },
+      }),
+    });
+    const ref = { name: "cursor" };
+    const response = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: "does_not_exist", arguments: {} },
+      }),
+      ref
+    );
+    const body = (await response.json()) as {
+      result: { isError?: boolean; content: Array<{ text: string }> };
+    };
+    expect(body.result.isError).toBe(true);
+    expect(body.result.content[0]?.text).toContain(
+      'Unknown tool "does_not_exist"'
+    );
+    expect(body.result.content[0]?.text).toContain("Linear-list_issues");
+    // The catalog is fresh; the unknown name does not force a re-fetch.
+    expect(listCalls).toBe(1);
+  });
+
+  it("returns a tool error when backend execution throws", async () => {
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => CONNECTED_LINEAR,
+        execute: () => {
+          throw new Error("network down");
+        },
+      }),
+    });
+    const ref = { name: "cursor", servers: ["Linear"] };
+    const response = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: "Linear-list_issues", arguments: {} },
+      }),
+      ref
+    );
+    expect(response.status).toBe(200);
+    const body = (await response.json()) as {
+      result: { isError?: boolean; content: Array<{ text: string }> };
+    };
+    expect(body.result.isError).toBe(true);
+    expect(body.result.content[0]?.text).toContain("network down");
+  });
+
+  it("rejects non-POST requests per the stateless MCP contract", async () => {
+    const bridge = new CursorAccountMcpBridge({ client: stubClient({}) });
+    const response = await bridge.handle(
+      new Request("http://127.0.0.1:3000/v1/cursor-account/cursor/mcp", {
+        method: "GET",
+      }),
+      { name: "cursor" }
+    );
+    expect(response.status).toBe(405);
+  });
+});
+
+describe("CursorAccountMcpBridge catalog cache", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("coalesces concurrent readers and refreshes once after the TTL", async () => {
+    vi.useFakeTimers();
+    let listCalls = 0;
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => CONNECTED_LINEAR,
+        onList: () => {
+          listCalls++;
+        },
+      }),
+    });
+    const ref = { name: "cursor" };
+    const listRequest = (id: number): Request =>
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id,
+        method: "tools/list",
+        params: {},
+      });
+
+    // Concurrent cold readers share one backend fetch.
+    await Promise.all([
+      bridge.handle(listRequest(1), ref),
+      bridge.handle(listRequest(2), ref),
+    ]);
+    expect(listCalls).toBe(1);
+
+    // Within the TTL: served from cache.
+    await bridge.handle(listRequest(3), ref);
+    expect(listCalls).toBe(1);
+
+    // Past the TTL: concurrent stale readers coalesce onto ONE refresh.
+    vi.advanceTimersByTime(61_000);
+    await Promise.all([
+      bridge.handle(listRequest(4), ref),
+      bridge.handle(listRequest(5), ref),
+    ]);
+    expect(listCalls).toBe(2);
+  });
+
+  it("force-refreshes on unknown tools, throttled to the refresh floor", async () => {
+    vi.useFakeTimers();
+    let listCalls = 0;
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => CONNECTED_LINEAR,
+        onList: () => {
+          listCalls++;
+        },
+      }),
+    });
+    const ref = { name: "cursor" };
+    const unknownCall = (id: number): Request =>
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id,
+        method: "tools/call",
+        params: { name: "still_not_a_tool", arguments: {} },
+      });
+
+    // Fresh catalog: the unknown name joins it instead of re-fetching.
+    await bridge.handle(unknownCall(1), ref);
+    expect(listCalls).toBe(1);
+
+    // Past the force-refresh floor (but inside the TTL): the unknown name
+    // triggers exactly one re-fetch; an immediate repeat joins it.
+    vi.advanceTimersByTime(6_000);
+    await bridge.handle(unknownCall(2), ref);
+    expect(listCalls).toBe(2);
+    await bridge.handle(unknownCall(3), ref);
+    expect(listCalls).toBe(2);
+  });
+
+  it("assigns collision suffixes stably regardless of backend ordering", async () => {
+    const serverA = {
+      serverIdentifier: "A Wiki",
+      status: "connected",
+      tools: [{ name: "A Wiki-search", description: "from A" }],
+    };
+    const serverB = {
+      serverIdentifier: "A_Wiki",
+      status: "connected",
+      tools: [{ name: "A_Wiki-search", description: "from B" }],
+    };
+
+    const mappingFor = async (
+      servers: unknown[]
+    ): Promise<Map<string, string>> => {
+      const bridge = new CursorAccountMcpBridge({
+        client: stubClient({ list: () => ({ servers }) }),
+      });
+      const response = await bridge.handle(
+        rpcRequest(bridge.secret, {
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/list",
+          params: {},
+        }),
+        { name: "cursor" }
+      );
+      const body = (await response.json()) as {
+        result: { tools: Array<{ name: string; description: string }> };
+      };
+      return new Map(
+        body.result.tools.map((tool) => [tool.name, tool.description])
+      );
+    };
+
+    // Both tools sanitize to "A_Wiki-search"; the exposed-name → backend-tool
+    // mapping must not depend on which server the backend lists first.
+    const forward = await mappingFor([serverA, serverB]);
+    const reversed = await mappingFor([serverB, serverA]);
+    expect(forward).toEqual(reversed);
+    expect([...forward.keys()].sort()).toEqual([
+      "A_Wiki-search",
+      "A_Wiki-search_2",
+    ]);
+  });
+
+  it("assigns cross-group exposed names stably regardless of backend ordering", async () => {
+    const serverAlpha = {
+      serverIdentifier: "Alpha",
+      status: "connected",
+      tools: [
+        { name: "dup", description: "alpha-first" },
+        { name: "dup", description: "alpha-second" },
+      ],
+    };
+    const serverBeta = {
+      serverIdentifier: "Beta",
+      status: "connected",
+      tools: [{ name: "dup_2", description: "beta" }],
+    };
+
+    const mappingFor = async (
+      servers: unknown[]
+    ): Promise<Map<string, string>> => {
+      const bridge = new CursorAccountMcpBridge({
+        client: stubClient({ list: () => ({ servers }) }),
+      });
+      const response = await bridge.handle(
+        rpcRequest(bridge.secret, {
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/list",
+          params: {},
+        }),
+        { name: "cursor" }
+      );
+      const body = (await response.json()) as {
+        result: { tools: Array<{ name: string; description: string }> };
+      };
+      return new Map(
+        body.result.tools.map((tool) => [tool.description, tool.name])
+      );
+    };
+
+    const forward = await mappingFor([serverAlpha, serverBeta]);
+    const reversed = await mappingFor([serverBeta, serverAlpha]);
+    expect(forward).toEqual(reversed);
+    expect([...forward.values()].sort()).toEqual(["dup", "dup_2", "dup_2_2"]);
+  });
+
+  it("avoids global exposed-name collisions across sanitize groups", async () => {
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => ({
+          servers: [
+            {
+              serverIdentifier: "Linear",
+              status: "connected",
+              tools: [{ name: "search", description: "linear search" }],
+            },
+            {
+              serverIdentifier: "Other",
+              status: "connected",
+              tools: [{ name: "search_2", description: "other search" }],
+            },
+          ],
+        }),
+      }),
+    });
+    const response = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/list",
+        params: {},
+      }),
+      { name: "cursor" }
+    );
+    const body = (await response.json()) as {
+      result: { tools: Array<{ name: string }> };
+    };
+    const names = body.result.tools.map((tool) => tool.name);
+    expect(new Set(names).size).toBe(names.length);
+    expect(names.sort()).toEqual(["search", "search_2"]);
+  });
+});
+
+describe("formatServerStatusSummary", () => {
+  it("describes connected / needsAuth / error statuses", () => {
+    expect(
+      formatServerStatusSummary({
+        serverIdentifier: "Linear",
+        status: "connected",
+        tools: [{ name: "a", description: "", inputSchema: {} }],
+      })
+    ).toBe("Linear (1 tools)");
+    expect(
+      formatServerStatusSummary({
+        serverIdentifier: "Notion",
+        status: "needsAuth",
+        tools: [],
+      })
+    ).toBe("Notion (needsAuth — re-authorize in Cursor)");
+    expect(
+      formatServerStatusSummary(
+        { serverIdentifier: "anytool", status: "error", tools: [] },
+        "HTTP MCP tool execution failed: fetch failed"
+      )
+    ).toBe("anytool (error: HTTP MCP tool execution failed: fetch failed)");
+    expect(
+      formatServerStatusSummary({
+        serverIdentifier: "anytool",
+        status: "error",
+        tools: [],
+      })
+    ).toBe("anytool (error: backend could not reach connector)");
+  });
+});
+
+describe("diagnoseConnectorError", () => {
+  it("returns the backend execute failure text", async () => {
+    const detail = await diagnoseConnectorError(
+      {
+        executeAccountMcpTool: async () => ({
+          content: [
+            {
+              type: "text",
+              text: "HTTP MCP tool execution failed: fetch failed",
+            },
+          ],
+          isError: true,
+        }),
+      },
+      "anytool"
+    );
+    expect(detail).toBe("HTTP MCP tool execution failed: fetch failed");
+  });
+});
+
+describe("CursorAccountMcpBridge.logPreflight", () => {
+  it("logs connector error detail from a backend probe", async () => {
+    const lines: string[] = [];
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => ({
+          servers: [
+            { serverIdentifier: "anytool", status: "error", tools: [] },
+            {
+              serverIdentifier: "Linear",
+              status: "connected",
+              tools: [{ name: "Linear-list_issues" }],
+            },
+          ],
+        }),
+        execute: () => ({
+          result: {
+            error: {
+              error: "HTTP MCP tool execution failed: fetch failed",
+            },
+          },
+        }),
+      }),
+      logger: (line) => lines.push(line),
+    });
+
+    await bridge.logPreflight([{ name: "anytool", servers: ["anytool"] }]);
+
+    expect(lines[0]).toContain(
+      'Cursor account MCP connection "anytool": anytool (error: HTTP MCP tool execution failed: fetch failed), Linear (1 tools)'
+    );
+    expect(
+      lines.some((line) => line.includes("could not use this connector"))
+    ).toBe(true);
+  });
+
+  it("mentions unhealthy connectors when a tool is missing", async () => {
+    const bridge = new CursorAccountMcpBridge({
+      client: stubClient({
+        list: () => ({
+          servers: [
+            { serverIdentifier: "anytool", status: "error", tools: [] },
+          ],
+        }),
+      }),
+    });
+    const response = await bridge.handle(
+      rpcRequest(bridge.secret, {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: "create_anyship_deployment", arguments: {} },
+      }),
+      { name: "anytool", servers: ["anytool"] }
+    );
+    const body = (await response.json()) as {
+      result: { content: Array<{ text: string }>; isError?: boolean };
+    };
+    expect(body.result.isError).toBe(true);
+    expect(body.result.content[0]?.text).toContain(
+      "Unhealthy connectors: anytool=error"
+    );
+  });
+});