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

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

@@ -1,188 +0,0 @@
-import express from "express";
-import request from "supertest";
-import { describe, it, expect, vi } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-import { Observable, of } from "rxjs";
-
-import { createCopilotEndpointExpress } from "../express";
-import { createCopilotEndpointSingleRouteExpress } from "../endpoints/express-single";
-import { CopilotRuntime } from "../core/runtime";
-
-vi.mock("../handlers/handle-run", () => ({
-  handleRunAgent: vi
-    .fn()
-    .mockResolvedValue(new Response(null, { status: 200 })),
-}));
-
-vi.mock("../handlers/handle-connect", () => ({
-  handleConnectAgent: vi
-    .fn()
-    .mockResolvedValue(new Response(null, { status: 200 })),
-}));
-
-vi.mock("../handlers/handle-stop", () => ({
-  handleStopAgent: vi
-    .fn()
-    .mockResolvedValue(new Response(null, { status: 200 })),
-}));
-
-describe("Express adapter with hooks", () => {
-  const createMockRuntime = (opts?: Partial<CopilotRuntime>) => {
-    const createMockAgent = () => {
-      const agent: unknown = {
-        execute: async () => ({ events: [] }),
-      };
-      (agent as { clone: () => unknown }).clone = () => createMockAgent();
-      return agent as AbstractAgent;
-    };
-
-    const runner = {
-      run: () =>
-        new Observable((observer) => {
-          observer.next({});
-          observer.complete();
-          return () => undefined;
-        }),
-      connect: () => of({}),
-      stop: async () => true,
-    };
-
-    return new CopilotRuntime({
-      agents: {
-        default: createMockAgent(),
-        myAgent: createMockAgent(),
-        testAgent: createMockAgent(),
-      },
-      runner,
-      ...opts,
-    });
-  };
-
-  describe("createCopilotEndpointExpress", () => {
-    const createApp = (
-      runtimeOpts?: Partial<CopilotRuntime>,
-      endpointOpts?: Partial<
-        Omit<
-          Parameters<typeof createCopilotEndpointExpress>[0],
-          "runtime" | "basePath"
-        >
-      >,
-    ) => {
-      const runtime = createMockRuntime(runtimeOpts);
-      const app = express();
-      app.use(
-        createCopilotEndpointExpress({
-          runtime,
-          basePath: "/",
-          ...endpointOpts,
-        }),
-      );
-      return { app, runtime };
-    };
-
-    it("routes GET /info correctly", async () => {
-      const { app } = createApp();
-      const response = await request(app).get("/info");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toHaveProperty("version");
-    });
-
-    it("routes POST /agent/:id/run correctly", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/agent/myAgent/run")
-        .set("Content-Type", "application/json")
-        .send({
-          messages: [],
-          state: {},
-          threadId: "thread-1",
-        });
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("forwards hooks — onRequest hook is called", async () => {
-      const onRequest = vi.fn();
-      const { app } = createApp(undefined, { hooks: { onRequest } });
-
-      await request(app).get("/info");
-
-      expect(onRequest).toHaveBeenCalledTimes(1);
-      expect(onRequest).toHaveBeenCalledWith(
-        expect.objectContaining({
-          request: expect.any(Request),
-          path: expect.stringContaining("/info"),
-          runtime: expect.any(CopilotRuntime),
-        }),
-      );
-    });
-
-    it("hooks can modify response headers via onResponse", async () => {
-      const { app } = createApp(undefined, {
-        hooks: {
-          onResponse: ({ response }) => {
-            const headers = new Headers(response.headers);
-            headers.set("x-custom-header", "hello-from-hook");
-            return new Response(response.body, {
-              status: response.status,
-              headers,
-            });
-          },
-        },
-      });
-
-      const response = await request(app).get("/info");
-
-      expect(response.status).toBe(200);
-      expect(response.headers["x-custom-header"]).toBe("hello-from-hook");
-    });
-
-    it("CORS headers are present (Access-Control-Allow-Origin: *)", async () => {
-      const { app } = createApp(undefined, { cors: true });
-      const response = await request(app)
-        .options("/info")
-        .set("Origin", "https://example.com")
-        .set("Access-Control-Request-Method", "GET");
-
-      expect(response.headers["access-control-allow-origin"]).toBe("*");
-    });
-  });
-
-  describe("createCopilotEndpointSingleRouteExpress", () => {
-    const createSingleApp = (
-      hooks?: Parameters<
-        typeof createCopilotEndpointSingleRouteExpress
-      >[0]["hooks"],
-    ) => {
-      const runtime = createMockRuntime();
-      const app = express();
-      app.use(
-        createCopilotEndpointSingleRouteExpress({
-          runtime,
-          basePath: "/rpc",
-          hooks,
-        }),
-      );
-      return { app, runtime };
-    };
-
-    it("dispatches single-route with method envelope", async () => {
-      const { app } = createSingleApp();
-      const response = await request(app)
-        .post("/rpc")
-        .set("Content-Type", "application/json")
-        .send({
-          method: "agent/run",
-          params: { agentId: "myAgent" },
-          body: {
-            messages: [],
-            state: {},
-            threadId: "thread-1",
-          },
-        });
-
-      expect(response.status).not.toBe(404);
-    });
-  });
-});

package/src/v2/runtime/__tests__/express-body-order.test.ts

@@ -1,76 +0,0 @@
-import express from "express";
-import request from "supertest";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-import { createCopilotEndpointExpress } from "../express";
-import { CopilotRuntime } from "../core/runtime";
-
-const handleRunAgentMock = vi.fn();
-
-vi.mock("../handlers/handle-run", () => ({
-  handleRunAgent: (...args: unknown[]) => handleRunAgentMock(...args),
-}));
-
-const createRuntime = () =>
-  new CopilotRuntime({
-    agents: {
-      agent: {
-        clone: () => ({
-          execute: async () => ({ events: [] }),
-        }),
-      } as unknown as AbstractAgent,
-    },
-  });
-
-describe("createCopilotEndpointExpress with body parsers", () => {
-  beforeEach(() => {
-    handleRunAgentMock.mockReset();
-    handleRunAgentMock.mockImplementation(
-      async ({ request }: { request: Request }) => {
-        const body = await request.json();
-        return new Response(JSON.stringify({ body }), {
-          headers: { "content-type": "application/json" },
-        });
-      },
-    );
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  const sendRunRequest = (app: express.Express) =>
-    request(app)
-      .post("/agent/agent/run")
-      .set("Content-Type", "application/json")
-      .send({ hello: "world" });
-
-  it("handles requests when CopilotKit router is registered before express.json()", async () => {
-    const app = express();
-    app.use(
-      createCopilotEndpointExpress({ runtime: createRuntime(), basePath: "/" }),
-    );
-    app.use(express.json());
-
-    const response = await sendRunRequest(app);
-
-    expect(response.status).toBe(200);
-    expect(response.body).toEqual({ body: { hello: "world" } });
-    expect(handleRunAgentMock).toHaveBeenCalledTimes(1);
-  });
-
-  it("handles requests when express.json() runs before the CopilotKit router", async () => {
-    const app = express();
-    app.use(express.json());
-    app.use(
-      createCopilotEndpointExpress({ runtime: createRuntime(), basePath: "/" }),
-    );
-
-    const response = await sendRunRequest(app);
-
-    expect(response.status).toBe(200);
-    expect(response.body).toEqual({ body: { hello: "world" } });
-    expect(handleRunAgentMock).toHaveBeenCalledTimes(1);
-  });
-});

package/src/v2/runtime/__tests__/express-fetch-bridge.test.ts

@@ -1,344 +0,0 @@
-import express from "express";
-import request from "supertest";
-import { describe, it, expect, vi } from "vitest";
-import { createExpressNodeHandler } from "../endpoints/express-fetch-bridge";
-import type { CopilotRuntimeFetchHandler } from "../core/fetch-handler";
-
-/* ------------------------------------------------------------------------------------------------
- * Helpers
- * --------------------------------------------------------------------------------------------- */
-
-/**
- * Creates an Express app that optionally runs express.json() before our handler,
- * simulating the "pre-parsed body" scenario.
- */
-function createApp(
-  fetchHandler: CopilotRuntimeFetchHandler,
-  opts: { bodyParserFirst?: boolean } = {},
-) {
-  const app = express();
-  const nodeHandler = createExpressNodeHandler(fetchHandler);
-
-  if (opts.bodyParserFirst) {
-    app.use(express.json());
-  }
-
-  app.all(/.*/, (req, res) => nodeHandler(req, res));
-  return app;
-}
-
-/* ------------------------------------------------------------------------------------------------
- * Pre-parsed body (express.json() before handler)
- * --------------------------------------------------------------------------------------------- */
-
-describe("express-fetch-bridge — pre-parsed body", () => {
-  it("receives JSON body when express.json() runs first", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      const body = await req.json();
-      return new Response(JSON.stringify({ received: body }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send({ hello: "world" });
-
-    expect(res.status).toBe(200);
-    expect(res.body.received).toEqual({ hello: "world" });
-  });
-
-  it("receives JSON body when express.json() does NOT run first", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      const body = await req.json();
-      return new Response(JSON.stringify({ received: body }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: false });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send({ hello: "world" });
-
-    expect(res.status).toBe(200);
-    expect(res.body.received).toEqual({ hello: "world" });
-  });
-
-  it("preserves nested objects in pre-parsed body", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      const body = await req.json();
-      return new Response(JSON.stringify(body), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const payload = {
-      messages: [{ role: "user", content: "hi" }],
-      state: { count: 42, nested: { deep: true } },
-      threadId: "t-123",
-    };
-
-    const res = await request(app)
-      .post("/agent/default/run")
-      .set("Content-Type", "application/json")
-      .send(payload);
-
-    expect(res.status).toBe(200);
-    expect(res.body).toEqual(payload);
-  });
-
-  it("preserves arrays in pre-parsed body", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      const body = await req.json();
-      return new Response(JSON.stringify(body), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send([1, 2, 3]);
-
-    expect(res.status).toBe(200);
-    expect(res.body).toEqual([1, 2, 3]);
-  });
-
-  it("empty object body is preserved", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      const body = await req.json();
-      return new Response(JSON.stringify({ received: body }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send({});
-
-    expect(res.status).toBe(200);
-    expect(res.body.received).toEqual({});
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * URL reconstruction
- * --------------------------------------------------------------------------------------------- */
-
-describe("express-fetch-bridge — URL reconstruction", () => {
-  it("preserves pathname in reconstructed URL", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      const url = new URL(req.url);
-      return new Response(JSON.stringify({ path: url.pathname }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/api/copilotkit/agent/default/run")
-      .set("Content-Type", "application/json")
-      .send({ threadId: "t1" });
-
-    expect(res.status).toBe(200);
-    expect(res.body.path).toBe("/api/copilotkit/agent/default/run");
-  });
-
-  it("preserves query string in reconstructed URL", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      const url = new URL(req.url);
-      return new Response(
-        JSON.stringify({
-          search: url.search,
-          param: url.searchParams.get("foo"),
-        }),
-        { status: 200, headers: { "Content-Type": "application/json" } },
-      );
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test?foo=bar")
-      .set("Content-Type", "application/json")
-      .send({ data: true });
-
-    expect(res.status).toBe(200);
-    expect(res.body.param).toBe("bar");
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * Header preservation
- * --------------------------------------------------------------------------------------------- */
-
-describe("express-fetch-bridge — header preservation", () => {
-  it("preserves custom headers from original request", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      return new Response(
-        JSON.stringify({
-          auth: req.headers.get("authorization"),
-          custom: req.headers.get("x-custom-header"),
-        }),
-        { status: 200, headers: { "Content-Type": "application/json" } },
-      );
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .set("Authorization", "Bearer tok123")
-      .set("X-Custom-Header", "my-value")
-      .send({ data: true });
-
-    expect(res.status).toBe(200);
-    expect(res.body.auth).toBe("Bearer tok123");
-    expect(res.body.custom).toBe("my-value");
-  });
-
-  it("sets content-type to application/json for object bodies", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      return new Response(
-        JSON.stringify({ contentType: req.headers.get("content-type") }),
-        { status: 200, headers: { "Content-Type": "application/json" } },
-      );
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send({ data: true });
-
-    expect(res.status).toBe(200);
-    expect(res.body.contentType).toBe("application/json");
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * HTTP method handling
- * --------------------------------------------------------------------------------------------- */
-
-describe("express-fetch-bridge — HTTP methods", () => {
-  it("GET requests bypass pre-parsed body logic", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      return new Response(JSON.stringify({ method: req.method }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app).get("/info");
-
-    expect(res.status).toBe(200);
-    expect(res.body.method).toBe("GET");
-  });
-
-  it("OPTIONS requests bypass pre-parsed body logic", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (req) => {
-      return new Response(null, { status: 204 });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app).options("/test");
-
-    expect(res.status).toBe(204);
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * Error handling
- * --------------------------------------------------------------------------------------------- */
-
-describe("express-fetch-bridge — error handling", () => {
-  it("returns 500 when fetch handler throws", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async () => {
-      throw new Error("handler exploded");
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send({ data: true });
-
-    expect(res.status).toBe(500);
-    expect(res.text).toBe("Internal Server Error");
-  });
-
-  it("returns 500 when fetch handler throws (no body parser)", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async () => {
-      throw new Error("handler exploded");
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: false });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send({ data: true });
-
-    expect(res.status).toBe(500);
-    expect(res.text).toBe("Internal Server Error");
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * Streaming responses
- * --------------------------------------------------------------------------------------------- */
-
-describe("express-fetch-bridge — streaming responses", () => {
-  it("streams SSE response through pre-parsed body path", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async () => {
-      const stream = new ReadableStream({
-        start(controller) {
-          controller.enqueue(new TextEncoder().encode("data: event1\n\n"));
-          controller.enqueue(new TextEncoder().encode("data: event2\n\n"));
-          controller.close();
-        },
-      });
-      return new Response(stream, {
-        status: 200,
-        headers: { "Content-Type": "text/event-stream" },
-      });
-    };
-
-    const app = createApp(fetchHandler, { bodyParserFirst: true });
-
-    const res = await request(app)
-      .post("/test")
-      .set("Content-Type", "application/json")
-      .send({ data: true });
-
-    expect(res.status).toBe(200);
-    expect(res.text).toContain("data: event1");
-    expect(res.text).toContain("data: event2");
-  });
-});