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

package/src/v2/runtime/__tests__/router-edge-cases.test.ts

@@ -1,217 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { matchRoute } from "../core/fetch-router";
-
-/* ------------------------------------------------------------------------------------------------
- * basePath = "/"
- * --------------------------------------------------------------------------------------------- */
-
-describe("matchRoute — basePath is /", () => {
-  it("matches /info", () => {
-    const result = matchRoute("/info", "/");
-    expect(result).toEqual({ method: "info" });
-  });
-
-  it("matches /agent/:id/run", () => {
-    const result = matchRoute("/agent/myAgent/run", "/");
-    expect(result).toEqual({ method: "agent/run", agentId: "myAgent" });
-  });
-
-  it("matches /agent/:id/connect", () => {
-    const result = matchRoute("/agent/myAgent/connect", "/");
-    expect(result).toEqual({ method: "agent/connect", agentId: "myAgent" });
-  });
-
-  it("matches /agent/:id/stop/:threadId", () => {
-    const result = matchRoute("/agent/myAgent/stop/t1", "/");
-    expect(result).toEqual({
-      method: "agent/stop",
-      agentId: "myAgent",
-      threadId: "t1",
-    });
-  });
-
-  it("matches /transcribe", () => {
-    const result = matchRoute("/transcribe", "/");
-    expect(result).toEqual({ method: "transcribe" });
-  });
-
-  it("returns null for unknown path", () => {
-    const result = matchRoute("/unknown", "/");
-    expect(result).toBeNull();
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * Trailing slash normalization
- * --------------------------------------------------------------------------------------------- */
-
-describe("matchRoute — trailing slash normalization", () => {
-  it("basePath with trailing slash matches", () => {
-    const result = matchRoute("/api/copilotkit/info", "/api/copilotkit/");
-    expect(result).toEqual({ method: "info" });
-  });
-
-  it("basePath without trailing slash matches", () => {
-    const result = matchRoute("/api/copilotkit/info", "/api/copilotkit");
-    expect(result).toEqual({ method: "info" });
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * URL decoding
- * --------------------------------------------------------------------------------------------- */
-
-describe("matchRoute — URL decoding", () => {
-  it("decodes URL-encoded agentId", () => {
-    const result = matchRoute("/api/agent/my%20agent/run", "/api");
-    expect(result).toEqual({ method: "agent/run", agentId: "my agent" });
-  });
-
-  it("decodes URL-encoded threadId", () => {
-    const result = matchRoute("/api/agent/myAgent/stop/thread%2F123", "/api");
-    expect(result).toEqual({
-      method: "agent/stop",
-      agentId: "myAgent",
-      threadId: "thread/123",
-    });
-  });
-
-  it("handles agentId with special characters", () => {
-    const result = matchRoute("/api/agent/agent%40domain.com/run", "/api");
-    expect(result).toEqual({
-      method: "agent/run",
-      agentId: "agent@domain.com",
-    });
-  });
-
-  it("handles already-decoded agentId", () => {
-    const result = matchRoute("/api/agent/simple-agent/run", "/api");
-    expect(result).toEqual({ method: "agent/run", agentId: "simple-agent" });
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * Suffix matching (no basePath)
- * --------------------------------------------------------------------------------------------- */
-
-describe("matchRoute — suffix matching (no basePath)", () => {
-  it("matches info as last segment of any path", () => {
-    const result = matchRoute("/some/deeply/nested/prefix/info");
-    expect(result).toEqual({ method: "info" });
-  });
-
-  it("matches transcribe as last segment", () => {
-    const result = matchRoute("/prefix/transcribe");
-    expect(result).toEqual({ method: "transcribe" });
-  });
-
-  it("matches agent/:id/run as trailing pattern", () => {
-    const result = matchRoute("/prefix/agent/myAgent/run");
-    expect(result).toEqual({ method: "agent/run", agentId: "myAgent" });
-  });
-
-  it("matches agent/:id/connect as trailing pattern", () => {
-    const result = matchRoute("/prefix/agent/myAgent/connect");
-    expect(result).toEqual({ method: "agent/connect", agentId: "myAgent" });
-  });
-
-  it("matches agent/:id/stop/:threadId as trailing pattern", () => {
-    const result = matchRoute("/prefix/agent/myAgent/stop/t1");
-    expect(result).toEqual({
-      method: "agent/stop",
-      agentId: "myAgent",
-      threadId: "t1",
-    });
-  });
-
-  it("returns null for no matching suffix", () => {
-    const result = matchRoute("/some/random/path/here");
-    expect(result).toBeNull();
-  });
-
-  it("returns null for empty path", () => {
-    const result = matchRoute("/");
-    expect(result).toBeNull();
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * basePath boundary matching
- * --------------------------------------------------------------------------------------------- */
-
-describe("matchRoute — basePath boundary", () => {
-  it("does not match if basePath is a prefix but not at segment boundary", () => {
-    // /apicopilotkit/info should NOT match basePath /api
-    const result = matchRoute("/apicopilotkit/info", "/api");
-    expect(result).toBeNull();
-  });
-
-  it("matches when basePath is exact prefix at segment boundary", () => {
-    const result = matchRoute("/api/info", "/api");
-    expect(result).toEqual({ method: "info" });
-  });
-
-  it("basePath matches exactly with no trailing path", () => {
-    // /api with basePath /api → remainder is "/" → no match (no known route for /)
-    const result = matchRoute("/api", "/api");
-    expect(result).toBeNull();
-  });
-
-  it("returns null when path does not start with basePath", () => {
-    const result = matchRoute("/other/info", "/api");
-    expect(result).toBeNull();
-  });
-});
-
-/* ------------------------------------------------------------------------------------------------
- * Edge cases: segments and special patterns
- * --------------------------------------------------------------------------------------------- */
-
-describe("matchRoute — segment edge cases", () => {
-  it("handles double slashes by filtering empty segments", () => {
-    // /api//info → segments: ["api", "info"] after filter(Boolean)
-    const result = matchRoute("/api//info", "/api");
-    expect(result).toEqual({ method: "info" });
-  });
-
-  it("handles path with only basePath + slash", () => {
-    const result = matchRoute("/api/", "/api");
-    expect(result).toBeNull();
-  });
-
-  it("matches with deep basePath", () => {
-    const result = matchRoute("/v1/api/copilotkit/info", "/v1/api/copilotkit");
-    expect(result).toEqual({ method: "info" });
-  });
-
-  it("matches agent route with deep basePath", () => {
-    const result = matchRoute(
-      "/v1/api/copilotkit/agent/default/run",
-      "/v1/api/copilotkit",
-    );
-    expect(result).toEqual({ method: "agent/run", agentId: "default" });
-  });
-
-  it("agentId with hyphens, underscores, and dots", () => {
-    const result = matchRoute("/api/agent/my-agent_v2.0/run", "/api");
-    expect(result).toEqual({
-      method: "agent/run",
-      agentId: "my-agent_v2.0",
-    });
-  });
-
-  it("single segment path without basePath matches info", () => {
-    const result = matchRoute("/info");
-    expect(result).toEqual({ method: "info" });
-  });
-
-  it("case-sensitive matching (INFO does not match info)", () => {
-    const result = matchRoute("/api/INFO", "/api");
-    expect(result).toBeNull();
-  });
-
-  it("case-sensitive matching (Agent vs agent)", () => {
-    const result = matchRoute("/api/Agent/default/run", "/api");
-    expect(result).toBeNull();
-  });
-});

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

@@ -1,174 +0,0 @@
-import express from "express";
-import request from "supertest";
-import { describe, expect, it, vi } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-import { Observable, of } from "rxjs";
-
-import { createCopilotEndpointExpress } from "../express";
-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("CopilotEndpointExpress routing", () => {
-  const createMockRuntime = () => {
-    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(),
-        agent123: createMockAgent(),
-        "my-agent": createMockAgent(),
-        my_agent: createMockAgent(),
-        testAgent: createMockAgent(),
-        test: createMockAgent(),
-        "test%20agent": createMockAgent(),
-        "test agent": createMockAgent(),
-      },
-      runner,
-    });
-  };
-
-  const createApp = () => {
-    const runtime = createMockRuntime();
-    const app = express();
-    app.use(createCopilotEndpointExpress({ runtime, basePath: "/" }));
-    return { app, runtime };
-  };
-
-  describe("RunAgent route pattern", () => {
-    it("matches simple agent name", 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("matches hyphenated agent name", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/agent/my-agent/run")
-        .set("Content-Type", "application/json")
-        .send({
-          messages: [],
-          state: {},
-          threadId: "thread-1",
-        });
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("matches underscored agent name", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/agent/my_agent/run")
-        .set("Content-Type", "application/json")
-        .send({
-          messages: [],
-          state: {},
-          threadId: "thread-1",
-        });
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("returns 404 for empty agent name", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/agent//run")
-        .set("Content-Type", "application/json")
-        .send({
-          messages: [],
-          state: {},
-          threadId: "thread-1",
-        });
-
-      expect(response.status).toBe(404);
-    });
-  });
-
-  describe("Runtime info route", () => {
-    it("returns 200 for /info", async () => {
-      const { app } = createApp();
-      const response = await request(app).get("/info");
-
-      expect(response.status).toBe(200);
-      expect(response.body).toHaveProperty("version");
-    });
-
-    it("returns 404 for non-info path", async () => {
-      const { app } = createApp();
-      const response = await request(app).get("/agents");
-
-      expect(response.status).toBe(404);
-    });
-  });
-
-  describe("Transcribe route", () => {
-    it("matches /transcribe", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/transcribe")
-        .set("Content-Type", "application/json")
-        .send({});
-
-      expect(response.status).not.toBe(404);
-    });
-  });
-
-  describe("Unmatched routes", () => {
-    it("returns 404 for root path", async () => {
-      const { app } = createApp();
-      const response = await request(app).get("/");
-
-      expect(response.status).toBe(404);
-    });
-
-    it("returns 404 for unknown paths", async () => {
-      const { app } = createApp();
-      const response = await request(app).get("/unknown/path");
-
-      expect(response.status).toBe(404);
-    });
-  });
-});

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

@@ -1,168 +0,0 @@
-import express from "express";
-import request from "supertest";
-import { describe, expect, it, vi } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-import { Observable, of } from "rxjs";
-
-import { createCopilotEndpointSingleRouteExpress } from "../express";
-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("CopilotEndpointSingleRouteExpress routing", () => {
-  const createMockRuntime = () => {
-    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(),
-        agent123: createMockAgent(),
-        "my-agent": createMockAgent(),
-        my_agent: createMockAgent(),
-        testAgent: createMockAgent(),
-        test: createMockAgent(),
-        "test%20agent": createMockAgent(),
-        "test agent": createMockAgent(),
-      },
-      runner,
-    });
-  };
-
-  const createApp = () => {
-    const runtime = createMockRuntime();
-    const app = express();
-    app.use(
-      createCopilotEndpointSingleRouteExpress({ runtime, basePath: "/rpc" }),
-    );
-    return { app, runtime };
-  };
-
-  const postRpc = (app: express.Express, payload: Record<string, unknown>) => {
-    return request(app)
-      .post("/rpc")
-      .set("Content-Type", "application/json")
-      .send(payload);
-  };
-
-  describe("agent/run method", () => {
-    it("accepts simple agent names", async () => {
-      const { app } = createApp();
-      const response = await postRpc(app, {
-        method: "agent/run",
-        params: { agentId: "myAgent" },
-        body: {
-          messages: [],
-          state: {},
-          threadId: "thread-1",
-        },
-      });
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("returns 400 when agentId missing", async () => {
-      const { app } = createApp();
-      const response = await postRpc(app, {
-        method: "agent/run",
-        body: {},
-      });
-
-      expect(response.status).toBe(400);
-    });
-  });
-
-  describe("agent/stop method", () => {
-    it("requires threadId", async () => {
-      const { app } = createApp();
-      const response = await postRpc(app, {
-        method: "agent/stop",
-        params: { agentId: "agent123" },
-      });
-
-      expect(response.status).toBe(400);
-    });
-  });
-
-  describe("info method", () => {
-    it("returns runtime info", async () => {
-      const { app } = createApp();
-      const response = await postRpc(app, { method: "info" });
-
-      expect(response.status).toBe(200);
-      expect(response.body).toHaveProperty("version");
-    });
-
-    it("handles query parameters", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/rpc?foo=bar")
-        .set("Content-Type", "application/json")
-        .send({ method: "info" });
-
-      expect(response.status).toBe(200);
-    });
-  });
-
-  describe("invalid inputs", () => {
-    it("returns 415 for non-JSON content", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/rpc")
-        .set("Content-Type", "text/plain")
-        .send("method=info");
-
-      expect(response.status).toBe(415);
-    });
-
-    it("returns 400 for unsupported method", async () => {
-      const { app } = createApp();
-      const response = await postRpc(app, { method: "unknown" });
-
-      expect(response.status).toBe(400);
-    });
-
-    it("returns 404 for unmatched path", async () => {
-      const { app } = createApp();
-      const response = await request(app)
-        .post("/other")
-        .set("Content-Type", "application/json")
-        .send({ method: "info" });
-
-      expect(response.status).toBe(404);
-    });
-  });
-});