@carbon-copy/mcp 0.1.0

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@carbon-copy/mcp",
+  "version": "0.1.0",
+  "description": "An MCP server that gives AI agents programmatic access to Carbon Copy - a Polymarket copy-trading platform.",
+  "type": "module",
+  "bin": {
+    "carboncopy-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepare": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CarbonCopyInc/carboncopy-mcp.git"
+  },
+  "keywords": [
+    "mcp",
+    "carboncopy",
+    "polymarket",
+    "copy-trading"
+  ],
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/CarbonCopyInc/carboncopy-mcp/issues"
+  },
+  "homepage": "https://github.com/CarbonCopyInc/carboncopy-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "^5.8.0",
+    "vitest": "^4.0.18"
+  }
+}

package/src/__tests__/client.test.ts

@@ -0,0 +1,392 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { CarbonCopyClient } from "../client.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+type MockResponseOptions = {
+  ok?: boolean;
+  status?: number;
+  statusText?: string;
+  contentLength?: string;
+  body?: unknown;
+  bodyText?: string;
+  /** If true, cloned.json() rejects (tests the text() fallback path) */
+  cloneJsonThrows?: boolean;
+};
+
+function createMockResponse(opts: MockResponseOptions = {}) {
+  const {
+    ok = true,
+    status = 200,
+    statusText = "OK",
+    contentLength,
+    body = null,
+    bodyText = "",
+    cloneJsonThrows = false,
+  } = opts;
+
+  const headers: Record<string, string> = {};
+  if (contentLength !== undefined) headers["content-length"] = contentLength;
+
+  const jsonFn = vi.fn().mockResolvedValue(body);
+  const textFn = vi.fn().mockResolvedValue(
+    bodyText || (body !== null ? JSON.stringify(body) : "")
+  );
+
+  // The clone is only used for error-path json parsing
+  const cloneJsonFn = cloneJsonThrows
+    ? vi.fn().mockRejectedValue(new Error("not json"))
+    : vi.fn().mockResolvedValue(body);
+
+  const clone = vi.fn().mockReturnValue({ json: cloneJsonFn });
+
+  return {
+    ok,
+    status,
+    statusText,
+    headers: { get: (name: string) => headers[name.toLowerCase()] ?? null },
+    json: jsonFn,
+    text: textFn,
+    clone,
+  };
+}
+
+const BASE = "https://carboncopy.news";
+
+describe("CarbonCopyClient", () => {
+  let fetchMock: ReturnType<typeof vi.fn>;
+  let client: CarbonCopyClient;
+
+  beforeEach(() => {
+    fetchMock = vi.fn();
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+    client = new CarbonCopyClient("cc_testkey");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // -------------------------------------------------------------------------
+  // Core request behaviour
+  // -------------------------------------------------------------------------
+
+  describe("request() — GET", () => {
+    it("sends correct URL and Authorization header, returns parsed JSON", async () => {
+      const data = { total: 42 };
+      fetchMock.mockResolvedValue(createMockResponse({ body: data }));
+
+      const result = await client.getPortfolio();
+
+      expect(fetchMock).toHaveBeenCalledOnce();
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/portfolio`);
+      expect((init.headers as Record<string, string>)["Authorization"]).toBe(
+        "Bearer cc_testkey"
+      );
+      expect((init.headers as Record<string, string>)["Content-Type"]).toBe(
+        "application/json"
+      );
+      expect(init.method).toBe("GET");
+      expect(init.body).toBeUndefined();
+      expect(result).toEqual(data);
+    });
+  });
+
+  describe("request() — POST", () => {
+    it("serialises body to JSON and sends correct method", async () => {
+      const responseData = { id: "trader-1" };
+      fetchMock.mockResolvedValue(createMockResponse({ body: responseData }));
+
+      const payload = {
+        walletAddress: "0xabc",
+        copyPercentage: 50,
+      };
+      await client.followTrader(payload);
+
+      const [, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(init.method).toBe("POST");
+      expect(init.body).toBe(JSON.stringify(payload));
+    });
+  });
+
+  describe("request() — error handling", () => {
+    it("throws an error including status and response body when response is not ok", async () => {
+      const errBody = { message: "Unauthorized" };
+      fetchMock.mockResolvedValue(
+        createMockResponse({
+          ok: false,
+          status: 401,
+          statusText: "Unauthorized",
+          body: errBody,
+        })
+      );
+
+      await expect(client.getPortfolio()).rejects.toThrow(
+        /Carbon Copy API error 401 Unauthorized/
+      );
+      await expect(client.getPortfolio()).rejects.toThrow(
+        /Unauthorized/
+      );
+    });
+
+    it("falls back to res.text() when cloned.json() fails on error response", async () => {
+      fetchMock.mockResolvedValue(
+        createMockResponse({
+          ok: false,
+          status: 500,
+          statusText: "Internal Server Error",
+          bodyText: "raw error text",
+          cloneJsonThrows: true,
+        })
+      );
+
+      await expect(client.getPortfolio()).rejects.toThrow(
+        /raw error text/
+      );
+    });
+  });
+
+  describe("request() — empty body handling", () => {
+    it("returns undefined for 204 No Content without calling res.json()", async () => {
+      const mock = createMockResponse({ status: 204 });
+      // ok defaults true but 204 has no body
+      fetchMock.mockResolvedValue({ ...mock, ok: true, status: 204 });
+
+      const result = await client.unfollowTrader("0xabc");
+      expect(result).toBeUndefined();
+      expect(mock.json).not.toHaveBeenCalled();
+    });
+
+    it("returns undefined when Content-Length is 0", async () => {
+      const mock = createMockResponse({ contentLength: "0" });
+      fetchMock.mockResolvedValue(mock);
+
+      const result = await client.pauseTrader("0xabc");
+      expect(result).toBeUndefined();
+      expect(mock.json).not.toHaveBeenCalled();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // buildQuery (tested via endpoint methods)
+  // -------------------------------------------------------------------------
+
+  describe("buildQuery", () => {
+    it("appends query string for defined values", async () => {
+      fetchMock.mockResolvedValue(createMockResponse({ body: [] }));
+      await client.getPortfolioHistory({ limit: 10, cursor: "abc" });
+
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toContain("limit=10");
+      expect(url).toContain("cursor=abc");
+    });
+
+    it("omits undefined values from query string", async () => {
+      fetchMock.mockResolvedValue(createMockResponse({ body: [] }));
+      await client.getPortfolioHistory({ limit: 5 });
+
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toContain("limit=5");
+      expect(url).not.toContain("cursor");
+      expect(url).not.toContain("since");
+      expect(url).not.toContain("until");
+    });
+
+    it("omits query string entirely when params are all undefined", async () => {
+      fetchMock.mockResolvedValue(createMockResponse({ body: [] }));
+      await client.getPositions({});
+
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toBe(`${BASE}/api/v1/portfolio/positions`);
+      expect(url).not.toContain("?");
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Endpoint methods — method + path
+  // -------------------------------------------------------------------------
+
+  describe("endpoint methods", () => {
+    beforeEach(() => {
+      fetchMock.mockResolvedValue(createMockResponse({ body: {} }));
+    });
+
+    it("getPortfolio() → GET /api/v1/portfolio", async () => {
+      await client.getPortfolio();
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/portfolio`);
+      expect(init.method).toBe("GET");
+    });
+
+    it("getPortfolioHistory({limit:10, cursor:'abc'}) → GET /api/v1/portfolio/history?limit=10&cursor=abc", async () => {
+      await client.getPortfolioHistory({ limit: 10, cursor: "abc" });
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(
+        `${BASE}/api/v1/portfolio/history?limit=10&cursor=abc`
+      );
+      expect(init.method).toBe("GET");
+    });
+
+    it("getPositions() → GET /api/v1/portfolio/positions", async () => {
+      await client.getPositions();
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/portfolio/positions`);
+      expect(init.method).toBe("GET");
+    });
+
+    it("getTraders() → GET /api/v1/traders", async () => {
+      await client.getTraders();
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/traders`);
+      expect(init.method).toBe("GET");
+    });
+
+    it("followTrader({...}) → POST /api/v1/traders with body", async () => {
+      const body = {
+        walletAddress: "0xabc",
+        copyPercentage: 50,
+        maxCopyAmount: 100,
+        notificationsEnabled: true,
+      };
+      await client.followTrader(body);
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/traders`);
+      expect(init.method).toBe("POST");
+      expect(JSON.parse(init.body as string)).toEqual(body);
+    });
+
+    it("getTrader('0xabc') → GET /api/v1/traders/0xabc", async () => {
+      await client.getTrader("0xabc");
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/traders/0xabc`);
+      expect(init.method).toBe("GET");
+    });
+
+    it("updateTrader('0xabc', {...}) → PATCH /api/v1/traders/0xabc with body", async () => {
+      const body = { copyPercentage: 75, copyTradingEnabled: false };
+      await client.updateTrader("0xabc", body);
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/traders/0xabc`);
+      expect(init.method).toBe("PATCH");
+      expect(JSON.parse(init.body as string)).toEqual(body);
+    });
+
+    it("unfollowTrader('0xabc') → DELETE /api/v1/traders/0xabc", async () => {
+      fetchMock.mockResolvedValue(createMockResponse({ status: 204, ok: true }));
+      await client.unfollowTrader("0xabc");
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/traders/0xabc`);
+      expect(init.method).toBe("DELETE");
+    });
+
+    it("pauseTrader('0xabc') → POST /api/v1/traders/0xabc/pause", async () => {
+      await client.pauseTrader("0xabc");
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/traders/0xabc/pause`);
+      expect(init.method).toBe("POST");
+    });
+
+    it("resumeTrader('0xabc') → POST /api/v1/traders/0xabc/resume", async () => {
+      await client.resumeTrader("0xabc");
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/traders/0xabc/resume`);
+      expect(init.method).toBe("POST");
+    });
+
+    it("getOrders({status:'filled'}) → GET /api/v1/orders?status=filled", async () => {
+      await client.getOrders({ status: "filled" });
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/orders?status=filled`);
+      expect(init.method).toBe("GET");
+    });
+
+    it("getOrder('id123') → GET /api/v1/orders/id123", async () => {
+      await client.getOrder("id123");
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/orders/id123`);
+      expect(init.method).toBe("GET");
+    });
+
+    it("getAccount() → GET /api/v1/account", async () => {
+      await client.getAccount();
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/account`);
+      expect(init.method).toBe("GET");
+    });
+
+    it("health() → GET /api/v1/health", async () => {
+      await client.health();
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toBe(`${BASE}/api/v1/health`);
+      expect(init.method).toBe("GET");
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // URL encoding
+  // -------------------------------------------------------------------------
+
+  describe("URL encoding", () => {
+    beforeEach(() => {
+      fetchMock.mockResolvedValue(createMockResponse({ body: {} }));
+    });
+
+    it("encodes wallet addresses with special characters in path", async () => {
+      const wallet = "0xabc/def?foo=bar&baz=qux";
+      await client.getTrader(wallet);
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toContain(encodeURIComponent(wallet));
+      expect(url).not.toContain("?foo=bar");
+    });
+
+    it("encodes order IDs with special characters", async () => {
+      const id = "order/id?test=1";
+      await client.getOrder(id);
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toContain(encodeURIComponent(id));
+    });
+
+    it("encodes wallet addresses for updateTrader", async () => {
+      const wallet = "0xabc def";
+      await client.updateTrader(wallet, { copyPercentage: 10 });
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toContain(encodeURIComponent(wallet));
+      expect(url).toBe(`${BASE}/api/v1/traders/${encodeURIComponent(wallet)}`);
+    });
+
+    it("encodes wallet addresses for unfollowTrader", async () => {
+      const wallet = "0xabc def";
+      fetchMock.mockResolvedValue(createMockResponse({ status: 204, ok: true }));
+      await client.unfollowTrader(wallet);
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toBe(`${BASE}/api/v1/traders/${encodeURIComponent(wallet)}`);
+    });
+
+    it("encodes wallet addresses for pauseTrader", async () => {
+      const wallet = "0xabc def";
+      await client.pauseTrader(wallet);
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toBe(
+        `${BASE}/api/v1/traders/${encodeURIComponent(wallet)}/pause`
+      );
+    });
+
+    it("encodes wallet addresses for resumeTrader", async () => {
+      const wallet = "0xabc def";
+      await client.resumeTrader(wallet);
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toBe(
+        `${BASE}/api/v1/traders/${encodeURIComponent(wallet)}/resume`
+      );
+    });
+
+    it("encodes query string values correctly", async () => {
+      await client.getPortfolioHistory({ cursor: "abc=def&ghi" });
+      const [url] = fetchMock.mock.calls[0] as [string];
+      expect(url).toContain("cursor=abc%3Ddef%26ghi");
+    });
+  });
+});

package/src/__tests__/resources.test.ts

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CarbonCopyClient } from "../client.js";
+import { registerPortfolioResources } from "../resources/portfolio.js";
+import { registerTraderResources } from "../resources/traders.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+type RegisteredResource = {
+  name: string;
+  title?: string;
+  metadata?: {
+    title?: string;
+    description?: string;
+    mimeType?: string;
+  };
+  readCallback: (uri: URL, extra: unknown) => Promise<unknown>;
+  enabled: boolean;
+};
+
+type ServerInternals = {
+  _registeredResources: Record<string, RegisteredResource>;
+};
+
+function getResources(server: McpServer) {
+  return (server as unknown as ServerInternals)._registeredResources;
+}
+
+function createMockFetchResponse(body: unknown = {}) {
+  return {
+    ok: true,
+    status: 200,
+    statusText: "OK",
+    headers: { get: () => null },
+    json: vi.fn().mockResolvedValue(body),
+    text: vi.fn().mockResolvedValue(JSON.stringify(body)),
+    clone: vi.fn().mockReturnValue({ json: vi.fn().mockResolvedValue(body) }),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Resource Registration", () => {
+  let server: McpServer;
+  let client: CarbonCopyClient;
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    fetchMock = vi.fn();
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    server = new McpServer({ name: "test", version: "0.0.1" });
+    client = new CarbonCopyClient("cc_test");
+
+    registerPortfolioResources(server, client);
+    registerTraderResources(server, client);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // -------------------------------------------------------------------------
+  // Registration checks
+  // -------------------------------------------------------------------------
+
+  it("registers exactly 2 resources", () => {
+    const resources = getResources(server);
+    expect(Object.keys(resources)).toHaveLength(2);
+  });
+
+  it("registers the portfolio resource at carboncopy://portfolio", () => {
+    const resources = getResources(server);
+    expect(resources).toHaveProperty("carboncopy://portfolio");
+  });
+
+  it("registers the traders resource at carboncopy://traders", () => {
+    const resources = getResources(server);
+    expect(resources).toHaveProperty("carboncopy://traders");
+  });
+
+  it("portfolio resource has name 'portfolio'", () => {
+    const resources = getResources(server);
+    expect(resources["carboncopy://portfolio"].name).toBe("portfolio");
+  });
+
+  it("traders resource has name 'traders'", () => {
+    const resources = getResources(server);
+    expect(resources["carboncopy://traders"].name).toBe("traders");
+  });
+
+  it("portfolio resource has mimeType application/json", () => {
+    const resources = getResources(server);
+    const resource = resources["carboncopy://portfolio"];
+    expect(resource.metadata?.mimeType).toBe("application/json");
+  });
+
+  it("traders resource has mimeType application/json", () => {
+    const resources = getResources(server);
+    const resource = resources["carboncopy://traders"];
+    expect(resource.metadata?.mimeType).toBe("application/json");
+  });
+
+  it("all resources are enabled by default", () => {
+    const resources = getResources(server);
+    for (const resource of Object.values(resources)) {
+      expect(resource.enabled).toBe(true);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // Portfolio resource — readCallback
+  // -------------------------------------------------------------------------
+
+  describe("portfolio resource — read", () => {
+    it("returns a content block with URI carboncopy://portfolio", async () => {
+      const portfolioData = { totalValue: 1234.56, pnl: 123.45 };
+      fetchMock.mockResolvedValue(createMockFetchResponse(portfolioData));
+
+      const resource = getResources(server)["carboncopy://portfolio"];
+      const uri = new URL("carboncopy://portfolio");
+      const result = (await resource.readCallback(uri, {})) as {
+        contents: { uri: string; mimeType: string; text: string }[];
+      };
+
+      expect(result.contents).toHaveLength(1);
+      expect(result.contents[0].uri).toBe("carboncopy://portfolio");
+    });
+
+    it("returns application/json mimeType in content", async () => {
+      fetchMock.mockResolvedValue(createMockFetchResponse({ v: 1 }));
+
+      const resource = getResources(server)["carboncopy://portfolio"];
+      const result = (await resource.readCallback(
+        new URL("carboncopy://portfolio"),
+        {}
+      )) as { contents: { uri: string; mimeType: string; text: string }[] };
+
+      expect(result.contents[0].mimeType).toBe("application/json");
+    });
+
+    it("returns JSON-stringified portfolio data as text", async () => {
+      const portfolioData = { totalValue: 500, positions: [] };
+      fetchMock.mockResolvedValue(createMockFetchResponse(portfolioData));
+
+      const resource = getResources(server)["carboncopy://portfolio"];
+      const result = (await resource.readCallback(
+        new URL("carboncopy://portfolio"),
+        {}
+      )) as { contents: { uri: string; mimeType: string; text: string }[] };
+
+      expect(JSON.parse(result.contents[0].text)).toEqual(portfolioData);
+    });
+
+    it("calls GET /api/v1/portfolio when portfolio resource is read", async () => {
+      fetchMock.mockResolvedValue(createMockFetchResponse({}));
+
+      const resource = getResources(server)["carboncopy://portfolio"];
+      await resource.readCallback(new URL("carboncopy://portfolio"), {});
+
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain("/api/v1/portfolio");
+      expect(init.method).toBe("GET");
+    });
+
+    it("propagates API errors from the portfolio resource read", async () => {
+      fetchMock.mockResolvedValue({
+        ok: false,
+        status: 401,
+        statusText: "Unauthorized",
+        headers: { get: () => null },
+        clone: vi.fn().mockReturnValue({
+          json: vi.fn().mockResolvedValue({ message: "unauthorized" }),
+        }),
+      });
+
+      const resource = getResources(server)["carboncopy://portfolio"];
+      await expect(
+        resource.readCallback(new URL("carboncopy://portfolio"), {})
+      ).rejects.toThrow(/Carbon Copy API error 401/);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Traders resource — readCallback
+  // -------------------------------------------------------------------------
+
+  describe("traders resource — read", () => {
+    it("returns a content block with URI carboncopy://traders", async () => {
+      const tradersData = [{ wallet: "0xabc", copyPercentage: 50 }];
+      fetchMock.mockResolvedValue(createMockFetchResponse(tradersData));
+
+      const resource = getResources(server)["carboncopy://traders"];
+      const result = (await resource.readCallback(
+        new URL("carboncopy://traders"),
+        {}
+      )) as { contents: { uri: string; mimeType: string; text: string }[] };
+
+      expect(result.contents).toHaveLength(1);
+      expect(result.contents[0].uri).toBe("carboncopy://traders");
+    });
+
+    it("returns application/json mimeType in content", async () => {
+      fetchMock.mockResolvedValue(createMockFetchResponse([]));
+
+      const resource = getResources(server)["carboncopy://traders"];
+      const result = (await resource.readCallback(
+        new URL("carboncopy://traders"),
+        {}
+      )) as { contents: { uri: string; mimeType: string; text: string }[] };
+
+      expect(result.contents[0].mimeType).toBe("application/json");
+    });
+
+    it("returns JSON-stringified traders list as text", async () => {
+      const tradersData = [
+        { wallet: "0xabc", copyPercentage: 50 },
+        { wallet: "0xdef", copyPercentage: 25 },
+      ];
+      fetchMock.mockResolvedValue(createMockFetchResponse(tradersData));
+
+      const resource = getResources(server)["carboncopy://traders"];
+      const result = (await resource.readCallback(
+        new URL("carboncopy://traders"),
+        {}
+      )) as { contents: { uri: string; mimeType: string; text: string }[] };
+
+      expect(JSON.parse(result.contents[0].text)).toEqual(tradersData);
+    });
+
+    it("calls GET /api/v1/traders when traders resource is read", async () => {
+      fetchMock.mockResolvedValue(createMockFetchResponse([]));
+
+      const resource = getResources(server)["carboncopy://traders"];
+      await resource.readCallback(new URL("carboncopy://traders"), {});
+
+      const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+      expect(url).toContain("/api/v1/traders");
+      expect(init.method).toBe("GET");
+    });
+
+    it("propagates API errors from the traders resource read", async () => {
+      fetchMock.mockResolvedValue({
+        ok: false,
+        status: 403,
+        statusText: "Forbidden",
+        headers: { get: () => null },
+        clone: vi.fn().mockReturnValue({
+          json: vi.fn().mockResolvedValue({ message: "forbidden" }),
+        }),
+      });
+
+      const resource = getResources(server)["carboncopy://traders"];
+      await expect(
+        resource.readCallback(new URL("carboncopy://traders"), {})
+      ).rejects.toThrow(/Carbon Copy API error 403/);
+    });
+  });
+});