@copilotkit/runtime 1.54.1 → 1.55.0-next.8

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

@@ -0,0 +1,122 @@
+import express from "express";
+import type { AddressInfo } from "node:net";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { createCopilotEndpointSingleRouteExpress } from "../express";
+import { CopilotRuntime } from "../runtime";
+import { InMemoryAgentRunner } from "../runner/in-memory";
+
+const buildRuntime = () => {
+  const fakeAgent = {
+    clone: () => ({
+      setMessages: () => undefined,
+      setState: () => undefined,
+      threadId: "thread",
+      runAgent: async (
+        input: { runId: string },
+        { onEvent }: { onEvent: (payload: { event: unknown }) => void },
+      ) => {
+        onEvent({
+          event: {
+            type: "RUN_STARTED",
+            runId: input.runId,
+            input: { runId: input.runId },
+          },
+        });
+        onEvent({ event: { type: "TEXT_MESSAGE_START", messageId: "m1" } });
+        onEvent({
+          event: {
+            type: "TEXT_MESSAGE_CONTENT",
+            messageId: "m1",
+            delta: "hello",
+          },
+        });
+        onEvent({ event: { type: "TEXT_MESSAGE_END", messageId: "m1" } });
+        onEvent({ event: { type: "RUN_FINISHED", runId: input.runId } });
+      },
+    }),
+  };
+
+  return new CopilotRuntime({
+    agents: { default: fakeAgent },
+    runner: new InMemoryAgentRunner(),
+  });
+};
+
+async function readStreamText(
+  stream: ReadableStream<Uint8Array>,
+): Promise<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let output = "";
+
+  for (let i = 0; i < 20; i += 1) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    if (value) {
+      output += decoder.decode(value, { stream: true });
+      if (output.includes("RUN_FINISHED")) {
+        break;
+      }
+    }
+  }
+
+  await reader.cancel();
+  output += decoder.decode();
+  return output;
+}
+
+describe("Express single-route SSE streaming", () => {
+  let server: ReturnType<express.Express["listen"]> | undefined;
+
+  afterEach(() => {
+    if (server) {
+      server.close();
+      server = undefined;
+    }
+  });
+
+  it("streams SSE events for single-route run requests", async () => {
+    const runtime = buildRuntime();
+    const app = express();
+    app.use(
+      createCopilotEndpointSingleRouteExpress({ runtime, basePath: "/" }),
+    );
+
+    server = app.listen(0);
+    const { port } = server.address() as AddressInfo;
+
+    const response = await fetch(`http://localhost:${port}/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream",
+      },
+      body: JSON.stringify({
+        method: "agent/run",
+        params: { agentId: "default" },
+        body: {
+          threadId: "thread",
+          runId: "run-1",
+          messages: [],
+          state: {},
+          tools: [],
+          context: [],
+          forwardedProps: {},
+        },
+      }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type")).toContain("text/event-stream");
+    expect(response.body).toBeTruthy();
+
+    const payload = await readStreamText(response.body!);
+    expect(payload).toContain("data:");
+    expect(payload).toContain("RUN_STARTED");
+    expect(payload).toContain("TEXT_MESSAGE_CONTENT");
+    expect(payload).toContain("RUN_FINISHED");
+  });
+});

package/src/v2/runtime/__tests__/get-runtime-info.test.ts

@@ -0,0 +1,141 @@
+import { handleGetRuntimeInfo } from "../handlers/get-runtime-info";
+import { CopilotRuntime } from "../runtime";
+import { TranscriptionService } from "../transcription-service/transcription-service";
+import { describe, it, expect } from "vitest";
+import type { AbstractAgent } from "@ag-ui/client";
+
+// Mock transcription service
+class MockTranscriptionService extends TranscriptionService {
+  async transcribeFile(): Promise<string> {
+    return "Mock transcription result";
+  }
+}
+
+describe("handleGetRuntimeInfo", () => {
+  const mockRequest = new Request("https://example.com/info");
+
+  it("should return runtime info with audioFileTranscriptionEnabled=false when no transcription service", async () => {
+    const runtime = new CopilotRuntime({
+      agents: {},
+      // No transcriptionService provided
+    });
+
+    const response = await handleGetRuntimeInfo({
+      runtime,
+      request: mockRequest,
+    });
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+    expect(data).toEqual({
+      version: expect.any(String),
+      agents: {},
+      audioFileTranscriptionEnabled: false,
+      mode: "sse",
+      a2uiEnabled: false,
+    });
+  });
+
+  it("should return runtime info with audioFileTranscriptionEnabled=true when transcription service is configured", async () => {
+    const mockTranscriptionService = new MockTranscriptionService();
+    const runtime = new CopilotRuntime({
+      agents: {},
+      transcriptionService: mockTranscriptionService,
+    });
+
+    const response = await handleGetRuntimeInfo({
+      runtime,
+      request: mockRequest,
+    });
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+    expect(data).toEqual({
+      version: expect.any(String),
+      agents: {},
+      audioFileTranscriptionEnabled: true,
+      mode: "sse",
+      a2uiEnabled: false,
+    });
+  });
+
+  it("should include agents information along with audioFileTranscriptionEnabled", async () => {
+    const mockAgent = {
+      description: "Test agent description",
+      constructor: { name: "TestAgent" },
+    };
+
+    const runtime = new CopilotRuntime({
+      agents: {
+        testAgent: mockAgent as AbstractAgent,
+      },
+      transcriptionService: new MockTranscriptionService(),
+    });
+
+    const response = await handleGetRuntimeInfo({
+      runtime,
+      request: mockRequest,
+    });
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+    expect(data).toEqual({
+      version: expect.any(String),
+      agents: {
+        testAgent: {
+          name: "testAgent",
+          description: "Test agent description",
+          className: "TestAgent",
+        },
+      },
+      audioFileTranscriptionEnabled: true,
+      mode: "sse",
+      a2uiEnabled: false,
+    });
+  });
+
+  it("should return a2uiEnabled: true when runtime has a2ui configured", async () => {
+    const runtime = new CopilotRuntime({
+      agents: {},
+      a2ui: {},
+    });
+
+    const response = await handleGetRuntimeInfo({
+      runtime,
+      request: mockRequest,
+    });
+
+    expect(response.status).toBe(200);
+
+    const data = await response.json();
+    expect(data.a2uiEnabled).toBe(true);
+  });
+
+  it("should return 500 error when runtime.agents throws an error", async () => {
+    const runtime = {
+      get agents(): Record<string, AbstractAgent> {
+        throw new Error("Failed to get agents");
+      },
+      transcriptionService: undefined,
+      beforeRequestMiddleware: undefined,
+      afterRequestMiddleware: undefined,
+      mode: "sse",
+    } as CopilotRuntime;
+
+    const response = await handleGetRuntimeInfo({
+      runtime,
+      request: mockRequest,
+    });
+
+    expect(response.status).toBe(500);
+
+    const data = await response.json();
+    expect(data).toEqual({
+      error: "Failed to retrieve runtime information",
+      message: "Failed to get agents",
+    });
+  });
+});

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

@@ -0,0 +1,423 @@
+import { Observable } from "rxjs";
+import { describe, it, expect, vi } from "vitest";
+import { BaseEvent } from "@ag-ui/client";
+import { handleConnectAgent } from "../handlers/handle-connect";
+import { CopilotRuntime } from "../runtime";
+import { AgentRunnerConnectRequest } from "../runner/agent-runner";
+import { IntelligenceAgentRunner } from "../runner/intelligence";
+import { CopilotKitIntelligence } from "../intelligence-platform/client";
+
+describe("handleConnectAgent", () => {
+  const createMockRuntime = (
+    agents: Record<string, unknown> = {},
+    connectHandler?: (
+      request: AgentRunnerConnectRequest,
+    ) => Observable<BaseEvent>,
+  ): CopilotRuntime => {
+    return {
+      agents: Promise.resolve(agents),
+      transcriptionService: undefined,
+      beforeRequestMiddleware: undefined,
+      afterRequestMiddleware: undefined,
+      runner: {
+        run: () =>
+          new Observable<BaseEvent>((subscriber) => {
+            subscriber.complete();
+          }),
+        connect:
+          connectHandler ??
+          (() =>
+            new Observable<BaseEvent>((subscriber) => {
+              subscriber.complete();
+            })),
+        isRunning: async () => false,
+        stop: async () => false,
+      },
+    } as CopilotRuntime;
+  };
+
+  it("should return 404 when agent does not exist", async () => {
+    const runtime = createMockRuntime({});
+    const request = new Request(
+      "https://example.com/agent/nonexistent/connect",
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          threadId: "thread-1",
+          runId: "run-1",
+          state: {},
+          messages: [],
+          tools: [],
+          context: [],
+          forwardedProps: {},
+        }),
+      },
+    );
+
+    const response = await handleConnectAgent({
+      runtime,
+      request,
+      agentId: "nonexistent-agent",
+    });
+
+    expect(response.status).toBe(404);
+    expect(response.headers.get("Content-Type")).toBe("application/json");
+
+    const body = await response.json();
+    expect(body).toEqual({
+      error: "Agent not found",
+      message: "Agent 'nonexistent-agent' does not exist",
+    });
+  });
+
+  it("forwards only authorization and custom x- headers to runner.connect()", async () => {
+    const recordedRequests: AgentRunnerConnectRequest[] = [];
+    let resolveConnect: (() => void) | undefined;
+    const connectInvoked = new Promise<void>((resolve) => {
+      resolveConnect = resolve;
+    });
+
+    const runtime = createMockRuntime(
+      { "test-agent": { clone: () => ({}) } },
+      (request: AgentRunnerConnectRequest) =>
+        new Observable<BaseEvent>((subscriber) => {
+          recordedRequests.push(request);
+          resolveConnect?.();
+          subscriber.complete();
+        }),
+    );
+
+    const requestBody = {
+      threadId: "thread-1",
+      runId: "run-1",
+      state: {},
+      messages: [],
+      tools: [],
+      context: [],
+      forwardedProps: {},
+    };
+
+    const request = new Request(
+      "https://example.com/agent/test-agent/connect",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Custom": "custom-value",
+          "X-Another-Header": "another-value",
+          Authorization: "Bearer forwarded-token",
+          Origin: "http://localhost:4200",
+          "User-Agent": "test-agent",
+        },
+        body: JSON.stringify(requestBody),
+      },
+    );
+
+    const response = await handleConnectAgent({
+      runtime,
+      request,
+      agentId: "test-agent",
+    });
+
+    expect(response.status).toBe(200);
+    await connectInvoked;
+
+    expect(recordedRequests).toHaveLength(1);
+    expect(recordedRequests[0].threadId).toBe("thread-1");
+    expect(recordedRequests[0].headers).toMatchObject({
+      authorization: "Bearer forwarded-token",
+      "x-custom": "custom-value",
+      "x-another-header": "another-value",
+    });
+    expect(recordedRequests[0].headers).not.toHaveProperty("origin");
+    expect(recordedRequests[0].headers).not.toHaveProperty("content-type");
+    expect(recordedRequests[0].headers).not.toHaveProperty("user-agent");
+  });
+
+  it("passes empty headers object when no forwardable headers present", async () => {
+    const recordedRequests: AgentRunnerConnectRequest[] = [];
+    let resolveConnect: (() => void) | undefined;
+    const connectInvoked = new Promise<void>((resolve) => {
+      resolveConnect = resolve;
+    });
+
+    const runtime = createMockRuntime(
+      { "test-agent": { clone: () => ({}) } },
+      (request: AgentRunnerConnectRequest) =>
+        new Observable<BaseEvent>((subscriber) => {
+          recordedRequests.push(request);
+          resolveConnect?.();
+          subscriber.complete();
+        }),
+    );
+
+    const requestBody = {
+      threadId: "thread-1",
+      runId: "run-1",
+      state: {},
+      messages: [],
+      tools: [],
+      context: [],
+      forwardedProps: {},
+    };
+
+    const request = new Request(
+      "https://example.com/agent/test-agent/connect",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Origin: "http://localhost:4200",
+        },
+        body: JSON.stringify(requestBody),
+      },
+    );
+
+    const response = await handleConnectAgent({
+      runtime,
+      request,
+      agentId: "test-agent",
+    });
+
+    expect(response.status).toBe(200);
+    await connectInvoked;
+
+    expect(recordedRequests).toHaveLength(1);
+    expect(recordedRequests[0].headers).toEqual({});
+  });
+
+  describe("IntelligenceAgentRunner connect planning path", () => {
+    const createConnectRequest = (
+      headers?: Record<string, string>,
+      lastSeenEventId?: string | null,
+    ) =>
+      new Request("https://example.com/agent/my-agent/connect", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...headers },
+        body: JSON.stringify({
+          threadId: "thread-1",
+          runId: "run-1",
+          state: {},
+          messages: [],
+          tools: [],
+          context: [],
+          forwardedProps: {},
+          ...(lastSeenEventId !== undefined ? { lastSeenEventId } : {}),
+        }),
+      });
+
+    const createIntelligenceRuntime = (
+      platform?: Partial<CopilotKitIntelligence>,
+    ) => {
+      const runner = Object.create(IntelligenceAgentRunner.prototype);
+      runner.connect = vi.fn(
+        () =>
+          new Observable<BaseEvent>((subscriber) => {
+            subscriber.complete();
+          }),
+      );
+      return {
+        agents: Promise.resolve({
+          "my-agent": { clone: () => ({}) },
+        }),
+        transcriptionService: undefined,
+        beforeRequestMiddleware: undefined,
+        afterRequestMiddleware: undefined,
+        runner,
+        mode: "intelligence",
+        identifyUser: vi.fn().mockResolvedValue({ id: "user-1" }),
+        intelligence: platform,
+      } as unknown as CopilotRuntime;
+    };
+
+    it("returns a live connect plan when join credentials are available", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockResolvedValue({
+          mode: "live",
+          joinToken: "jt-connect-1",
+          joinFromEventId: "event-1",
+          events: [],
+        }),
+      };
+      const runtime = createIntelligenceRuntime(platform as any);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(200);
+      expect(response.headers.get("Content-Type")).toBe("application/json");
+      const body = await response.json();
+      expect(body).toEqual({
+        mode: "live",
+        joinToken: "jt-connect-1",
+        joinFromEventId: "event-1",
+        events: [],
+      });
+      expect(platform.ɵconnectThread).toHaveBeenCalledWith({
+        threadId: "thread-1",
+        userId: "user-1",
+        lastSeenEventId: null,
+      });
+    });
+
+    it("returns a bootstrap connect plan when no socket is needed", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockResolvedValue({
+          mode: "bootstrap",
+          latestEventId: "event-2",
+          events: [{ type: "MESSAGES_SNAPSHOT", messages: [] }],
+        }),
+      };
+      const runtime = createIntelligenceRuntime(platform as any);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(200);
+      const body = await response.json();
+      expect(body).toEqual({
+        mode: "bootstrap",
+        latestEventId: "event-2",
+        events: [{ type: "MESSAGES_SNAPSHOT", messages: [] }],
+      });
+    });
+
+    it("returns 204 when connect targets a fresh thread", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockResolvedValue(null),
+        createThread: vi.fn(),
+      };
+      const runtime = createIntelligenceRuntime(platform as any);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(204);
+      expect(platform.createThread).not.toHaveBeenCalled();
+      expect(platform.ɵconnectThread).toHaveBeenCalledTimes(1);
+      expect(platform.ɵconnectThread).toHaveBeenCalledWith({
+        threadId: "thread-1",
+        userId: "user-1",
+        lastSeenEventId: null,
+      });
+    });
+
+    it("returns 404 when connect planning is not available", async () => {
+      const platform = {
+        ɵconnectThread: vi
+          .fn()
+          .mockRejectedValue(new Error("No active connect plan")),
+      };
+      const runtime = createIntelligenceRuntime(platform as any);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(404);
+      const body = await response.json();
+      expect(body.error).toBe("Connect plan not available");
+    });
+
+    it("forwards lastSeenEventId to the intelligence platform", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockResolvedValue(null),
+      };
+      const runtime = createIntelligenceRuntime(platform as any);
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(undefined, "event-9"),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(204);
+      expect(platform.ɵconnectThread).toHaveBeenCalledWith({
+        threadId: "thread-1",
+        userId: "user-1",
+        lastSeenEventId: "event-9",
+      });
+    });
+
+    it("uses identifyUser instead of a conflicting X-User-Id header", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn().mockResolvedValue(null),
+      };
+      const identifyUser = vi.fn().mockResolvedValue({ id: "resolved-user" });
+      const runtime = createIntelligenceRuntime(platform as any);
+      runtime.identifyUser = identifyUser;
+      const request = createConnectRequest(
+        { "X-User-Id": "legacy-user" },
+        "event-9",
+      );
+
+      const response = await handleConnectAgent({
+        runtime,
+        request,
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(204);
+      expect(identifyUser).toHaveBeenCalledTimes(1);
+      expect(identifyUser).toHaveBeenCalledWith(request);
+      expect(platform.ɵconnectThread).toHaveBeenCalledWith({
+        threadId: "thread-1",
+        userId: "resolved-user",
+        lastSeenEventId: "event-9",
+      });
+    });
+
+    it("returns 400 when identifyUser returns an invalid id", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn(),
+      };
+      const runtime = createIntelligenceRuntime(platform as any);
+      runtime.identifyUser = vi.fn().mockResolvedValue({ id: "" });
+
+      const response = await handleConnectAgent({
+        runtime,
+        request: createConnectRequest(),
+        agentId: "my-agent",
+      });
+
+      expect(response.status).toBe(400);
+      expect(platform.ɵconnectThread).not.toHaveBeenCalled();
+    });
+
+    it("returns 500 when identifyUser throws", async () => {
+      const platform = {
+        ɵconnectThread: vi.fn(),
+      };
+      const runtime = createIntelligenceRuntime(platform as any);
+      runtime.identifyUser = vi
+        .fn()
+        .mockRejectedValue(new Error("auth failed"));
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      try {
+        const response = await handleConnectAgent({
+          runtime,
+          request: createConnectRequest(),
+          agentId: "my-agent",
+        });
+
+        expect(response.status).toBe(500);
+        expect(platform.ɵconnectThread).not.toHaveBeenCalled();
+      } finally {
+        errorSpy.mockRestore();
+      }
+    });
+  });
+});