@copilotkit/runtime 1.54.1 → 1.55.0-next.7

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

@@ -0,0 +1,168 @@
+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 "../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);
+    });
+  });
+});

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

@@ -0,0 +1,193 @@
+import { describe, it, expect } from "vitest";
+import type { AbstractAgent } from "@ag-ui/client";
+
+import { createCopilotEndpointSingleRoute } from "../endpoints";
+import { CopilotRuntime } from "../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

@@ -0,0 +1,257 @@
+import { createCopilotEndpoint } from "../endpoints";
+import { CopilotRuntime } from "../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);
+    });
+  });
+});