@copilotkit/runtime 1.56.4-canary.1777538870 → 1.56.5

package/src/agent/mcp-transport.ts

@@ -1,190 +0,0 @@
-import type { RunAgentInput } from "@ag-ui/client";
-import type { JSONRPCMessage, MCPTransport } from "@ai-sdk/mcp";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type { StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
-
-/**
- * The end-user identity resolved by the runtime's `identifyUser` callback for
- * the current request. Surfaced on {@link MCPRequestContext} so MCP header
- * resolvers can read it without re-doing auth work.
- */
-export interface MCPRuntimeUser {
-  id: string;
-  name: string;
-}
-
-/**
- * Context handed to {@link MCPClientConfigHTTP.getHeaders} on every outbound
- * MCP HTTP request. The resolver is invoked fresh per request — initialize,
- * tools/list, tools/call, and reconnects — so values it depends on are never
- * cached across calls.
- */
-export interface MCPRequestContext {
-  /**
-   * Headers forwarded onto the agent for this run. Populated by the runtime's
-   * `extractForwardableHeaders` (`authorization` + every `x-*` header from the
-   * incoming HTTP request). Keys are lower-cased.
-   */
-  requestHeaders: Record<string, string>;
-  /** The {@link RunAgentInput} the agent is currently running. */
-  input: RunAgentInput;
-  /** URL of the MCP server this request is going to. */
-  mcpServerUrl: string;
-  /**
-   * The end-user identity for this run, resolved by the runtime's
-   * `identifyUser` callback (only populated when the agent is run via a
-   * `CopilotRuntime` configured with `identifyUser`). Snapshotted at
-   * run-start.
-   */
-  user?: MCPRuntimeUser;
-}
-
-/**
- * Thrown when an MCP {@link MCPClientConfigHTTP.getHeaders} resolver throws.
- * Wraps the underlying error so `RUN_ERROR` carries clear attribution instead
- * of a generic transport failure. The original error is preserved on the
- * standard ES2022 `Error.cause` chain.
- */
-export class MCPHeaderResolverError extends Error {
-  constructor(message: string, cause: unknown) {
-    super(message, { cause });
-    this.name = "MCPHeaderResolverError";
-  }
-}
-
-export interface CopilotKitMCPTransportOptions {
-  /** URL of the MCP server. */
-  url: string;
-  /** Static HTTP headers, merged into every outbound request. */
-  headers?: Record<string, string>;
-  /**
-   * Per-call header resolver. Invoked on **every** outbound HTTP request to
-   * this server (initialize, tools/list, tools/call, reconnects). Returned
-   * headers are merged on top of `headers`, so a resolver can override either.
-   */
-  getHeaders?: (
-    ctx: MCPRequestContext,
-  ) => Record<string, string> | Promise<Record<string, string>>;
-  /**
-   * Pre-existing escape hatch: low-level options for the underlying
-   * `StreamableHTTPClientTransport`. Forwarded as-is, except `fetch` is
-   * wrapped so static `headers` and `getHeaders` resolution still apply.
-   */
-  options?: StreamableHTTPClientTransportOptions;
-  /** Snapshot of the agent's per-run forwarded headers, captured at run-start. */
-  requestHeaders: Record<string, string>;
-  /** RunAgentInput for the current run, exposed to the resolver via context. */
-  input: RunAgentInput;
-  /** Per-run end-user identity from the runtime's `identifyUser`, if set. */
-  user?: MCPRuntimeUser;
-}
-
-/**
- * MCP transport for CopilotKit's BuiltInAgent that adds per-call header
- * resolution on top of the standard Streamable HTTP transport.
- *
- * Implements `@ai-sdk/mcp`'s {@link MCPTransport} interface so it can be
- * passed straight to `createMCPClient({ transport })`. Internally delegates
- * to `@modelcontextprotocol/sdk`'s `StreamableHTTPClientTransport` with a
- * wrapped `fetch` that runs the static-header + per-call resolver pipeline
- * before each outbound request.
- */
-export class CopilotKitMCPTransport implements MCPTransport {
-  private readonly inner: StreamableHTTPClientTransport;
-
-  constructor(options: CopilotKitMCPTransportOptions) {
-    const transportOptions: StreamableHTTPClientTransportOptions = {
-      ...options.options,
-      fetch: buildWrappedFetch(options),
-    };
-    this.inner = new StreamableHTTPClientTransport(
-      new URL(options.url),
-      transportOptions,
-    );
-  }
-
-  get onclose(): (() => void) | undefined {
-    return this.inner.onclose;
-  }
-  set onclose(handler: (() => void) | undefined) {
-    this.inner.onclose = handler;
-  }
-
-  get onerror(): ((error: Error) => void) | undefined {
-    return this.inner.onerror;
-  }
-  set onerror(handler: ((error: Error) => void) | undefined) {
-    this.inner.onerror = handler;
-  }
-
-  get onmessage(): ((message: JSONRPCMessage) => void) | undefined {
-    return this.inner.onmessage as
-      | ((message: JSONRPCMessage) => void)
-      | undefined;
-  }
-  set onmessage(handler: ((message: JSONRPCMessage) => void) | undefined) {
-    this.inner.onmessage = handler as
-      | ((message: JSONRPCMessage) => void)
-      | undefined;
-  }
-
-  start(): Promise<void> {
-    return this.inner.start();
-  }
-
-  send(message: JSONRPCMessage): Promise<void> {
-    return this.inner.send(message as Parameters<typeof this.inner.send>[0]);
-  }
-
-  close(): Promise<void> {
-    return this.inner.close();
-  }
-}
-
-function buildWrappedFetch(options: CopilotKitMCPTransportOptions): FetchLike {
-  const {
-    headers: staticHeaders,
-    getHeaders,
-    requestHeaders,
-    input,
-    url: mcpServerUrl,
-    user,
-    options: transportOptions,
-  } = options;
-  const baseFetch: FetchLike = transportOptions?.fetch ?? globalThis.fetch;
-
-  return async (fetchUrl, init) => {
-    // SDK passes a Headers instance via init.headers — start fresh from it so
-    // we don't mutate the SDK's object, then layer headers on top via .set()
-    // (last write wins).
-    const merged = new Headers(init?.headers);
-    if (staticHeaders) {
-      for (const [key, value] of Object.entries(staticHeaders)) {
-        merged.set(key, value);
-      }
-    }
-    if (getHeaders) {
-      let resolved: Record<string, string>;
-      try {
-        resolved = await getHeaders({
-          requestHeaders,
-          input,
-          mcpServerUrl,
-          user,
-        });
-      } catch (err) {
-        throw new MCPHeaderResolverError(
-          `MCP header resolver for ${mcpServerUrl} threw: ${
-            err instanceof Error ? err.message : String(err)
-          }`,
-          err,
-        );
-      }
-      for (const [key, value] of Object.entries(resolved)) {
-        merged.set(key, value);
-      }
-    }
-    return baseFetch(fetchUrl, { ...init, headers: merged });
-  };
-}

package/src/v2/runtime/intelligence-platform/__tests__/intelligence-mcp-helper.test.ts

@@ -1,188 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { CopilotKitIntelligence } from "../client";
-import { BasicAgent } from "../../../../agent";
-import { EventType } from "@ag-ui/client";
-import { LLMock, MCPMock } from "@copilotkit/aimock";
-import { streamText } from "ai";
-import {
-  mockStreamTextResponse,
-  textDelta,
-  finish,
-  collectEvents,
-} from "../../../../agent/__tests__/test-helpers";
-
-vi.mock("ai", () => ({
-  streamText: vi.fn(),
-  tool: vi.fn((config) => config),
-  stepCountIs: vi.fn((count: number) => ({ type: "stepCount", count })),
-}));
-
-vi.mock("@ai-sdk/openai", () => ({
-  createOpenAI: vi.fn(() => (modelId: string) => ({
-    modelId,
-    provider: "openai",
-  })),
-}));
-
-async function startMcpMock(): Promise<{ url: string; server: LLMock }> {
-  const mock = new MCPMock();
-  mock.addTool({
-    name: "bash",
-    description: "Run a bash command",
-    inputSchema: {
-      type: "object",
-      properties: { command: { type: "string" } },
-    },
-  });
-  mock.onToolCall("bash", () => "ok");
-  const server = new LLMock({ port: 0 });
-  server.mount("/mcp", mock);
-  await server.start();
-  return { url: server.url, server };
-}
-
-/**
- * aimock redacts `Authorization` to `[REDACTED]` in its journal. Spy on
- * `globalThis.fetch` to read unredacted headers off each outbound request to
- * `mcpUrl`. The spy delegates to the real fetch so the round-trip completes.
- */
-function spyOnFetch(mcpUrl: string): {
-  records: Array<Record<string, string>>;
-  restore: () => void;
-} {
-  const records: Array<Record<string, string>> = [];
-  const realFetch = globalThis.fetch;
-  const spy = vi
-    .spyOn(globalThis, "fetch")
-    .mockImplementation(async (input, init) => {
-      const url =
-        typeof input === "string"
-          ? input
-          : input instanceof URL
-            ? input.toString()
-            : input.url;
-      if (url.startsWith(mcpUrl)) {
-        const seen: Record<string, string> = {};
-        new Headers(init?.headers ?? {}).forEach((value, key) => {
-          seen[key.toLowerCase()] = value;
-        });
-        records.push(seen);
-      }
-      return realFetch(input, init);
-    });
-  return { records, restore: () => spy.mockRestore() };
-}
-
-describe("CopilotKitIntelligence.toMCPServer()", () => {
-  const baseInput = {
-    threadId: "thread1",
-    runId: "run1",
-    messages: [],
-    tools: [],
-    context: [],
-    state: {},
-  };
-
-  let llm: LLMock | undefined;
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env = { ...originalEnv };
-    process.env.OPENAI_API_KEY = "test-key";
-  });
-
-  afterEach(async () => {
-    process.env = originalEnv;
-    if (llm) {
-      await llm.stop().catch(() => {});
-      llm = undefined;
-    }
-  });
-
-  it("emits Authorization (Bearer apiKey) and X-Cpki-User-Id (resolved user) on every MCP request", async () => {
-    const { url, server } = await startMcpMock();
-    llm = server;
-
-    const intelligence = new CopilotKitIntelligence({
-      apiUrl: url,
-      wsUrl: "wss://unused.example.com/socket",
-      apiKey: "cpk-proj_short_long",
-    });
-
-    const recorder = spyOnFetch(url);
-    try {
-      const agent = new BasicAgent({
-        model: "openai/gpt-4o",
-        mcpServers: [intelligence.toMCPServer()],
-      });
-      // The runtime would normally populate this via `identifyUser` after
-      // resolveIntelligenceUser. Simulate the same outcome here.
-      agent.user = { id: "jordan-beamson", name: "Jordan Beamson" };
-
-      vi.mocked(streamText).mockReturnValue(
-        mockStreamTextResponse([textDelta("hi"), finish()]) as any,
-      );
-
-      await collectEvents(agent["run"](baseInput));
-
-      expect(recorder.records.length).toBeGreaterThan(0);
-      for (const headers of recorder.records) {
-        expect(headers["authorization"]).toBe("Bearer cpk-proj_short_long");
-        expect(headers["x-cpki-user-id"]).toBe("jordan-beamson");
-      }
-    } finally {
-      recorder.restore();
-    }
-  });
-
-  it("throws when no user has been resolved (runtime missing identifyUser)", async () => {
-    const { url, server } = await startMcpMock();
-    llm = server;
-
-    const intelligence = new CopilotKitIntelligence({
-      apiUrl: url,
-      wsUrl: "wss://unused.example.com/socket",
-      apiKey: "cpk-proj_short_long",
-    });
-
-    const agent = new BasicAgent({
-      model: "openai/gpt-4o",
-      mcpServers: [intelligence.toMCPServer()],
-    });
-    // Deliberately leave `agent.user` unset — this is the case the helper
-    // must reject loudly so a misconfigured runtime doesn't silently collapse
-    // every browser session into one shared bash sandbox.
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([finish()]) as any,
-    );
-
-    const events: any[] = [];
-    try {
-      await new Promise((resolve, reject) => {
-        agent["run"](baseInput).subscribe({
-          next: (event) => events.push(event),
-          error: (err) => reject(err),
-          complete: () => resolve(events),
-        });
-      });
-    } catch {
-      // expected
-    }
-
-    const runError = events.find((e: any) => e.type === EventType.RUN_ERROR);
-    expect(runError).toBeDefined();
-    expect(runError?.message).toContain("no user resolved");
-    expect(runError?.message).toContain("identifyUser");
-  });
-
-  it("URL is composed from apiUrl + /mcp (trailing slash on apiUrl is normalized)", () => {
-    const intelligence = new CopilotKitIntelligence({
-      apiUrl: "https://api.example.com/",
-      wsUrl: "wss://ws.example.com",
-      apiKey: "k",
-    });
-    expect(intelligence.toMCPServer().url).toBe("https://api.example.com/mcp");
-  });
-});