@copilotkit/runtime 1.57.3 → 1.58.0-canary.thread-id-propagation

package/src/v2/runtime/__tests__/mcp-apps-middleware-integration.test.ts

@@ -1,275 +0,0 @@
-import { describe, it, expect, afterEach, vi } from "vitest";
-import {
-  AbstractAgent,
-  RunAgentInput,
-  BaseEvent,
-  EventType,
-} from "@ag-ui/client";
-import { Observable } from "rxjs";
-import { LLMock, MCPMock } from "@copilotkit/aimock";
-import { MCPAppsMiddleware, getServerHash } from "@ag-ui/mcp-apps-middleware";
-
-/**
- * A minimal next-agent that emits RUN_STARTED and RUN_FINISHED.
- * Used as the downstream agent when the middleware should NOT delegate.
- */
-class MockNextAgent extends AbstractAgent {
-  run(input: RunAgentInput): Observable<BaseEvent> {
-    return new Observable((subscriber) => {
-      subscriber.next({
-        type: EventType.RUN_STARTED,
-        threadId: input.threadId,
-        runId: input.runId,
-      } as BaseEvent);
-      subscriber.next({
-        type: EventType.RUN_FINISHED,
-        threadId: input.threadId,
-        runId: input.runId,
-      } as BaseEvent);
-      subscriber.complete();
-    });
-  }
-
-  clone(): AbstractAgent {
-    return new MockNextAgent();
-  }
-
-  protected connect(): ReturnType<AbstractAgent["connect"]> {
-    throw new Error("not used");
-  }
-}
-
-function createRunInput(overrides: Partial<RunAgentInput> = {}): RunAgentInput {
-  return {
-    threadId: "thread-1",
-    runId: "run-1",
-    state: {},
-    messages: [],
-    tools: [],
-    context: [],
-    forwardedProps: undefined,
-    ...overrides,
-  };
-}
-
-async function collectEvents(
-  observable: Observable<BaseEvent>,
-): Promise<BaseEvent[]> {
-  const events: BaseEvent[] = [];
-  await new Promise<void>((resolve, reject) => {
-    observable.subscribe({
-      next: (event) => events.push(event),
-      error: reject,
-      complete: resolve,
-    });
-  });
-  return events;
-}
-
-describe("MCPAppsMiddleware integration", () => {
-  let llm: LLMock;
-  let mcpMock: MCPMock;
-
-  afterEach(async () => {
-    if (llm) {
-      await llm.stop().catch(() => {});
-    }
-  });
-
-  async function startMcpServer(): Promise<string> {
-    mcpMock = new MCPMock();
-    mcpMock.addTool({
-      name: "get_weather",
-      description: "Get the weather",
-      inputSchema: {
-        type: "object",
-        properties: { city: { type: "string" } },
-      },
-    });
-    mcpMock.onToolCall("get_weather", (args: unknown) => {
-      const parsed = args as { city?: string };
-      return `Weather in ${parsed.city || "unknown"}: sunny`;
-    });
-    mcpMock.addResource(
-      {
-        uri: "app://dashboard",
-        name: "Dashboard",
-        mimeType: "text/plain",
-      },
-      { text: "Dashboard content here" },
-    );
-
-    llm = new LLMock({ port: 0 });
-    llm.mount("/mcp", mcpMock);
-    await llm.start();
-    return `${llm.url}/mcp`;
-  }
-
-  it("can be created with mcpServers config pointing at MCPMock URL", async () => {
-    const mcpUrl = await startMcpServer();
-
-    const middleware = new MCPAppsMiddleware({
-      mcpServers: [{ type: "http", url: mcpUrl }],
-    });
-
-    expect(middleware).toBeInstanceOf(MCPAppsMiddleware);
-  });
-
-  it("proxies tools/call through to MCPMock and returns results", async () => {
-    const mcpUrl = await startMcpServer();
-
-    const serverConfig = { type: "http" as const, url: mcpUrl };
-    const serverHash = getServerHash(serverConfig);
-
-    const middleware = new MCPAppsMiddleware({
-      mcpServers: [serverConfig],
-    });
-
-    const input = createRunInput({
-      forwardedProps: {
-        __proxiedMCPRequest: {
-          serverHash,
-          method: "tools/call",
-          params: {
-            name: "get_weather",
-            arguments: { city: "NYC" },
-          },
-        },
-      },
-    });
-
-    const mockAgent = new MockNextAgent();
-    const events = await collectEvents(middleware.run(input, mockAgent));
-
-    // Should have RUN_STARTED and RUN_FINISHED
-    const types = events.map((e) => e.type);
-    expect(types).toContain(EventType.RUN_STARTED);
-    expect(types).toContain(EventType.RUN_FINISHED);
-
-    // RUN_FINISHED should contain the MCP tool result
-    const runFinished = events.find(
-      (e) => e.type === EventType.RUN_FINISHED,
-    ) as BaseEvent & { result?: unknown };
-    expect(runFinished).toBeDefined();
-    expect(runFinished.result).toBeDefined();
-
-    // The result should contain the tool's text content
-    const result = runFinished.result as { content?: unknown[] };
-    expect(result.content).toBeDefined();
-    expect(Array.isArray(result.content)).toBe(true);
-
-    const textContent = (
-      result.content as Array<{ type: string; text?: string }>
-    ).find((c) => c.type === "text");
-    expect(textContent).toBeDefined();
-    expect(textContent!.text).toContain("sunny");
-  });
-
-  it("non-proxied request delegates to next agent", async () => {
-    const mcpUrl = await startMcpServer();
-
-    const middleware = new MCPAppsMiddleware({
-      mcpServers: [{ type: "http", url: mcpUrl }],
-    });
-
-    // Input WITHOUT __proxiedMCPRequest — should delegate to MockNextAgent
-    const input = createRunInput();
-
-    const mockAgent = new MockNextAgent();
-
-    const events = await collectEvents(middleware.run(input, mockAgent));
-
-    // MockNextAgent's run should have been called (delegation happened)
-    // The middleware calls runNextWithState which internally calls next.run,
-    // but since processStream wraps it, we check the output events instead
-    const types = events.map((e) => e.type);
-    expect(types).toContain(EventType.RUN_STARTED);
-    expect(types).toContain(EventType.RUN_FINISHED);
-  });
-
-  it("wrong serverHash returns error in RUN_FINISHED result", async () => {
-    const mcpUrl = await startMcpServer();
-
-    const middleware = new MCPAppsMiddleware({
-      mcpServers: [{ type: "http", url: mcpUrl }],
-    });
-
-    const input = createRunInput({
-      forwardedProps: {
-        __proxiedMCPRequest: {
-          serverHash: "nonexistent-hash-value",
-          method: "tools/call",
-          params: {
-            name: "get_weather",
-            arguments: { city: "NYC" },
-          },
-        },
-      },
-    });
-
-    const mockAgent = new MockNextAgent();
-    const events = await collectEvents(middleware.run(input, mockAgent));
-
-    // Should still get RUN_STARTED and RUN_FINISHED
-    const types = events.map((e) => e.type);
-    expect(types).toContain(EventType.RUN_STARTED);
-    expect(types).toContain(EventType.RUN_FINISHED);
-
-    // RUN_FINISHED should contain an error about unknown server
-    const runFinished = events.find(
-      (e) => e.type === EventType.RUN_FINISHED,
-    ) as BaseEvent & { result?: unknown };
-    expect(runFinished).toBeDefined();
-    const result = runFinished.result as { error?: string };
-    expect(result.error).toBeDefined();
-    expect(result.error).toContain("nonexistent-hash-value");
-  });
-
-  it("proxies resources/read through to MCPMock and returns results", async () => {
-    const mcpUrl = await startMcpServer();
-
-    const serverConfig = { type: "http" as const, url: mcpUrl };
-    const serverHash = getServerHash(serverConfig);
-
-    const middleware = new MCPAppsMiddleware({
-      mcpServers: [serverConfig],
-    });
-
-    const input = createRunInput({
-      forwardedProps: {
-        __proxiedMCPRequest: {
-          serverHash,
-          method: "resources/read",
-          params: { uri: "app://dashboard" },
-        },
-      },
-    });
-
-    const mockAgent = new MockNextAgent();
-    const events = await collectEvents(middleware.run(input, mockAgent));
-
-    // Should have RUN_STARTED and RUN_FINISHED
-    const types = events.map((e) => e.type);
-    expect(types).toContain(EventType.RUN_STARTED);
-    expect(types).toContain(EventType.RUN_FINISHED);
-
-    // RUN_FINISHED should contain the resource content
-    const runFinished = events.find(
-      (e) => e.type === EventType.RUN_FINISHED,
-    ) as BaseEvent & { result?: unknown };
-    expect(runFinished).toBeDefined();
-    expect(runFinished.result).toBeDefined();
-
-    // The result should contain resource contents
-    const result = runFinished.result as { contents?: unknown[] };
-    expect(result.contents).toBeDefined();
-    expect(Array.isArray(result.contents)).toBe(true);
-
-    const resource = (
-      result.contents as Array<{ uri: string; text?: string }>
-    )[0];
-    expect(resource).toBeDefined();
-    expect(resource.uri).toBe("app://dashboard");
-    expect(resource.text).toContain("Dashboard content here");
-  });
-});

package/src/v2/runtime/__tests__/middleware-express.test.ts

@@ -1,208 +0,0 @@
-import express from "express";
-import request from "supertest";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-import { createCopilotEndpointExpress } from "../express";
-import { CopilotRuntime } from "../core/runtime";
-import { logger } from "@copilotkit/shared";
-
-const dummyRuntime = (opts: Partial<CopilotRuntime> = {}) => {
-  const runtime = new CopilotRuntime({
-    agents: { agent: {} as unknown as AbstractAgent },
-    ...opts,
-  });
-  return runtime;
-};
-
-describe("CopilotEndpointExpress middleware", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  const buildApp = (runtime: CopilotRuntime) => {
-    const app = express();
-    app.use(createCopilotEndpointExpress({ runtime, basePath: "/" }));
-    return app;
-  };
-
-  it("processes request through middleware and handler", async () => {
-    const modifiedRequest = new Request("https://example.com/info", {
-      headers: { "x-modified": "yes" },
-    });
-
-    const before = vi.fn().mockResolvedValue(modifiedRequest);
-    const after = vi.fn().mockResolvedValue(undefined);
-
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-
-    const app = buildApp(runtime);
-    const response = await request(app).get("/info");
-
-    expect(before).toHaveBeenCalledWith({
-      runtime,
-      request: expect.any(Request),
-      path: "/info",
-    });
-
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalledWith(
-        expect.objectContaining({
-          runtime,
-          response: expect.any(Response),
-          path: "/info",
-        }),
-      );
-    });
-
-    expect(response.status).toBe(200);
-    expect(response.body).toHaveProperty("version");
-  });
-
-  it("returns Response from before middleware", async () => {
-    const errorResponse = new Response("Error", { status: 400 });
-    const before = vi.fn().mockRejectedValue(errorResponse);
-    const after = vi.fn();
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await request(app).get("/info");
-
-    expect(response.status).toBe(400);
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: errorResponse,
-        url: expect.stringContaining("/info"),
-        path: "/info",
-      }),
-      "Error running before request middleware",
-    );
-    expect(after).not.toHaveBeenCalled();
-  });
-
-  it("logs and returns 500 when before middleware throws", async () => {
-    const error = new Error("before");
-    const before = vi.fn().mockRejectedValue(error);
-    const after = vi.fn();
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await request(app).get("/info");
-
-    expect(response.status).toBe(500);
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: error,
-        url: expect.stringContaining("/info"),
-        path: "/info",
-      }),
-      "Error running before request middleware",
-    );
-    expect(after).not.toHaveBeenCalled();
-  });
-
-  it("logs handler error", async () => {
-    const before = vi.fn();
-    const after = vi.fn();
-    const errorAgent = {
-      clone: () => {
-        throw new Error("Agent error");
-      },
-    } as unknown as AbstractAgent;
-
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-      agents: { agent: errorAgent },
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await request(app)
-      .post("/agent/agent/run")
-      .set("Content-Type", "application/json")
-      .send({});
-
-    expect(response.status).toBe(500);
-    expect(logSpy).toHaveBeenCalled();
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalled();
-    });
-  });
-
-  it("passes parsed messages to afterRequestMiddleware", async () => {
-    let receivedParams: Record<string, unknown> = {};
-    const after = vi.fn().mockImplementation((params) => {
-      receivedParams = params;
-    });
-
-    const runtime = dummyRuntime({
-      afterRequestMiddleware: after,
-    });
-
-    const app = buildApp(runtime);
-    const response = await request(app).get("/info");
-
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalled();
-    });
-
-    expect(response.status).toBe(200);
-    expect(receivedParams).toHaveProperty("messages");
-    expect(receivedParams.messages).toEqual([]);
-  });
-
-  it("logs error from after middleware", async () => {
-    const error = new Error("after");
-    const before = vi.fn();
-    const after = vi.fn().mockRejectedValue(error);
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await request(app).get("/info");
-
-    expect(response.status).toBe(200);
-
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalledWith(
-        expect.objectContaining({
-          runtime,
-          response: expect.any(Response),
-          path: "/info",
-        }),
-      );
-    });
-
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: error,
-        url: expect.stringContaining("/info"),
-        path: "/info",
-      }),
-      "Error running after request middleware",
-    );
-  });
-});

package/src/v2/runtime/__tests__/middleware-single-express.test.ts

@@ -1,213 +0,0 @@
-import express from "express";
-import request from "supertest";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-import { createCopilotEndpointSingleRouteExpress } from "../express";
-import { CopilotRuntime } from "../core/runtime";
-import { logger } from "@copilotkit/shared";
-
-const dummyRuntime = (opts: Partial<CopilotRuntime> = {}) => {
-  const runtime = new CopilotRuntime({
-    agents: { agent: {} as unknown as AbstractAgent },
-    ...opts,
-  });
-  return runtime;
-};
-
-describe("CopilotEndpointSingleRouteExpress middleware", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  const buildApp = (runtime: CopilotRuntime) => {
-    const app = express();
-    app.use(
-      createCopilotEndpointSingleRouteExpress({ runtime, basePath: "/rpc" }),
-    );
-    return app;
-  };
-
-  const rpcRequest = (app: express.Express, body: Record<string, unknown>) =>
-    request(app)
-      .post("/rpc")
-      .set("Content-Type", "application/json")
-      .send(body);
-
-  it("processes middleware and handler", async () => {
-    const before = vi.fn().mockResolvedValue(undefined);
-    const after = vi.fn().mockResolvedValue(undefined);
-
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-
-    const app = buildApp(runtime);
-    const response = await rpcRequest(app, { method: "info" });
-
-    expect(before).toHaveBeenCalledWith({
-      runtime,
-      request: expect.any(Request),
-      path: "/rpc",
-    });
-
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalledWith(
-        expect.objectContaining({
-          runtime,
-          response: expect.any(Response),
-          path: "/rpc",
-        }),
-      );
-    });
-
-    expect(response.status).toBe(200);
-    expect(response.body).toHaveProperty("version");
-  });
-
-  it("handles Response error from before middleware", async () => {
-    const errorResponse = new Response("Error", { status: 400 });
-    const before = vi.fn().mockRejectedValue(errorResponse);
-    const after = vi.fn();
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await rpcRequest(app, { method: "info" });
-
-    expect(response.status).toBe(400);
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: errorResponse,
-        url: expect.stringContaining("/rpc"),
-        path: "/rpc",
-      }),
-      "Error running before request middleware",
-    );
-    expect(after).not.toHaveBeenCalled();
-  });
-
-  it("logs thrown error from before middleware", async () => {
-    const error = new Error("before");
-    const before = vi.fn().mockRejectedValue(error);
-    const after = vi.fn();
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await rpcRequest(app, { method: "info" });
-
-    expect(response.status).toBe(500);
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: error,
-        url: expect.stringContaining("/rpc"),
-        path: "/rpc",
-      }),
-      "Error running before request middleware",
-    );
-    expect(after).not.toHaveBeenCalled();
-  });
-
-  it("logs handler error", async () => {
-    const before = vi.fn();
-    const after = vi.fn();
-    const errorAgent = {
-      clone: () => {
-        throw new Error("Agent error");
-      },
-    } as unknown as AbstractAgent;
-
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-      agents: { agent: errorAgent },
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await rpcRequest(app, {
-      method: "agent/run",
-      params: { agentId: "agent" },
-      body: {},
-    });
-
-    expect(response.status).toBe(500);
-    expect(logSpy).toHaveBeenCalled();
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalled();
-    });
-  });
-
-  it("passes parsed messages to afterRequestMiddleware", async () => {
-    let receivedParams: Record<string, unknown> = {};
-    const after = vi.fn().mockImplementation((params) => {
-      receivedParams = params;
-    });
-
-    const runtime = dummyRuntime({
-      afterRequestMiddleware: after,
-    });
-
-    const app = buildApp(runtime);
-    const response = await rpcRequest(app, { method: "info" });
-
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalled();
-    });
-
-    expect(response.status).toBe(200);
-    expect(receivedParams).toHaveProperty("messages");
-    expect(receivedParams.messages).toEqual([]);
-  });
-
-  it("logs errors from after middleware", async () => {
-    const error = new Error("after");
-    const before = vi.fn();
-    const after = vi.fn().mockRejectedValue(error);
-    const runtime = dummyRuntime({
-      beforeRequestMiddleware: before,
-      afterRequestMiddleware: after,
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      .mockImplementation(() => undefined as unknown as void);
-
-    const app = buildApp(runtime);
-    const response = await rpcRequest(app, { method: "info" });
-
-    expect(response.status).toBe(200);
-
-    await vi.waitFor(() => {
-      expect(after).toHaveBeenCalledWith(
-        expect.objectContaining({
-          runtime,
-          response: expect.any(Response),
-          path: "/rpc",
-        }),
-      );
-    });
-
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: error,
-        url: expect.stringContaining("/rpc"),
-        path: "/rpc",
-      }),
-      "Error running after request middleware",
-    );
-  });
-});