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

package/src/v2/runtime/__tests__/routing-single.test.ts

@@ -1,193 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-import { createCopilotEndpointSingleRoute } from "../endpoints";
-import { CopilotRuntime } from "../core/runtime";
-
-describe("CopilotEndpointSingleRoute routing", () => {
-  const createMockRuntime = () => {
-    const createMockAgent = () => {
-      const agent: unknown = {
-        execute: async () => ({ events: [] }),
-      };
-      (agent as { clone: () => unknown }).clone = () => createMockAgent();
-      return agent as AbstractAgent;
-    };
-
-    return new CopilotRuntime({
-      agents: {
-        default: createMockAgent(),
-        myAgent: createMockAgent(),
-        agent123: createMockAgent(),
-        "my-agent": createMockAgent(),
-        my_agent: createMockAgent(),
-        testAgent: createMockAgent(),
-        test: createMockAgent(),
-        "test%20agent": createMockAgent(),
-        "test agent": createMockAgent(),
-      },
-    });
-  };
-
-  const callEndpoint = async (body: Record<string, unknown>) => {
-    const runtime = createMockRuntime();
-    const endpoint = createCopilotEndpointSingleRoute({
-      runtime,
-      basePath: "/rpc",
-    });
-    const request = new Request("https://example.com/rpc", {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(body),
-    });
-
-    return endpoint.fetch(request);
-  };
-
-  describe("agent/run method", () => {
-    it("accepts simple agent names", async () => {
-      const response = await callEndpoint({
-        method: "agent/run",
-        params: { agentId: "myAgent" },
-        body: {},
-      });
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("accepts hyphenated agent names", async () => {
-      const response = await callEndpoint({
-        method: "agent/run",
-        params: { agentId: "my-agent" },
-        body: {},
-      });
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("accepts underscored agent names", async () => {
-      const response = await callEndpoint({
-        method: "agent/run",
-        params: { agentId: "my_agent" },
-        body: {},
-      });
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("returns 400 when agentId missing", async () => {
-      const response = await callEndpoint({
-        method: "agent/run",
-        body: {},
-      });
-
-      expect(response.status).toBe(400);
-    });
-  });
-
-  describe("agent/connect method", () => {
-    it("accepts standard agent id", async () => {
-      const response = await callEndpoint({
-        method: "agent/connect",
-        params: { agentId: "agent123" },
-        body: {},
-      });
-
-      expect(response.status).not.toBe(404);
-    });
-  });
-
-  describe("agent/stop method", () => {
-    it("requires threadId", async () => {
-      const response = await callEndpoint({
-        method: "agent/stop",
-        params: { agentId: "agent123" },
-      });
-
-      expect(response.status).toBe(400);
-    });
-
-    it("returns response when params provided", async () => {
-      const response = await callEndpoint({
-        method: "agent/stop",
-        params: { agentId: "agent123", threadId: "thread-1" },
-      });
-
-      expect(response.status).not.toBe(404);
-    });
-  });
-
-  describe("info method", () => {
-    it("returns runtime info for base path", async () => {
-      const response = await callEndpoint({ method: "info" });
-
-      expect(response.status).toBe(200);
-      const body = await response.json();
-      expect(body).toHaveProperty("version");
-    });
-
-    it("handles query parameters", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpointSingleRoute({
-        runtime,
-        basePath: "/rpc",
-      });
-      const request = new Request("https://example.com/rpc?foo=bar", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ method: "info" }),
-      });
-
-      const response = await endpoint.fetch(request);
-      expect(response.status).toBe(200);
-    });
-  });
-
-  describe("transcribe method", () => {
-    it("returns non-404 even without multipart body", async () => {
-      const response = await callEndpoint({ method: "transcribe" });
-
-      expect(response.status).not.toBe(404);
-    });
-  });
-
-  describe("invalid inputs", () => {
-    it("returns 415 for non-JSON content", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpointSingleRoute({
-        runtime,
-        basePath: "/rpc",
-      });
-      const request = new Request("https://example.com/rpc", {
-        method: "POST",
-        headers: { "content-type": "text/plain" },
-        body: "method=info",
-      });
-
-      const response = await endpoint.fetch(request);
-      expect(response.status).toBe(415);
-    });
-
-    it("returns 400 for unsupported method", async () => {
-      const response = await callEndpoint({ method: "unknown" });
-
-      expect(response.status).toBe(400);
-    });
-
-    it("returns 404 for unmatched path", async () => {
-      const runtime = createMockRuntime();
-      const endpoint = createCopilotEndpointSingleRoute({
-        runtime,
-        basePath: "/rpc",
-      });
-      const request = new Request("https://example.com/other", {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ method: "info" }),
-      });
-
-      const response = await endpoint.fetch(request);
-      expect(response.status).toBe(404);
-    });
-  });
-});

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

@@ -1,257 +0,0 @@
-import { createCopilotEndpoint } from "../endpoints";
-import { CopilotRuntime } from "../core/runtime";
-import { describe, it, expect } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-describe("CopilotEndpoint routing", () => {
-  // Helper function to create a Request object with a given URL
-  const createRequest = (url: string, method: string = "GET"): Request => {
-    return new Request(url, { method });
-  };
-
-  // Create a mock runtime with a basic agent
-  const createMockRuntime = () => {
-    const createMockAgent = () => {
-      const agent: unknown = {
-        execute: async () => ({ events: [] }),
-      };
-      (agent as { clone: () => unknown }).clone = () => createMockAgent();
-      return agent as AbstractAgent;
-    };
-
-    return new CopilotRuntime({
-      agents: {
-        default: createMockAgent(),
-        myAgent: createMockAgent(),
-        agent123: createMockAgent(),
-        "my-agent": createMockAgent(),
-        my_agent: createMockAgent(),
-        testAgent: createMockAgent(),
-        test: createMockAgent(),
-        "test%20agent": createMockAgent(),
-        "test agent": createMockAgent(),
-      },
-    });
-  };
-
-  // Helper to test routing
-  const testRoute = async (
-    url: string,
-    method: string = "GET",
-    body?: unknown,
-  ) => {
-    const runtime = createMockRuntime();
-    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
-    const requestInit: RequestInit = { method };
-    if (body) {
-      requestInit.body = JSON.stringify(body);
-      requestInit.headers = { "Content-Type": "application/json" };
-    }
-    const request = createRequest(url, method);
-    const response = await endpoint.fetch(request);
-    return response;
-  };
-
-  describe("RunAgent route pattern", () => {
-    it("should match agent run URL with simple agent name", async () => {
-      const response = await testRoute(
-        "https://example.com/agent/myAgent/run",
-        "POST",
-        {
-          agentId: "myAgent",
-        },
-      );
-
-      // Should not be 404
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should match agent run URL with alphanumeric agent name", async () => {
-      const response = await testRoute(
-        "https://example.com/agent/agent123/run",
-        "POST",
-        {
-          agentId: "agent123",
-        },
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should match agent run URL with hyphenated agent name", async () => {
-      const response = await testRoute(
-        "https://example.com/agent/my-agent/run",
-        "POST",
-        {
-          agentId: "my-agent",
-        },
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should match agent run URL with underscored agent name", async () => {
-      const response = await testRoute(
-        "https://example.com/agent/my_agent/run",
-        "POST",
-        {
-          agentId: "my_agent",
-        },
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should not match agent run URL with empty agent name", async () => {
-      const response = await testRoute(
-        "https://example.com/agent//run",
-        "POST",
-      );
-
-      expect(response.status).toBe(404);
-      const body = await response.json();
-      expect(body).toEqual({ error: "Not found" });
-    });
-
-    it("should not match partial agent run URL", async () => {
-      const response = await testRoute(
-        "https://example.com/agent/myAgent",
-        "POST",
-      );
-
-      expect(response.status).toBe(404);
-    });
-
-    it("should not match agent run URL with extra path segments", async () => {
-      const response = await testRoute(
-        "https://example.com/agent/myAgent/run/extra",
-        "POST",
-      );
-
-      expect(response.status).toBe(404);
-    });
-  });
-
-  describe("GetRuntimeInfo route pattern (/info endpoint)", () => {
-    it("should match simple info URL", async () => {
-      const response = await testRoute("https://example.com/info");
-
-      expect(response.status).toBe(200);
-      const body = await response.json();
-      expect(body).toHaveProperty("version");
-    });
-
-    it("should match info URL with query parameters", async () => {
-      const response = await testRoute("https://example.com/info?param=value");
-
-      expect(response.status).toBe(200);
-    });
-
-    it("should not match non-info URLs", async () => {
-      const response = await testRoute("https://example.com/agents");
-
-      expect(response.status).toBe(404);
-    });
-  });
-
-  describe("Transcribe route pattern (/transcribe endpoint)", () => {
-    it("should match simple transcribe URL", async () => {
-      // Transcribe expects POST method and audio data
-      const response = await testRoute(
-        "https://example.com/transcribe",
-        "POST",
-        {},
-      );
-
-      // It might return an error since we're not providing audio, but it shouldn't be 404
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should match transcribe URL with query parameters", async () => {
-      const response = await testRoute(
-        "https://example.com/transcribe?format=json",
-        "POST",
-        {},
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should not match transcribe URLs with extra path segments", async () => {
-      const response = await testRoute(
-        "https://example.com/transcribe/extra",
-        "POST",
-      );
-
-      expect(response.status).toBe(404);
-    });
-  });
-
-  describe("Unmatched routes (404 behavior)", () => {
-    it("should return 404 for root path", async () => {
-      const response = await testRoute("https://example.com/");
-
-      expect(response.status).toBe(404);
-      const body = await response.json();
-      expect(body).toEqual({ error: "Not found" });
-    });
-
-    it("should return 404 for unknown paths", async () => {
-      const response = await testRoute("https://example.com/unknown/path");
-
-      expect(response.status).toBe(404);
-    });
-
-    it("should return 404 for malformed agent paths", async () => {
-      const response = await testRoute("https://example.com/agent/run", "POST");
-
-      expect(response.status).toBe(404);
-    });
-
-    it("should return 404 for agents path", async () => {
-      const response = await testRoute("https://example.com/agents");
-
-      expect(response.status).toBe(404);
-    });
-  });
-
-  describe("Edge cases", () => {
-    it("should handle URLs with different domains", async () => {
-      const response = await testRoute(
-        "http://localhost:3000/agent/test/run",
-        "POST",
-        {
-          agentId: "test",
-        },
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should handle URLs with ports for info endpoint", async () => {
-      const response = await testRoute("https://api.example.com:8080/info");
-
-      expect(response.status).toBe(200);
-    });
-
-    it("should handle URLs with ports for transcribe endpoint", async () => {
-      const response = await testRoute(
-        "https://api.example.com:8080/transcribe",
-        "POST",
-        {},
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("should handle URLs with special characters in agent names", async () => {
-      const response = await testRoute(
-        "https://example.com/agent/test%20agent/run",
-        "POST",
-        { agentId: "test%20agent" },
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-  });
-});

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

@@ -1,234 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-import {
-  CopilotIntelligenceRuntime,
-  CopilotRuntime,
-  CopilotSseRuntime,
-} from "../core/runtime";
-import type { CopilotKitIntelligence } from "../intelligence-platform";
-import { InMemoryAgentRunner } from "../runner/in-memory";
-import { IntelligenceAgentRunner } from "../runner/intelligence";
-
-describe("runtime construction", () => {
-  const agents = {};
-  const identifyUser = vi
-    .fn()
-    .mockResolvedValue({ id: "user-1", name: "User One" });
-  const createMockIntelligence = (): CopilotKitIntelligence =>
-    ({
-      ɵgetRunnerWsUrl: vi.fn().mockReturnValue("ws://runner.example"),
-      ɵgetRunnerAuthToken: vi.fn().mockReturnValue("token-123"),
-      ɵgetClientWsUrl: vi.fn().mockReturnValue("ws://client.example"),
-    }) as unknown as CopilotKitIntelligence;
-
-  it("builds an SSE runtime by default", () => {
-    const runtime = new CopilotSseRuntime({ agents });
-
-    expect(runtime.mode).toBe("sse");
-
-    expect(runtime.runner).toBeInstanceOf(InMemoryAgentRunner);
-    expect(runtime.intelligence).toBeUndefined();
-  });
-
-  it("builds an Intelligence runtime with an Intelligence runner", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotIntelligenceRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-    });
-
-    expect(runtime.mode).toBe("intelligence");
-
-    expect(runtime.intelligence).toBe(sdk);
-    expect(runtime.runner).toBeInstanceOf(IntelligenceAgentRunner);
-    expect(runtime.generateThreadNames).toBe(true);
-    expect(runtime.identifyUser).toBe(identifyUser);
-    expect(sdk.ɵgetRunnerWsUrl).toHaveBeenCalledTimes(1);
-    expect(sdk.ɵgetRunnerAuthToken).toHaveBeenCalledTimes(1);
-  });
-
-  it("preserves an explicit generateThreadNames=false option in Intelligence mode", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotIntelligenceRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-      generateThreadNames: false,
-    });
-
-    expect(runtime.generateThreadNames).toBe(false);
-  });
-
-  it("keeps CopilotRuntime as an SSE shim when no CopilotKitIntelligence is provided", () => {
-    const runtime = new CopilotRuntime({ agents });
-
-    expect(runtime.mode).toBe("sse");
-
-    expect(runtime.runner).toBeInstanceOf(InMemoryAgentRunner);
-    expect(runtime.intelligence).toBeUndefined();
-  });
-
-  it("keeps CopilotRuntime as an Intelligence shim when CopilotKitIntelligence is provided", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-    });
-
-    expect(runtime.mode).toBe("intelligence");
-
-    expect(runtime.intelligence).toBe(sdk);
-    expect(runtime.runner).toBeInstanceOf(IntelligenceAgentRunner);
-    expect(
-      (runtime as CopilotRuntime & { generateThreadNames?: boolean })
-        .generateThreadNames,
-    ).toBe(true);
-    expect(
-      (
-        runtime as CopilotRuntime & {
-          identifyUser?: typeof identifyUser;
-        }
-      ).identifyUser,
-    ).toBe(identifyUser);
-  });
-
-  it("forwards generateThreadNames=false through the CopilotRuntime intelligence shim", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-      generateThreadNames: false,
-    });
-
-    expect(runtime.mode).toBe("intelligence");
-    expect(
-      (runtime as CopilotRuntime & { generateThreadNames?: boolean })
-        .generateThreadNames,
-    ).toBe(false);
-  });
-
-  it("exposes identifyUser as undefined for SSE runtimes", () => {
-    const runtime = new CopilotRuntime({ agents });
-
-    expect(
-      (runtime as CopilotRuntime & { identifyUser?: typeof identifyUser })
-        .identifyUser,
-    ).toBeUndefined();
-  });
-
-  it("defaults lockTtlSeconds to 20 and lockHeartbeatIntervalSeconds to 15", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotIntelligenceRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-    });
-
-    expect(runtime.lockTtlSeconds).toBe(20);
-    expect(runtime.lockHeartbeatIntervalSeconds).toBe(15);
-  });
-
-  it("clamps lockTtlSeconds to a maximum of 3600 (1 hour)", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotIntelligenceRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-      lockTtlSeconds: 7200,
-    });
-
-    expect(runtime.lockTtlSeconds).toBe(3600);
-  });
-
-  it("clamps lockHeartbeatIntervalSeconds to a maximum of 3000 (50 minutes)", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotIntelligenceRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-      lockHeartbeatIntervalSeconds: 5000,
-    });
-
-    expect(runtime.lockHeartbeatIntervalSeconds).toBe(3000);
-  });
-
-  it("uses provided values when they are within allowed range", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotIntelligenceRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-      lockTtlSeconds: 30,
-    });
-
-    expect(runtime.lockTtlSeconds).toBe(30);
-    expect(runtime.lockHeartbeatIntervalSeconds).toBe(15);
-  });
-
-  it("stores lock config on CopilotIntelligenceRuntime", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotIntelligenceRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-      lockTtlSeconds: 30,
-      lockKeyPrefix: "custom",
-      lockHeartbeatIntervalSeconds: 10,
-    });
-
-    expect(runtime.lockTtlSeconds).toBe(30);
-    expect(runtime.lockKeyPrefix).toBe("custom");
-    expect(runtime.lockHeartbeatIntervalSeconds).toBe(10);
-  });
-
-  it("forwards lock config through the CopilotRuntime intelligence shim", () => {
-    const sdk = createMockIntelligence();
-
-    const runtime = new CopilotRuntime({
-      agents,
-      intelligence: sdk,
-      identifyUser,
-      lockTtlSeconds: 60,
-      lockKeyPrefix: "agent",
-      lockHeartbeatIntervalSeconds: 20,
-    });
-
-    expect(
-      (runtime as CopilotRuntime & { lockTtlSeconds?: number }).lockTtlSeconds,
-    ).toBe(60);
-    expect(
-      (runtime as CopilotRuntime & { lockKeyPrefix?: string }).lockKeyPrefix,
-    ).toBe("agent");
-    expect(
-      (runtime as CopilotRuntime & { lockHeartbeatIntervalSeconds?: number })
-        .lockHeartbeatIntervalSeconds,
-    ).toBe(20);
-  });
-
-  it("exposes lock config as undefined for SSE runtimes", () => {
-    const runtime = new CopilotRuntime({ agents });
-
-    expect(
-      (runtime as CopilotRuntime & { lockTtlSeconds?: number }).lockTtlSeconds,
-    ).toBeUndefined();
-    expect(
-      (runtime as CopilotRuntime & { lockKeyPrefix?: string }).lockKeyPrefix,
-    ).toBeUndefined();
-    expect(
-      (runtime as CopilotRuntime & { lockHeartbeatIntervalSeconds?: number })
-        .lockHeartbeatIntervalSeconds,
-    ).toBeUndefined();
-  });
-});