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

package/src/v2/runtime/__tests__/fetch-router.test.ts

@@ -1,276 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { matchRoute } from "../core/fetch-router";
-
-describe("fetch-router", () => {
-  describe("with basePath (strict prefix stripping)", () => {
-    const basePath = "/api/copilotkit";
-
-    it("matches GET /info", () => {
-      const result = matchRoute("/api/copilotkit/info", basePath);
-      expect(result).toEqual({ method: "info" });
-    });
-
-    it("matches POST /transcribe", () => {
-      const result = matchRoute("/api/copilotkit/transcribe", basePath);
-      expect(result).toEqual({ method: "transcribe" });
-    });
-
-    it("matches POST /agent/:agentId/run", () => {
-      const result = matchRoute("/api/copilotkit/agent/myAgent/run", basePath);
-      expect(result).toEqual({ method: "agent/run", agentId: "myAgent" });
-    });
-
-    it("matches POST /agent/:agentId/connect", () => {
-      const result = matchRoute(
-        "/api/copilotkit/agent/myAgent/connect",
-        basePath,
-      );
-      expect(result).toEqual({ method: "agent/connect", agentId: "myAgent" });
-    });
-
-    it("matches POST /agent/:agentId/stop/:threadId", () => {
-      const result = matchRoute(
-        "/api/copilotkit/agent/myAgent/stop/thread-123",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "agent/stop",
-        agentId: "myAgent",
-        threadId: "thread-123",
-      });
-    });
-
-    it("returns null for paths not starting with basePath", () => {
-      const result = matchRoute("/other/info", basePath);
-      expect(result).toBeNull();
-    });
-
-    it("returns null for unmatched subpaths after basePath", () => {
-      const result = matchRoute("/api/copilotkit/unknown", basePath);
-      expect(result).toBeNull();
-    });
-
-    it("matches GET /threads", () => {
-      const result = matchRoute("/api/copilotkit/threads", basePath);
-      expect(result).toEqual({ method: "threads/list" });
-    });
-
-    it("matches POST /threads/subscribe", () => {
-      const result = matchRoute("/api/copilotkit/threads/subscribe", basePath);
-      expect(result).toEqual({ method: "threads/subscribe" });
-    });
-
-    it("matches PATCH /threads/:threadId", () => {
-      const result = matchRoute("/api/copilotkit/threads/thread-abc", basePath);
-      expect(result).toEqual({
-        method: "threads/update",
-        threadId: "thread-abc",
-      });
-    });
-
-    it("matches POST /threads/:threadId/archive", () => {
-      const result = matchRoute(
-        "/api/copilotkit/threads/thread-abc/archive",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "threads/archive",
-        threadId: "thread-abc",
-      });
-    });
-
-    it("matches GET /threads/:threadId/messages", () => {
-      const result = matchRoute(
-        "/api/copilotkit/threads/thread-abc/messages",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "threads/messages",
-        threadId: "thread-abc",
-      });
-    });
-
-    it("matches GET /threads/:threadId/events", () => {
-      const result = matchRoute(
-        "/api/copilotkit/threads/thread-abc/events",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "threads/events",
-        threadId: "thread-abc",
-      });
-    });
-
-    it("matches GET /threads/:threadId/events with URL-encoded threadId", () => {
-      const result = matchRoute(
-        "/api/copilotkit/threads/thread%2F123/events",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "threads/events",
-        threadId: "thread/123",
-      });
-    });
-
-    it("matches GET /threads/:threadId/state", () => {
-      const result = matchRoute(
-        "/api/copilotkit/threads/thread-abc/state",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "threads/state",
-        threadId: "thread-abc",
-      });
-    });
-
-    it("matches POST /threads/clear (and does not collide with threads/update)", () => {
-      // Critical: the threads/update route also matches /threads/:threadId,
-      // so we must verify that "/threads/clear" never falls through to that
-      // arm with threadId="clear". The router has explicit guards (the
-      // segment[len-1] !== "clear" check) — this test pins them.
-      const result = matchRoute("/api/copilotkit/threads/clear", basePath);
-      expect(result).toEqual({ method: "threads/clear" });
-      expect(result).not.toEqual({
-        method: "threads/update",
-        threadId: "clear",
-      });
-    });
-
-    it("handles URL-encoded threadId in thread routes", () => {
-      const result = matchRoute(
-        "/api/copilotkit/threads/thread%2F123",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "threads/update",
-        threadId: "thread/123",
-      });
-    });
-
-    it("returns null when basePath is a prefix but not a segment boundary", () => {
-      const result = matchRoute("/api/copilotkitextra/info", basePath);
-      expect(result).toBeNull();
-    });
-
-    it("handles basePath with trailing slash", () => {
-      const result = matchRoute("/api/copilotkit/info", "/api/copilotkit/");
-      expect(result).toEqual({ method: "info" });
-    });
-
-    it("handles URL-encoded agentId", () => {
-      const result = matchRoute(
-        "/api/copilotkit/agent/my%20agent/run",
-        basePath,
-      );
-      expect(result).toEqual({ method: "agent/run", agentId: "my agent" });
-    });
-
-    it("handles URL-encoded threadId", () => {
-      const result = matchRoute(
-        "/api/copilotkit/agent/ag/stop/thread%2F123",
-        basePath,
-      );
-      expect(result).toEqual({
-        method: "agent/stop",
-        agentId: "ag",
-        threadId: "thread/123",
-      });
-    });
-
-    it("matches basePath with just root /", () => {
-      const result = matchRoute("/info", "/");
-      expect(result).toEqual({ method: "info" });
-    });
-
-    it("matches GET /cpk-debug-events", () => {
-      const result = matchRoute("/api/copilotkit/cpk-debug-events", basePath);
-      expect(result).toEqual({ method: "cpk-debug-events" });
-    });
-  });
-
-  describe("without basePath (suffix matching)", () => {
-    it("matches /info suffix", () => {
-      const result = matchRoute("/anything/info");
-      expect(result).toEqual({ method: "info" });
-    });
-
-    it("matches /transcribe suffix", () => {
-      const result = matchRoute("/anything/transcribe");
-      expect(result).toEqual({ method: "transcribe" });
-    });
-
-    it("matches /agent/:agentId/run suffix", () => {
-      const result = matchRoute("/anything/agent/myAgent/run");
-      expect(result).toEqual({ method: "agent/run", agentId: "myAgent" });
-    });
-
-    it("matches /agent/:agentId/connect suffix", () => {
-      const result = matchRoute("/anything/agent/myAgent/connect");
-      expect(result).toEqual({
-        method: "agent/connect",
-        agentId: "myAgent",
-      });
-    });
-
-    it("matches /agent/:agentId/stop/:threadId suffix", () => {
-      const result = matchRoute("/anything/agent/ag/stop/t1");
-      expect(result).toEqual({
-        method: "agent/stop",
-        agentId: "ag",
-        threadId: "t1",
-      });
-    });
-
-    it("returns null when no known suffix matches", () => {
-      const result = matchRoute("/anything/unknown");
-      expect(result).toBeNull();
-    });
-
-    it("matches /threads suffix", () => {
-      const result = matchRoute("/anything/threads");
-      expect(result).toEqual({ method: "threads/list" });
-    });
-
-    it("matches /threads/subscribe suffix", () => {
-      const result = matchRoute("/anything/threads/subscribe");
-      expect(result).toEqual({ method: "threads/subscribe" });
-    });
-
-    it("matches /threads/:threadId suffix", () => {
-      const result = matchRoute("/anything/threads/t1");
-      expect(result).toEqual({ method: "threads/update", threadId: "t1" });
-    });
-
-    it("matches /threads/:threadId/archive suffix", () => {
-      const result = matchRoute("/anything/threads/t1/archive");
-      expect(result).toEqual({ method: "threads/archive", threadId: "t1" });
-    });
-
-    it("matches /threads/:threadId/messages suffix", () => {
-      const result = matchRoute("/anything/threads/t1/messages");
-      expect(result).toEqual({ method: "threads/messages", threadId: "t1" });
-    });
-
-    it("works with deeply nested mount prefix", () => {
-      const result = matchRoute("/api/v2/copilotkit/agent/a1/run");
-      expect(result).toEqual({ method: "agent/run", agentId: "a1" });
-    });
-
-    it("matches /cpk-debug-events suffix", () => {
-      const result = matchRoute("/api/copilotkit/cpk-debug-events");
-      expect(result).toEqual({ method: "cpk-debug-events" });
-    });
-
-    it("matches bare /cpk-debug-events", () => {
-      const result = matchRoute("/cpk-debug-events");
-      expect(result).toEqual({ method: "cpk-debug-events" });
-    });
-  });
-
-  describe("cpk-debug-events route with basePath", () => {
-    it("matches /cpk-debug-events with /api basePath", () => {
-      const result = matchRoute("/api/cpk-debug-events", "/api");
-      expect(result).toEqual({ method: "cpk-debug-events" });
-    });
-  });
-});

package/src/v2/runtime/__tests__/get-runtime-info.test.ts

@@ -1,335 +0,0 @@
-import { handleGetRuntimeInfo } from "../handlers/get-runtime-info";
-import { CopilotRuntime } from "../core/runtime";
-import { TranscriptionService } from "../transcription-service/transcription-service";
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-// Mock transcription service
-class MockTranscriptionService extends TranscriptionService {
-  async transcribeFile(): Promise<string> {
-    return "Mock transcription result";
-  }
-}
-
-describe("handleGetRuntimeInfo", () => {
-  const mockRequest = new Request("https://example.com/info");
-
-  it("should return runtime info with audioFileTranscriptionEnabled=false when no transcription service", async () => {
-    const runtime = new CopilotRuntime({
-      agents: {},
-      // No transcriptionService provided
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    expect(data).toEqual({
-      version: expect.any(String),
-      agents: {},
-      audioFileTranscriptionEnabled: false,
-      mode: "sse",
-      a2uiEnabled: false,
-      openGenerativeUIEnabled: false,
-      telemetryDisabled: false,
-    });
-  });
-
-  it("should return runtime info with audioFileTranscriptionEnabled=true when transcription service is configured", async () => {
-    const mockTranscriptionService = new MockTranscriptionService();
-    const runtime = new CopilotRuntime({
-      agents: {},
-      transcriptionService: mockTranscriptionService,
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    expect(data).toEqual({
-      version: expect.any(String),
-      agents: {},
-      audioFileTranscriptionEnabled: true,
-      mode: "sse",
-      a2uiEnabled: false,
-      openGenerativeUIEnabled: false,
-      telemetryDisabled: false,
-    });
-  });
-
-  it("should include agents information along with audioFileTranscriptionEnabled", async () => {
-    const mockAgent = {
-      description: "Test agent description",
-      constructor: { name: "TestAgent" },
-    };
-
-    const runtime = new CopilotRuntime({
-      agents: {
-        testAgent: mockAgent as AbstractAgent,
-      },
-      transcriptionService: new MockTranscriptionService(),
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    expect(data).toEqual({
-      version: expect.any(String),
-      agents: {
-        testAgent: {
-          name: "testAgent",
-          description: "Test agent description",
-          className: "TestAgent",
-        },
-      },
-      audioFileTranscriptionEnabled: true,
-      mode: "sse",
-      a2uiEnabled: false,
-      openGenerativeUIEnabled: false,
-      telemetryDisabled: false,
-    });
-  });
-
-  it("should return a2uiEnabled: true when runtime has a2ui configured", async () => {
-    const runtime = new CopilotRuntime({
-      agents: {},
-      a2ui: {},
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    expect(data.a2uiEnabled).toBe(true);
-  });
-
-  it("should include capabilities when agent implements getCapabilities", async () => {
-    const mockCapabilities = {
-      tools: { supported: true, clientProvided: true },
-      transport: { streaming: true },
-    };
-
-    const mockAgent = {
-      description: "Capable agent",
-      constructor: { name: "CapableAgent" },
-      getCapabilities: async () => mockCapabilities,
-    };
-
-    const runtime = new CopilotRuntime({
-      agents: {
-        capableAgent: mockAgent as unknown as AbstractAgent,
-      },
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    expect(data.agents.capableAgent.capabilities).toEqual(mockCapabilities);
-  });
-
-  it("should omit capabilities when agent does not implement getCapabilities", async () => {
-    const mockAgent = {
-      description: "Basic agent",
-      constructor: { name: "BasicAgent" },
-    };
-
-    const runtime = new CopilotRuntime({
-      agents: {
-        basicAgent: mockAgent as unknown as AbstractAgent,
-      },
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    expect(data.agents.basicAgent.capabilities).toBeUndefined();
-  });
-
-  it("should include empty capabilities object when getCapabilities returns {}", async () => {
-    const mockAgent = {
-      description: "Empty caps agent",
-      constructor: { name: "EmptyCapsAgent" },
-      getCapabilities: async () => ({}),
-    };
-
-    const runtime = new CopilotRuntime({
-      agents: {
-        emptyAgent: mockAgent as unknown as AbstractAgent,
-      },
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    // {} is truthy, so it should be included in the response
-    expect(data.agents.emptyAgent.capabilities).toEqual({});
-  });
-
-  it("should isolate per-agent getCapabilities failures and log a warning", async () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-
-    const failingAgent = {
-      description: "Failing agent",
-      constructor: { name: "FailingAgent" },
-      getCapabilities: async () => {
-        throw new Error("capability fetch failed");
-      },
-    };
-
-    const healthyAgent = {
-      description: "Healthy agent",
-      constructor: { name: "HealthyAgent" },
-      getCapabilities: async () => ({
-        tools: { supported: true },
-      }),
-    };
-
-    const runtime = new CopilotRuntime({
-      agents: {
-        failing: failingAgent as unknown as AbstractAgent,
-        healthy: healthyAgent as unknown as AbstractAgent,
-      },
-    });
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(200);
-
-    const data = await response.json();
-    // Failing agent should still appear but without capabilities
-    expect(data.agents.failing).toEqual({
-      name: "failing",
-      description: "Failing agent",
-      className: "FailingAgent",
-    });
-    expect(data.agents.failing.capabilities).toBeUndefined();
-
-    // Healthy agent should have its capabilities
-    expect(data.agents.healthy.capabilities).toEqual({
-      tools: { supported: true },
-    });
-
-    // Error should be logged, not silently swallowed
-    expect(warnSpy).toHaveBeenCalledWith(
-      'Failed to fetch capabilities for agent "failing":',
-      "capability fetch failed",
-    );
-
-    warnSpy.mockRestore();
-  });
-
-  describe("telemetryDisabled", () => {
-    beforeEach(() => {
-      delete process.env.COPILOTKIT_TELEMETRY_DISABLED;
-      delete process.env.DO_NOT_TRACK;
-    });
-
-    afterEach(() => {
-      delete process.env.COPILOTKIT_TELEMETRY_DISABLED;
-      delete process.env.DO_NOT_TRACK;
-    });
-
-    it("returns telemetryDisabled: false when env var is not set", async () => {
-      const runtime = new CopilotRuntime({ agents: {} });
-      const response = await handleGetRuntimeInfo({
-        runtime,
-        request: mockRequest,
-      });
-      const data = await response.json();
-      expect(data.telemetryDisabled).toBe(false);
-    });
-
-    it("returns telemetryDisabled: true when COPILOTKIT_TELEMETRY_DISABLED=true", async () => {
-      process.env.COPILOTKIT_TELEMETRY_DISABLED = "true";
-      const runtime = new CopilotRuntime({ agents: {} });
-      const response = await handleGetRuntimeInfo({
-        runtime,
-        request: mockRequest,
-      });
-      const data = await response.json();
-      expect(data.telemetryDisabled).toBe(true);
-    });
-
-    it("returns telemetryDisabled: true when COPILOTKIT_TELEMETRY_DISABLED=1", async () => {
-      process.env.COPILOTKIT_TELEMETRY_DISABLED = "1";
-      const runtime = new CopilotRuntime({ agents: {} });
-      const response = await handleGetRuntimeInfo({
-        runtime,
-        request: mockRequest,
-      });
-      const data = await response.json();
-      expect(data.telemetryDisabled).toBe(true);
-    });
-
-    it("returns telemetryDisabled: true when DO_NOT_TRACK=1", async () => {
-      process.env.DO_NOT_TRACK = "1";
-      const runtime = new CopilotRuntime({ agents: {} });
-      const response = await handleGetRuntimeInfo({
-        runtime,
-        request: mockRequest,
-      });
-      const data = await response.json();
-      expect(data.telemetryDisabled).toBe(true);
-    });
-  });
-
-  it("should return 500 error when runtime.agents throws an error", async () => {
-    const runtime = {
-      get agents(): Record<string, AbstractAgent> {
-        throw new Error("Failed to get agents");
-      },
-      transcriptionService: undefined,
-      beforeRequestMiddleware: undefined,
-      afterRequestMiddleware: undefined,
-      mode: "sse",
-    } as CopilotRuntime;
-
-    const response = await handleGetRuntimeInfo({
-      runtime,
-      request: mockRequest,
-    });
-
-    expect(response.status).toBe(500);
-
-    const data = await response.json();
-    expect(data).toEqual({
-      error: "Failed to retrieve runtime information",
-      message: "Failed to get agents",
-    });
-  });
-});