@cursor/july 0.1.23 → 0.1.24

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

@@ -1,807 +0,0 @@
-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"
-    );
-  });
-});