@copilotkit/runtime 1.56.3 → 1.56.4-canary.1777529757

package/src/v2/runtime/__tests__/express-telemetry.integration.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Integration test: Express adapter + telemetry.
+ */
+import express from "express";
+import request from "supertest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { AbstractAgent } from "@ag-ui/client";
+import { Observable, of } from "rxjs";
+
+import { telemetry } from "../telemetry";
+import { createCopilotExpressHandler } from "../endpoints/express";
+import { CopilotRuntime } from "../core/runtime";
+
+function makeAgent(): AbstractAgent {
+  const a: unknown = { execute: async () => ({ events: [] }) };
+  (a as { clone: () => unknown }).clone = () => makeAgent();
+  return a as AbstractAgent;
+}
+
+function makeRuntime() {
+  const runner = {
+    run: () =>
+      new Observable((observer) => {
+        observer.next({});
+        observer.complete();
+        return () => undefined;
+      }),
+    connect: () => of({}),
+    stop: async () => true,
+  };
+  return new CopilotRuntime({
+    agents: { default: makeAgent() },
+    runner,
+  });
+}
+
+describe("Express adapter — telemetry firing (integration)", () => {
+  let captureSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    captureSpy = vi.spyOn(telemetry, "capture").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    captureSpy.mockRestore();
+  });
+
+  it("fires instance_created on handler creation (multi-route)", async () => {
+    const runtime = makeRuntime();
+    createCopilotExpressHandler({ runtime, basePath: "/" });
+
+    await vi.waitFor(() => {
+      expect(captureSpy).toHaveBeenCalledWith(
+        "oss.runtime.instance_created",
+        expect.objectContaining({
+          agentsAmount: 1,
+          "cloud.api_key_provided": false,
+        }),
+      );
+    });
+  });
+
+  it("fires copilot_request_created when a real HTTP request hits the handler", async () => {
+    const runtime = makeRuntime();
+    const app = express();
+    app.use(createCopilotExpressHandler({ runtime, basePath: "/" }));
+
+    await request(app)
+      .post("/agent/default/run")
+      .set("Content-Type", "application/json")
+      .send({ messages: [], state: {}, threadId: "t1" });
+
+    expect(captureSpy).toHaveBeenCalledWith(
+      "oss.runtime.copilot_request_created",
+      expect.objectContaining({
+        requestType: "run",
+        "cloud.api_key_provided": false,
+      }),
+    );
+  });
+
+  it("includes cloud.public_api_key on request when header is present", async () => {
+    const runtime = makeRuntime();
+    const app = express();
+    app.use(createCopilotExpressHandler({ runtime, basePath: "/" }));
+
+    await request(app)
+      .post("/agent/default/run")
+      .set("Content-Type", "application/json")
+      .set("x-copilotcloud-public-api-key", "ck_pub_test_xyz")
+      .send({ messages: [], state: {}, threadId: "t1" });
+
+    expect(captureSpy).toHaveBeenCalledWith(
+      "oss.runtime.copilot_request_created",
+      expect.objectContaining({
+        "cloud.api_key_provided": true,
+        "cloud.public_api_key": "ck_pub_test_xyz",
+      }),
+    );
+  });
+});

package/src/v2/runtime/__tests__/handle-connect.test.ts

@@ -231,17 +231,18 @@ describe("handleConnectAgent", () => {
         identifyUser: vi
           .fn()
           .mockResolvedValue({ id: "user-1", name: "User One" }),
-        intelligence: platform,
+        intelligence: {
+          ɵgetClientWsUrl: vi.fn(() => "wss://runtime.example/client"),
+          ...platform,
+        },
       } as unknown as CopilotRuntime;
     };
 
-    it("returns a live connect plan when join credentials are available", async () => {
+    it("returns runtime websocket connection credentials when available", async () => {
       const platform = {
         ɵconnectThread: vi.fn().mockResolvedValue({
-          mode: "live",
+          threadId: "thread-1",
           joinToken: "jt-connect-1",
-          joinFromEventId: "event-1",
-          events: [],
         }),
       };
       const runtime = createIntelligenceRuntime(platform);
@@ -256,33 +257,25 @@ describe("handleConnectAgent", () => {
       expect(response.headers.get("Content-Type")).toBe("application/json");
       const body = await response.json();
       expect(body).toEqual({
-        mode: "live",
+        threadId: "thread-1",
         joinToken: "jt-connect-1",
-        joinFromEventId: "event-1",
-        events: [],
+        realtime: {
+          clientUrl: "wss://runtime.example/client",
+          topic: "thread:thread-1",
+        },
       });
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "user-1",
-        runId: "run-1",
-        lastSeenEventId: null,
+        agentId: "my-agent",
       });
     });
 
-    it("returns a bootstrap connect plan when no socket is needed", async () => {
+    it("does not restamp historical replay plans during connect", async () => {
       const platform = {
         ɵconnectThread: vi.fn().mockResolvedValue({
-          mode: "bootstrap",
-          latestEventId: "event-2",
-          events: [
-            {
-              type: "RUN_STARTED",
-              threadId: "thread-1",
-              run_id: "backend-run-1",
-              input: { messages: [] },
-            },
-            { type: "RUN_FINISHED" },
-          ],
+          threadId: "thread-1",
+          joinToken: "jt-connect-1",
         }),
       };
       const runtime = createIntelligenceRuntime(platform);
@@ -296,25 +289,12 @@ describe("handleConnectAgent", () => {
       expect(response.status).toBe(200);
       const body = await response.json();
       expect(body).toEqual({
-        mode: "bootstrap",
-        latestEventId: "event-2",
-        events: [
-          {
-            type: "RUN_STARTED",
-            threadId: "thread-1",
-            runId: "run-1",
-            input: {
-              messages: [],
-              threadId: "thread-1",
-              runId: "run-1",
-            },
-          },
-          {
-            type: "RUN_FINISHED",
-            threadId: "thread-1",
-            runId: "run-1",
-          },
-        ],
+        threadId: "thread-1",
+        joinToken: "jt-connect-1",
+        realtime: {
+          clientUrl: "wss://runtime.example/client",
+          topic: "thread:thread-1",
+        },
       });
     });
 
@@ -337,8 +317,7 @@ describe("handleConnectAgent", () => {
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "user-1",
-        runId: "run-1",
-        lastSeenEventId: null,
+        agentId: "my-agent",
       });
     });
 
@@ -361,7 +340,73 @@ describe("handleConnectAgent", () => {
       expect(body.error).toBe("Connect plan not available");
     });
 
-    it("forwards lastSeenEventId to the intelligence platform", async () => {
+    it("preserves platform not found errors when connect fails with 404", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockRejectedValue(
+          Object.assign(new Error("Intelligence platform error 404"), {
+            status: 404,
+          }),
+        ),
+      };
+      const runtime = createIntelligenceRuntime(platform);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(404);
+      const body = await response.json();
+      expect(body).toEqual({
+        error: "Connect request rejected",
+        message: "Intelligence platform error 404",
+      });
+    });
+
+    it("preserves platform validation errors when connect fails validation", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockRejectedValue(
+          Object.assign(new Error("Intelligence platform error 400"), {
+            status: 400,
+          }),
+        ),
+      };
+      const runtime = createIntelligenceRuntime(platform);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(400);
+      const body = await response.json();
+      expect(body.error).toBe("Connect request rejected");
+    });
+
+    it("preserves platform ownership conflicts when connect fails authorization", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockRejectedValue(
+          Object.assign(new Error("Intelligence platform error 403"), {
+            status: 403,
+          }),
+        ),
+      };
+      const runtime = createIntelligenceRuntime(platform);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(403);
+      const body = await response.json();
+      expect(body.error).toBe("Connect request rejected");
+    });
+
+    it("does not forward replay cursors to the credentials-only intelligence platform connect", async () => {
       const platform = {
         ɵconnectThread: vi.fn().mockResolvedValue(null),
       };
@@ -377,8 +422,7 @@ describe("handleConnectAgent", () => {
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "user-1",
-        runId: "run-1",
-        lastSeenEventId: "event-9",
+        agentId: "my-agent",
       });
     });
 
@@ -408,8 +452,7 @@ describe("handleConnectAgent", () => {
       expect(platform.ɵconnectThread).toHaveBeenCalledWith({
         threadId: "thread-1",
         userId: "resolved-user",
-        runId: "run-1",
-        lastSeenEventId: "event-9",
+        agentId: "my-agent",
       });
     });
 
@@ -475,4 +518,68 @@ describe("handleConnectAgent", () => {
       }
     });
   });
+
+  describe("telemetry", () => {
+    it("captures oss.runtime.copilot_request_created on every invocation", async () => {
+      const { telemetry } = await import("../telemetry");
+      const captureSpy = vi
+        .spyOn(telemetry, "capture")
+        .mockResolvedValue(undefined);
+
+      try {
+        const runtime = createMockRuntime({});
+        const request = new Request("https://example.com/agent/test/connect", {
+          method: "POST",
+        });
+        await handleConnectAgent({
+          runtime,
+          request,
+          agentId: "nonexistent-agent",
+        });
+
+        expect(captureSpy).toHaveBeenCalledWith(
+          "oss.runtime.copilot_request_created",
+          expect.objectContaining({
+            requestType: "connect",
+            "cloud.api_key_provided": false,
+          }),
+        );
+      } finally {
+        captureSpy.mockRestore();
+      }
+    });
+
+    it("includes cloud.public_api_key when x-copilotcloud-public-api-key header is set", async () => {
+      const { telemetry } = await import("../telemetry");
+      const captureSpy = vi
+        .spyOn(telemetry, "capture")
+        .mockResolvedValue(undefined);
+
+      try {
+        const runtime = createMockRuntime({});
+        const request = new Request("https://example.com/agent/test/connect", {
+          method: "POST",
+          headers: {
+            "x-copilotcloud-public-api-key": "ck_pub_connect_test",
+          },
+        });
+
+        await handleConnectAgent({
+          runtime,
+          request,
+          agentId: "nonexistent-agent",
+        });
+
+        expect(captureSpy).toHaveBeenCalledWith(
+          "oss.runtime.copilot_request_created",
+          expect.objectContaining({
+            "cloud.api_key_provided": true,
+            "cloud.public_api_key": "ck_pub_connect_test",
+          }),
+        );
+      } finally {
+        captureSpy.mockRestore();
+      }
+    });
+  });
 });