@copilotkit/runtime 1.57.2 → 1.57.4

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

@@ -1,250 +0,0 @@
-import { vi, type MockedFunction } from "vitest";
-import { createCopilotEndpoint } from "../endpoints";
-import { CopilotRuntime } from "../core/runtime";
-import { logger } from "@copilotkit/shared";
-import type { AbstractAgent } from "@ag-ui/client";
-import { afterEach, describe, expect, it } from "vitest";
-
-const dummyRuntime = (opts: Partial<CopilotRuntime> = {}) => {
-  const runtime = new CopilotRuntime({
-    agents: { agent: {} as unknown as AbstractAgent },
-    ...opts,
-  });
-  return runtime;
-};
-
-describe("CopilotEndpoint middleware", () => {
-  afterEach(() => {
-    vi.restoreAllMocks();
-    // restore global fetch if it was mocked
-    if (fetchMock) {
-      global.fetch = originalFetch;
-    }
-  });
-
-  let originalFetch: typeof fetch;
-  let fetchMock: MockedFunction<typeof fetch> | null = null;
-
-  const setupFetchMock = (beforeUrl: string, afterUrl: string) => {
-    originalFetch = global.fetch;
-    fetchMock = vi.fn().mockImplementation(async (url: string) => {
-      if (url === beforeUrl) {
-        const body = {
-          headers: { "x-modified": "yes" },
-          body: { foo: "bar" },
-        };
-        return new Response(JSON.stringify(body), {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        });
-      }
-      if (url === afterUrl) {
-        return new Response(null, { status: 204 });
-      }
-      throw new Error(`Unexpected fetch URL: ${url}`);
-    });
-    // Override global fetch for the duration of this test
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    global.fetch = fetchMock as unknown as typeof fetch;
-  };
-
-  it("processes request through middleware and handler", async () => {
-    const originalRequest = new Request("https://example.com/info");
-    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 endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
-    const response = await endpoint.fetch(originalRequest);
-
-    expect(before).toHaveBeenCalledWith({
-      runtime,
-      request: originalRequest,
-      path: expect.any(String),
-    });
-    await new Promise((r) => setImmediate(r));
-    expect(after).toHaveBeenCalledWith(
-      expect.objectContaining({
-        runtime,
-        response: expect.any(Response),
-        path: expect.any(String),
-      }),
-    );
-    // The response should contain version info from the /info endpoint
-    const body = await response.json();
-    expect(body).toHaveProperty("version");
-  });
-
-  it("logs and returns Response error from beforeRequestMiddleware", 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")
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .mockImplementation(() => undefined as any);
-
-    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
-    const response = await endpoint.fetch(
-      new Request("https://example.com/info"),
-    );
-
-    expect(response.status).toBe(400);
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: errorResponse,
-        url: "https://example.com/info",
-        path: expect.any(String),
-      }),
-      "Error running before request middleware",
-    );
-    expect(after).not.toHaveBeenCalled();
-  });
-
-  it("logs and returns 500 error from beforeRequestMiddleware", 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")
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .mockImplementation(() => undefined as any);
-
-    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
-
-    const response = await endpoint.fetch(
-      new Request("https://example.com/info"),
-    );
-
-    // Hono catches errors and returns them as 500 responses
-    expect(response.status).toBe(500);
-
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: error,
-        url: "https://example.com/info",
-        path: expect.any(String),
-      }),
-      "Error running before request middleware",
-    );
-    expect(after).not.toHaveBeenCalled();
-  });
-
-  it("logs error from handler", async () => {
-    // Create a mock agent that throws an error
-    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: { errorAgent },
-    });
-    const logSpy = vi
-      .spyOn(logger, "error")
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .mockImplementation(() => undefined as any);
-
-    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
-
-    const response = await endpoint.fetch(
-      new Request("https://example.com/agent/errorAgent/run", {
-        method: "POST",
-      }),
-    );
-
-    // Hono catches errors and returns them as 500 responses
-    expect(response.status).toBe(500);
-
-    // The actual handler logs the error, not the middleware
-    expect(logSpy).toHaveBeenCalled();
-    // After middleware is called even on error
-    await new Promise((r) => setTimeout(r, 50));
-    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 endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
-    const response = await endpoint.fetch(
-      new Request("https://example.com/info"),
-    );
-
-    await new Promise((r) => setImmediate(r));
-
-    expect(response).toBeInstanceOf(Response);
-    expect(after).toHaveBeenCalled();
-    expect(receivedParams).toHaveProperty("messages");
-    expect(receivedParams.messages).toEqual([]);
-  });
-
-  it("logs but does not rethrow error from afterRequestMiddleware", 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")
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .mockImplementation(() => undefined as any);
-
-    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
-    const response = await endpoint.fetch(
-      new Request("https://example.com/info"),
-    );
-
-    await new Promise((r) => setImmediate(r));
-
-    expect(response).toBeInstanceOf(Response);
-    expect(after).toHaveBeenCalledWith(
-      expect.objectContaining({
-        runtime,
-        response: expect.any(Response),
-        path: expect.any(String),
-      }),
-    );
-
-    await new Promise((r) => setImmediate(r));
-
-    expect(logSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        err: error,
-        url: "https://example.com/info",
-      }),
-      "Error running after request middleware",
-    );
-  });
-});

package/src/v2/runtime/__tests__/node-fetch-handler.test.ts

@@ -1,157 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createServer, type Server } from "node:http";
-import { createNodeFetchHandler } from "../endpoints/node-fetch-handler";
-import type { CopilotRuntimeFetchHandler } from "../core/fetch-handler";
-
-const getPort = (() => {
-  let port = 19000;
-  return () => port++;
-})();
-
-function listen(server: Server, port: number): Promise<void> {
-  return new Promise((resolve) => server.listen(port, resolve));
-}
-
-function close(server: Server): Promise<void> {
-  return new Promise((resolve, reject) =>
-    server.close((err) => (err ? reject(err) : resolve())),
-  );
-}
-
-describe("createNodeFetchHandler", () => {
-  it("converts Node request to Fetch and sends response back", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (request) => {
-      const url = new URL(request.url);
-      return new Response(
-        JSON.stringify({ path: url.pathname, method: request.method }),
-        {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        },
-      );
-    };
-
-    const nodeHandler = createNodeFetchHandler(fetchHandler);
-    const port = getPort();
-    const server = createServer(nodeHandler);
-    await listen(server, port);
-
-    try {
-      const response = await fetch(`http://localhost:${port}/test`);
-      expect(response.status).toBe(200);
-      const body = await response.json();
-      expect(body).toEqual({ path: "/test", method: "GET" });
-    } finally {
-      await close(server);
-    }
-  });
-
-  it("handles POST with JSON body", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async (request) => {
-      const body = await request.json();
-      return new Response(JSON.stringify({ received: body }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    };
-
-    const nodeHandler = createNodeFetchHandler(fetchHandler);
-    const port = getPort();
-    const server = createServer(nodeHandler);
-    await listen(server, port);
-
-    try {
-      const response = await fetch(`http://localhost:${port}/data`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ hello: "world" }),
-      });
-      expect(response.status).toBe(200);
-      const body = await response.json();
-      expect(body).toEqual({ received: { hello: "world" } });
-    } finally {
-      await close(server);
-    }
-  });
-
-  it("returns 500 for unhandled errors in the fetch handler", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async () => {
-      throw new Error("Unexpected error");
-    };
-
-    const nodeHandler = createNodeFetchHandler(fetchHandler);
-    const port = getPort();
-    const server = createServer(nodeHandler);
-    await listen(server, port);
-
-    try {
-      const response = await fetch(`http://localhost:${port}/boom`);
-      expect(response.status).toBe(500);
-      const text = await response.text();
-      expect(text).toBe("Internal Server Error");
-    } finally {
-      await close(server);
-    }
-  });
-
-  it("streams SSE responses without buffering", 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",
-          "Cache-Control": "no-cache",
-        },
-      });
-    };
-
-    const nodeHandler = createNodeFetchHandler(fetchHandler);
-    const port = getPort();
-    const server = createServer(nodeHandler);
-    await listen(server, port);
-
-    try {
-      const response = await fetch(`http://localhost:${port}/sse`);
-      expect(response.status).toBe(200);
-      expect(response.headers.get("Content-Type")).toBe("text/event-stream");
-      const text = await response.text();
-      expect(text).toContain("data: event1");
-      expect(text).toContain("data: event2");
-    } finally {
-      await close(server);
-    }
-  });
-
-  it("preserves response headers", async () => {
-    const fetchHandler: CopilotRuntimeFetchHandler = async () => {
-      return new Response("ok", {
-        status: 201,
-        headers: {
-          "X-Custom-Header": "custom-value",
-          "Content-Type": "text/plain",
-        },
-      });
-    };
-
-    const nodeHandler = createNodeFetchHandler(fetchHandler);
-    const port = getPort();
-    const server = createServer(nodeHandler);
-    await listen(server, port);
-
-    try {
-      const response = await fetch(`http://localhost:${port}/custom`);
-      expect(response.status).toBe(201);
-      expect(response.headers.get("X-Custom-Header")).toBe("custom-value");
-    } finally {
-      await close(server);
-    }
-  });
-});