@copilotkit/runtime 1.55.0-next.9 → 1.55.1-next.0

package/src/v2/runtime/__tests__/backward-compat.test.ts

@@ -0,0 +1,261 @@
+import express from "express";
+import request from "supertest";
+import { describe, it, expect, vi } from "vitest";
+import type { AbstractAgent } from "@ag-ui/client";
+import { Observable, of } from "rxjs";
+
+import {
+  createCopilotEndpoint,
+  createCopilotEndpointSingleRoute,
+} from "../endpoints";
+import { createCopilotEndpointExpress } from "../express";
+import { createCopilotEndpointSingleRouteExpress } from "../endpoints/express-single";
+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("Backward compatibility", () => {
+  const createMockAgent = () => {
+    const agent: unknown = {
+      execute: async () => ({ events: [] }),
+    };
+    (agent as { clone: () => unknown }).clone = () => createMockAgent();
+    return agent as AbstractAgent;
+  };
+
+  const createMockRuntime = (opts?: Partial<CopilotRuntime>) => {
+    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(),
+      },
+      runner,
+      ...opts,
+    });
+  };
+
+  /* ---------------------------------------------------------------------------
+   * APIs work without hooks parameter
+   * -------------------------------------------------------------------------- */
+
+  describe("APIs work without hooks parameter", () => {
+    it("createCopilotEndpoint still works without hooks parameter (routes /info)", async () => {
+      const runtime = createMockRuntime();
+      const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+      const response = await endpoint.fetch(
+        new Request("https://example.com/info"),
+      );
+
+      expect(response.status).toBe(200);
+      const body = await response.json();
+      expect(body).toHaveProperty("version");
+    });
+
+    it("createCopilotEndpointExpress still works without hooks parameter (routes /info)", async () => {
+      const runtime = createMockRuntime();
+      const app = express();
+      app.use(createCopilotEndpointExpress({ runtime, basePath: "/" }));
+
+      const response = await request(app).get("/info");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty("version");
+    });
+
+    it("createCopilotEndpointSingleRoute still works without hooks parameter", async () => {
+      const runtime = createMockRuntime();
+      const endpoint = createCopilotEndpointSingleRoute({
+        runtime,
+        basePath: "/rpc",
+      });
+
+      const response = await endpoint.fetch(
+        new Request("https://example.com/rpc", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ method: "info" }),
+        }),
+      );
+
+      expect(response.status).toBe(200);
+      const body = await response.json();
+      expect(body).toHaveProperty("version");
+    });
+
+    it("createCopilotEndpointSingleRouteExpress still works without hooks parameter", async () => {
+      const runtime = createMockRuntime();
+      const app = express();
+      app.use(
+        createCopilotEndpointSingleRouteExpress({
+          runtime,
+          basePath: "/rpc",
+        }),
+      );
+
+      const response = await request(app)
+        .post("/rpc")
+        .set("Content-Type", "application/json")
+        .send({ method: "info" });
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty("version");
+    });
+  });
+
+  /* ---------------------------------------------------------------------------
+   * Adding hooks doesn't break routing
+   * -------------------------------------------------------------------------- */
+
+  describe("adding hooks does not break routing", () => {
+    it("Hono endpoint with hooks still routes /info", async () => {
+      const runtime = createMockRuntime();
+      const onRequest = vi.fn();
+      const endpoint = createCopilotEndpoint({
+        runtime,
+        basePath: "/",
+        hooks: { onRequest },
+      });
+
+      const response = await endpoint.fetch(
+        new Request("https://example.com/info"),
+      );
+
+      expect(response.status).toBe(200);
+      const body = await response.json();
+      expect(body).toHaveProperty("version");
+      expect(onRequest).toHaveBeenCalled();
+    });
+
+    it("Hono endpoint with hooks still routes POST /agent/:id/run", async () => {
+      const runtime = createMockRuntime();
+      const onBeforeHandler = vi.fn();
+      const endpoint = createCopilotEndpoint({
+        runtime,
+        basePath: "/",
+        hooks: { onBeforeHandler },
+      });
+
+      const response = await endpoint.fetch(
+        new Request("https://example.com/agent/default/run", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            messages: [],
+            state: {},
+            threadId: "thread-1",
+          }),
+        }),
+      );
+
+      expect(response.status).not.toBe(404);
+      expect(onBeforeHandler).toHaveBeenCalledWith(
+        expect.objectContaining({
+          route: expect.objectContaining({
+            method: "agent/run",
+            agentId: "default",
+          }),
+        }),
+      );
+    });
+
+    it("Express endpoint with hooks still routes /info", async () => {
+      const runtime = createMockRuntime();
+      const onRequest = vi.fn();
+      const app = express();
+      app.use(
+        createCopilotEndpointExpress({
+          runtime,
+          basePath: "/",
+          hooks: { onRequest },
+        }),
+      );
+
+      const response = await request(app).get("/info");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty("version");
+      expect(onRequest).toHaveBeenCalled();
+    });
+  });
+
+  /* ---------------------------------------------------------------------------
+   * Legacy middleware still executes
+   * -------------------------------------------------------------------------- */
+
+  describe("CopilotRuntime legacy middleware still executes", () => {
+    it("beforeRequestMiddleware is called", async () => {
+      const beforeCalls: string[] = [];
+      const beforeRequestMiddleware = vi.fn().mockImplementation(() => {
+        beforeCalls.push("before-called");
+      });
+
+      const runtime = createMockRuntime({ beforeRequestMiddleware });
+      const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+      await endpoint.fetch(new Request("https://example.com/info"));
+
+      expect(beforeRequestMiddleware).toHaveBeenCalledTimes(1);
+      expect(beforeRequestMiddleware).toHaveBeenCalledWith(
+        expect.objectContaining({
+          runtime,
+          request: expect.any(Request),
+          path: expect.stringContaining("/info"),
+        }),
+      );
+      expect(beforeCalls).toEqual(["before-called"]);
+    });
+
+    it("afterRequestMiddleware is called", async () => {
+      const afterCalls: string[] = [];
+      const afterRequestMiddleware = vi.fn().mockImplementation(() => {
+        afterCalls.push("after-called");
+      });
+
+      const runtime = createMockRuntime({ afterRequestMiddleware });
+      const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+      await endpoint.fetch(new Request("https://example.com/info"));
+
+      // afterRequestMiddleware is fire-and-forget; give it a tick
+      await new Promise((r) => setTimeout(r, 20));
+
+      expect(afterRequestMiddleware).toHaveBeenCalledTimes(1);
+      expect(afterRequestMiddleware).toHaveBeenCalledWith(
+        expect.objectContaining({
+          runtime,
+          response: expect.any(Response),
+          path: expect.stringContaining("/info"),
+        }),
+      );
+      expect(afterCalls).toEqual(["after-called"]);
+    });
+  });
+});