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

package/src/v2/runtime/__tests__/cors-credentials.test.ts

@@ -1,320 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  createCopilotEndpoint,
-  createCopilotEndpointSingleRoute,
-} from "../endpoints";
-import { CopilotRuntime } from "../core/runtime";
-import type { AbstractAgent } from "@ag-ui/client";
-
-const createMockRuntime = (options: { beforeRequestMiddleware?: any } = {}) => {
-  const createMockAgent = () => {
-    const agent: unknown = {
-      execute: async () => ({ events: [] }),
-    };
-    (agent as { clone: () => unknown }).clone = () => createMockAgent();
-    return agent as AbstractAgent;
-  };
-
-  return new CopilotRuntime({
-    agents: { default: createMockAgent() },
-    ...options,
-  });
-};
-
-describe("CORS credentials configuration", () => {
-  describe("createCopilotEndpoint", () => {
-    it("sets Access-Control-Allow-Credentials header when credentials is true", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        cors: {
-          origin: "https://myapp.com",
-          credentials: true,
-        },
-      });
-
-      // Make a preflight OPTIONS request
-      const request = new Request("https://example.com/info", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://myapp.com",
-          "Access-Control-Request-Method": "GET",
-        },
-      });
-
-      const response = await endpoint.fetch(request);
-
-      expect(response.headers.get("Access-Control-Allow-Credentials")).toBe(
-        "true",
-      );
-      expect(response.headers.get("Access-Control-Allow-Origin")).toBe(
-        "https://myapp.com",
-      );
-    });
-
-    it("does not set Access-Control-Allow-Credentials header when credentials is false", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        cors: {
-          origin: "https://myapp.com",
-          credentials: false,
-        },
-      });
-
-      const request = new Request("https://example.com/info", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://myapp.com",
-          "Access-Control-Request-Method": "GET",
-        },
-      });
-
-      const response = await endpoint.fetch(request);
-
-      // When credentials is false, the header should not be present or be "false"
-      const credentialsHeader = response.headers.get(
-        "Access-Control-Allow-Credentials",
-      );
-      expect(credentialsHeader === null || credentialsHeader === "false").toBe(
-        true,
-      );
-    });
-
-    it("defaults to no credentials when cors config is not provided", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        // No cors config - should default to origin: "*" without credentials
-      });
-
-      const request = new Request("https://example.com/info", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://somesite.com",
-          "Access-Control-Request-Method": "GET",
-        },
-      });
-
-      const response = await endpoint.fetch(request);
-
-      // Should allow any origin but not credentials
-      expect(response.headers.get("Access-Control-Allow-Origin")).toBe("*");
-      const credentialsHeader = response.headers.get(
-        "Access-Control-Allow-Credentials",
-      );
-      expect(credentialsHeader === null || credentialsHeader === "false").toBe(
-        true,
-      );
-    });
-
-    it("receives cookies in request when client sends them", async () => {
-      const receivedCookies: string[] = [];
-
-      const runtime = createMockRuntime({
-        beforeRequestMiddleware: async ({ request }: { request: Request }) => {
-          const cookie = request.headers.get("Cookie");
-          if (cookie) {
-            receivedCookies.push(cookie);
-          }
-          return undefined; // Don't modify the request
-        },
-      });
-
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        cors: {
-          origin: "https://myapp.com",
-          credentials: true,
-        },
-      });
-
-      // Simulate a request with cookies (as a browser would send with credentials: "include")
-      const request = new Request("https://example.com/info", {
-        method: "GET",
-        headers: {
-          Origin: "https://myapp.com",
-          Cookie: "session=abc123; user=john",
-        },
-      });
-
-      const response = await endpoint.fetch(request);
-
-      expect(response.status).toBe(200);
-      expect(receivedCookies).toContain("session=abc123; user=john");
-    });
-  });
-
-  describe("createCopilotEndpointSingleRoute", () => {
-    it("sets Access-Control-Allow-Credentials header when credentials is true", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpointSingleRoute({
-        runtime,
-        basePath: "/api/copilotkit",
-        cors: {
-          origin: "https://myapp.com",
-          credentials: true,
-        },
-      });
-
-      const request = new Request("https://example.com/api/copilotkit", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://myapp.com",
-          "Access-Control-Request-Method": "POST",
-        },
-      });
-
-      const response = await endpoint.fetch(request);
-
-      expect(response.headers.get("Access-Control-Allow-Credentials")).toBe(
-        "true",
-      );
-      expect(response.headers.get("Access-Control-Allow-Origin")).toBe(
-        "https://myapp.com",
-      );
-    });
-
-    it("receives cookies in POST request body", async () => {
-      const receivedCookies: string[] = [];
-
-      const runtime = createMockRuntime({
-        beforeRequestMiddleware: async ({ request }: { request: Request }) => {
-          const cookie = request.headers.get("Cookie");
-          if (cookie) {
-            receivedCookies.push(cookie);
-          }
-          return undefined;
-        },
-      });
-
-      const endpoint = createCopilotEndpointSingleRoute({
-        runtime,
-        basePath: "/api/copilotkit",
-        cors: {
-          origin: "https://myapp.com",
-          credentials: true,
-        },
-      });
-
-      const request = new Request("https://example.com/api/copilotkit", {
-        method: "POST",
-        headers: {
-          Origin: "https://myapp.com",
-          "Content-Type": "application/json",
-          Cookie: "auth_token=xyz789",
-        },
-        body: JSON.stringify({ method: "info" }),
-      });
-
-      const response = await endpoint.fetch(request);
-
-      expect(response.status).toBe(200);
-      expect(receivedCookies).toContain("auth_token=xyz789");
-    });
-  });
-
-  describe("origin configuration", () => {
-    it("supports string origin", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        cors: {
-          origin: "https://specific-origin.com",
-          credentials: true,
-        },
-      });
-
-      const request = new Request("https://example.com/info", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://specific-origin.com",
-          "Access-Control-Request-Method": "GET",
-        },
-      });
-
-      const response = await endpoint.fetch(request);
-
-      expect(response.headers.get("Access-Control-Allow-Origin")).toBe(
-        "https://specific-origin.com",
-      );
-    });
-
-    it("supports array of origins", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        cors: {
-          origin: ["https://app1.com", "https://app2.com"],
-          credentials: true,
-        },
-      });
-
-      // Request from first allowed origin
-      const request1 = new Request("https://example.com/info", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://app1.com",
-          "Access-Control-Request-Method": "GET",
-        },
-      });
-
-      const response1 = await endpoint.fetch(request1);
-      expect(response1.headers.get("Access-Control-Allow-Origin")).toBe(
-        "https://app1.com",
-      );
-
-      // Request from second allowed origin
-      const request2 = new Request("https://example.com/info", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://app2.com",
-          "Access-Control-Request-Method": "GET",
-        },
-      });
-
-      const response2 = await endpoint.fetch(request2);
-      expect(response2.headers.get("Access-Control-Allow-Origin")).toBe(
-        "https://app2.com",
-      );
-    });
-
-    it("supports function origin for dynamic resolution", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        cors: {
-          origin: (origin: string) => {
-            // Only allow origins ending with .mycompany.com
-            if (origin.endsWith(".mycompany.com")) {
-              return origin;
-            }
-            return null;
-          },
-          credentials: true,
-        },
-      });
-
-      // Allowed origin
-      const request1 = new Request("https://example.com/info", {
-        method: "OPTIONS",
-        headers: {
-          Origin: "https://app.mycompany.com",
-          "Access-Control-Request-Method": "GET",
-        },
-      });
-
-      const response1 = await endpoint.fetch(request1);
-      expect(response1.headers.get("Access-Control-Allow-Origin")).toBe(
-        "https://app.mycompany.com",
-      );
-    });
-  });
-});

package/src/v2/runtime/__tests__/debug-sse-response.test.ts

@@ -1,302 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { Observable, of } from "rxjs";
-import { BaseEvent, EventType } from "@ag-ui/client";
-import type { ResolvedDebugConfig } from "@copilotkit/shared";
-
-const mockDebug = vi.fn();
-
-vi.mock("pino", () => ({
-  default: vi.fn(() => ({
-    child: vi.fn(() => ({ debug: mockDebug })),
-    debug: mockDebug,
-  })),
-}));
-
-vi.mock("pino-pretty", () => ({ default: vi.fn() }));
-
-vi.mock("../../telemetry", () => ({
-  telemetry: { capture: vi.fn() },
-}));
-
-import pino from "pino";
-import { createSseEventResponse } from "../handlers/shared/sse-response";
-
-function createTestObservable(events: BaseEvent[]): Observable<BaseEvent> {
-  return of(...events);
-}
-
-function createMockRequest(): Request {
-  return new Request("https://example.com/agent/test/run", {
-    method: "POST",
-  });
-}
-
-async function drainResponse(response: Response): Promise<void> {
-  const reader = response.body!.getReader();
-  while (true) {
-    const { done } = await reader.read();
-    if (done) break;
-  }
-}
-
-describe("createSseEventResponse debug logging", () => {
-  beforeEach(() => {
-    mockDebug.mockClear();
-  });
-
-  it("does not log when debug is undefined", async () => {
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable([]),
-    });
-
-    await drainResponse(response);
-
-    expect(mockDebug).not.toHaveBeenCalled();
-  });
-
-  it("logs lifecycle message on stream open", async () => {
-    const debug: ResolvedDebugConfig = {
-      enabled: true,
-      events: false,
-      lifecycle: true,
-      verbose: false,
-    };
-
-    const event: BaseEvent = {
-      type: EventType.RUN_STARTED,
-      threadId: "t-1",
-      runId: "r-1",
-    } as BaseEvent;
-
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable([event]),
-      debug,
-    });
-
-    await drainResponse(response);
-
-    expect(mockDebug).toHaveBeenCalledWith("SSE stream opened");
-  });
-
-  it("logs lifecycle completion with total eventCount even when event logging is off", async () => {
-    const debug: ResolvedDebugConfig = {
-      enabled: true,
-      events: false,
-      lifecycle: true,
-      verbose: false,
-    };
-
-    const events: BaseEvent[] = [
-      {
-        type: EventType.RUN_STARTED,
-        threadId: "t-1",
-        runId: "r-1",
-      } as BaseEvent,
-      {
-        type: EventType.RUN_FINISHED,
-        threadId: "t-1",
-        runId: "r-1",
-      } as BaseEvent,
-    ];
-
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable(events),
-      debug,
-    });
-
-    await drainResponse(response);
-
-    expect(mockDebug).toHaveBeenCalledWith(
-      { eventCount: 2, loggedEventCount: 0 },
-      "SSE stream completed",
-    );
-  });
-
-  it("logs lifecycle completion with matching eventCount and loggedEventCount when events enabled", async () => {
-    const debug: ResolvedDebugConfig = {
-      enabled: true,
-      events: true,
-      lifecycle: true,
-      verbose: false,
-    };
-
-    const events: BaseEvent[] = [
-      {
-        type: EventType.RUN_STARTED,
-        threadId: "t-1",
-        runId: "r-1",
-      } as BaseEvent,
-      {
-        type: EventType.RUN_FINISHED,
-        threadId: "t-1",
-        runId: "r-1",
-      } as BaseEvent,
-    ];
-
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable(events),
-      debug,
-    });
-
-    await drainResponse(response);
-
-    expect(mockDebug).toHaveBeenCalledWith(
-      { eventCount: 2, loggedEventCount: 2 },
-      "SSE stream completed",
-    );
-  });
-
-  it("logs events in summary mode when verbose is false", async () => {
-    const debug: ResolvedDebugConfig = {
-      enabled: true,
-      events: true,
-      lifecycle: false,
-      verbose: false,
-    };
-
-    const event: BaseEvent = {
-      type: EventType.TEXT_MESSAGE_START,
-      messageId: "msg-1",
-      role: "assistant",
-    } as BaseEvent;
-
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable([event]),
-      debug,
-    });
-
-    await drainResponse(response);
-
-    const eventEmittedCalls = mockDebug.mock.calls.filter(
-      (call) => call[call.length - 1] === "Event emitted",
-    );
-    expect(eventEmittedCalls.length).toBeGreaterThanOrEqual(1);
-
-    const [summaryArg] = eventEmittedCalls[0];
-    expect(summaryArg).toHaveProperty("type", EventType.TEXT_MESSAGE_START);
-    expect(summaryArg).toHaveProperty("messageId", "msg-1");
-    // In summary mode the full event object is not passed directly
-    expect(summaryArg).not.toHaveProperty("event");
-  });
-
-  it("logs events in verbose mode with full event object", async () => {
-    const debug: ResolvedDebugConfig = {
-      enabled: true,
-      events: true,
-      lifecycle: false,
-      verbose: true,
-    };
-
-    const event: BaseEvent = {
-      type: EventType.TEXT_MESSAGE_START,
-      messageId: "msg-1",
-      role: "assistant",
-    } as BaseEvent;
-
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable([event]),
-      debug,
-    });
-
-    await drainResponse(response);
-
-    const eventEmittedCalls = mockDebug.mock.calls.filter(
-      (call) => call[call.length - 1] === "Event emitted",
-    );
-    expect(eventEmittedCalls.length).toBeGreaterThanOrEqual(1);
-
-    const [verboseArg] = eventEmittedCalls[0];
-    expect(verboseArg).toHaveProperty("event");
-    expect(verboseArg.event).toEqual(event);
-  });
-
-  it("uses a pre-created logger instead of calling createLogger when one is provided", async () => {
-    const debug: ResolvedDebugConfig = {
-      enabled: true,
-      events: false,
-      lifecycle: true,
-      verbose: false,
-    };
-
-    const externalDebug = vi.fn();
-    const externalLogger = { debug: externalDebug } as any;
-
-    // Clear the pino mock call count so we can assert it was NOT called again
-    const pinoMock = pino as unknown as ReturnType<typeof vi.fn>;
-    pinoMock.mockClear();
-
-    const event: BaseEvent = {
-      type: EventType.RUN_STARTED,
-      threadId: "t-1",
-      runId: "r-1",
-    } as BaseEvent;
-
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable([event]),
-      debug,
-      logger: externalLogger,
-    });
-
-    await drainResponse(response);
-
-    // The external logger should have been used for lifecycle messages
-    expect(externalDebug).toHaveBeenCalledWith("SSE stream opened");
-    expect(externalDebug).toHaveBeenCalledWith(
-      { eventCount: 1, loggedEventCount: 0 },
-      "SSE stream completed",
-    );
-
-    // pino should NOT have been called – the pre-created logger was reused
-    expect(pinoMock).not.toHaveBeenCalled();
-  });
-
-  it("does not log events when events is disabled", async () => {
-    const debug: ResolvedDebugConfig = {
-      enabled: true,
-      events: false,
-      lifecycle: true,
-      verbose: false,
-    };
-
-    const events: BaseEvent[] = [
-      {
-        type: EventType.TEXT_MESSAGE_START,
-        messageId: "msg-1",
-        role: "assistant",
-      } as BaseEvent,
-      {
-        type: EventType.RUN_FINISHED,
-        threadId: "t-1",
-        runId: "r-1",
-      } as BaseEvent,
-    ];
-
-    const response = createSseEventResponse({
-      request: createMockRequest(),
-      observableFactory: () => createTestObservable(events),
-      debug,
-    });
-
-    await drainResponse(response);
-
-    const eventEmittedCalls = mockDebug.mock.calls.filter(
-      (call) => call[call.length - 1] === "Event emitted",
-    );
-    expect(eventEmittedCalls).toHaveLength(0);
-
-    // Only lifecycle calls should be present
-    const lifecycleCalls = mockDebug.mock.calls.filter(
-      (call) =>
-        call[call.length - 1] === "SSE stream opened" ||
-        call[call.length - 1] === "SSE stream completed",
-    );
-    expect(lifecycleCalls.length).toBeGreaterThanOrEqual(1);
-  });
-});