@copilotkit/runtime 1.54.1 → 1.55.0-next.8

package/src/v2/runtime/__tests__/middleware-sse-parser.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from "vitest";
+import { parseSSEResponse } from "../middleware-sse-parser";
+
+function buildSSEResponse(events: Record<string, unknown>[]): Response {
+  const body = events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join("");
+  return new Response(body, {
+    status: 200,
+    headers: { "content-type": "text/event-stream" },
+  });
+}
+
+describe("parseSSEResponse", () => {
+  it("extracts threadId and runId from RUN_STARTED", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.threadId).toBe("t-1");
+    expect(result.runId).toBe("r-1");
+  });
+
+  it("reconstructs a text message from start/content/end events", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      { type: "TEXT_MESSAGE_START", messageId: "m-1", role: "assistant" },
+      { type: "TEXT_MESSAGE_CONTENT", messageId: "m-1", delta: "Hello" },
+      { type: "TEXT_MESSAGE_CONTENT", messageId: "m-1", delta: " world" },
+      { type: "TEXT_MESSAGE_END", messageId: "m-1" },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]).toEqual({
+      id: "m-1",
+      role: "assistant",
+      content: "Hello world",
+    });
+  });
+
+  it("reconstructs tool calls on assistant messages", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      { type: "TEXT_MESSAGE_START", messageId: "m-1", role: "assistant" },
+      { type: "TEXT_MESSAGE_END", messageId: "m-1" },
+      {
+        type: "TOOL_CALL_START",
+        toolCallId: "tc-1",
+        toolCallName: "get_weather",
+        parentMessageId: "m-1",
+      },
+      { type: "TOOL_CALL_ARGS", toolCallId: "tc-1", delta: '{"city":"NYC"}' },
+      { type: "TOOL_CALL_END", toolCallId: "tc-1" },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]).toMatchObject({
+      id: "m-1",
+      role: "assistant",
+      toolCalls: [{ id: "tc-1", name: "get_weather", args: '{"city":"NYC"}' }],
+    });
+  });
+
+  it("includes tool result messages", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      {
+        type: "TOOL_CALL_RESULT",
+        toolCallId: "tc-1",
+        messageId: "m-result",
+        role: "tool",
+        content: "72F sunny",
+      },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toContainEqual({
+      id: "m-result",
+      role: "tool",
+      content: "72F sunny",
+      toolCallId: "tc-1",
+    });
+  });
+
+  it("uses MESSAGES_SNAPSHOT when present", async () => {
+    const snapshotMessages = [
+      { id: "u-1", role: "user", content: "hi" },
+      { id: "a-1", role: "assistant", content: "hello" },
+    ];
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      { type: "MESSAGES_SNAPSHOT", messages: snapshotMessages },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toEqual(snapshotMessages);
+  });
+
+  it("reconstructs a text message from TEXT_MESSAGE_CHUNK events", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      {
+        type: "TEXT_MESSAGE_CHUNK",
+        messageId: "m-1",
+        role: "assistant",
+        delta: "Hello",
+      },
+      { type: "TEXT_MESSAGE_CHUNK", messageId: "m-1", delta: " world" },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0]).toEqual({
+      id: "m-1",
+      role: "assistant",
+      content: "Hello world",
+    });
+  });
+
+  it("reconstructs tool calls from TOOL_CALL_CHUNK events", async () => {
+    const response = buildSSEResponse([
+      { type: "RUN_STARTED", threadId: "t-1", runId: "r-1" },
+      {
+        type: "TEXT_MESSAGE_CHUNK",
+        messageId: "m-1",
+        role: "assistant",
+        delta: "",
+      },
+      {
+        type: "TOOL_CALL_CHUNK",
+        toolCallId: "tc-1",
+        toolCallName: "getWeather",
+        parentMessageId: "m-1",
+        delta: '{"loc',
+      },
+      {
+        type: "TOOL_CALL_CHUNK",
+        toolCallId: "tc-1",
+        parentMessageId: "m-1",
+        delta: 'ation":"SF"}',
+      },
+      {
+        type: "TOOL_CALL_RESULT",
+        toolCallId: "tc-1",
+        messageId: "m-result",
+        content: "18C",
+      },
+      { type: "RUN_FINISHED", threadId: "t-1", runId: "r-1" },
+    ]);
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toHaveLength(2);
+    expect(result.messages[0]).toMatchObject({
+      id: "m-1",
+      role: "assistant",
+      toolCalls: [
+        { id: "tc-1", name: "getWeather", args: '{"location":"SF"}' },
+      ],
+    });
+    expect(result.messages[1]).toEqual({
+      id: "m-result",
+      role: "tool",
+      content: "18C",
+      toolCallId: "tc-1",
+    });
+  });
+
+  it("returns empty messages for non-SSE responses", async () => {
+    const response = new Response(JSON.stringify({ version: "1.0" }), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toEqual([]);
+    expect(result.threadId).toBeUndefined();
+    expect(result.runId).toBeUndefined();
+  });
+
+  it("handles empty body gracefully", async () => {
+    const response = new Response("", {
+      status: 200,
+      headers: { "content-type": "text/event-stream" },
+    });
+    const result = await parseSSEResponse(response);
+    expect(result.messages).toEqual([]);
+  });
+});

package/src/v2/runtime/__tests__/middleware.test.ts

@@ -0,0 +1,251 @@
+import { vi, type MockedFunction } from "vitest";
+import { createCopilotEndpoint } from "../endpoints";
+import { CopilotRuntime } from "../runtime";
+import { logger } from "@copilotkit/shared";
+import type { AbstractAgent } from "@ag-ui/client";
+import { WebhookStage } from "../middleware";
+import { afterEach, describe, expect, it } from "vitest";
+
+const dummyRuntime = (opts: Partial<CopilotRuntime> = {}) => {
+  const runtime = new CopilotRuntime({
+    agents: { agent: {} as unknown as AbstractAgent },
+    ...opts,
+  });
+  return runtime;
+};
+
+describe("CopilotEndpoint middleware", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // restore global fetch if it was mocked
+    if (fetchMock) {
+      global.fetch = originalFetch;
+    }
+  });
+
+  let originalFetch: typeof fetch;
+  let fetchMock: MockedFunction<typeof fetch> | null = null;
+
+  const setupFetchMock = (beforeUrl: string, afterUrl: string) => {
+    originalFetch = global.fetch;
+    fetchMock = vi.fn().mockImplementation(async (url: string) => {
+      if (url === beforeUrl) {
+        const body = {
+          headers: { "x-modified": "yes" },
+          body: { foo: "bar" },
+        };
+        return new Response(JSON.stringify(body), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        });
+      }
+      if (url === afterUrl) {
+        return new Response(null, { status: 204 });
+      }
+      throw new Error(`Unexpected fetch URL: ${url}`);
+    });
+    // Override global fetch for the duration of this test
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.fetch = fetchMock as unknown as typeof fetch;
+  };
+
+  it("processes request through middleware and handler", async () => {
+    const originalRequest = new Request("https://example.com/info");
+    const modifiedRequest = new Request("https://example.com/info", {
+      headers: { "x-modified": "yes" },
+    });
+
+    const before = vi.fn().mockResolvedValue(modifiedRequest);
+    const after = vi.fn().mockResolvedValue(undefined);
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: before,
+      afterRequestMiddleware: after,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+    const response = await endpoint.fetch(originalRequest);
+
+    expect(before).toHaveBeenCalledWith({
+      runtime,
+      request: originalRequest,
+      path: expect.any(String),
+    });
+    await new Promise((r) => setImmediate(r));
+    expect(after).toHaveBeenCalledWith(
+      expect.objectContaining({
+        runtime,
+        response: expect.any(Response),
+        path: expect.any(String),
+      }),
+    );
+    // The response should contain version info from the /info endpoint
+    const body = await response.json();
+    expect(body).toHaveProperty("version");
+  });
+
+  it("logs and returns Response error from beforeRequestMiddleware", async () => {
+    const errorResponse = new Response("Error", { status: 400 });
+    const before = vi.fn().mockRejectedValue(errorResponse);
+    const after = vi.fn();
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: before,
+      afterRequestMiddleware: after,
+    });
+    const logSpy = vi
+      .spyOn(logger, "error")
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockImplementation(() => undefined as any);
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info"),
+    );
+
+    expect(response.status).toBe(400);
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        err: errorResponse,
+        url: "https://example.com/info",
+        path: expect.any(String),
+      }),
+      "Error running before request middleware",
+    );
+    expect(after).not.toHaveBeenCalled();
+  });
+
+  it("logs and returns 500 error from beforeRequestMiddleware", async () => {
+    const error = new Error("before");
+    const before = vi.fn().mockRejectedValue(error);
+    const after = vi.fn();
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: before,
+      afterRequestMiddleware: after,
+    });
+    const logSpy = vi
+      .spyOn(logger, "error")
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockImplementation(() => undefined as any);
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info"),
+    );
+
+    // Hono catches errors and returns them as 500 responses
+    expect(response.status).toBe(500);
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        err: error,
+        url: "https://example.com/info",
+        path: expect.any(String),
+      }),
+      "Error running before request middleware",
+    );
+    expect(after).not.toHaveBeenCalled();
+  });
+
+  it("logs error from handler", async () => {
+    // Create a mock agent that throws an error
+    const before = vi.fn();
+    const after = vi.fn();
+    const errorAgent = {
+      clone: () => {
+        throw new Error("Agent error");
+      },
+    } as unknown as AbstractAgent;
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: before,
+      afterRequestMiddleware: after,
+      agents: { errorAgent },
+    });
+    const logSpy = vi
+      .spyOn(logger, "error")
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockImplementation(() => undefined as any);
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+    const response = await endpoint.fetch(
+      new Request("https://example.com/agent/errorAgent/run", {
+        method: "POST",
+      }),
+    );
+
+    // Hono catches errors and returns them as 500 responses
+    expect(response.status).toBe(500);
+
+    // The actual handler logs the error, not the middleware
+    expect(logSpy).toHaveBeenCalled();
+    // After middleware is called even on error
+    await new Promise((r) => setTimeout(r, 50));
+    expect(after).toHaveBeenCalled();
+  });
+
+  it("passes parsed messages to afterRequestMiddleware", async () => {
+    let receivedParams: Record<string, unknown> = {};
+    const after = vi.fn().mockImplementation((params) => {
+      receivedParams = params;
+    });
+
+    const runtime = dummyRuntime({
+      afterRequestMiddleware: after,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info"),
+    );
+
+    await new Promise((r) => setImmediate(r));
+
+    expect(response).toBeInstanceOf(Response);
+    expect(after).toHaveBeenCalled();
+    expect(receivedParams).toHaveProperty("messages");
+    expect(receivedParams.messages).toEqual([]);
+  });
+
+  it("logs but does not rethrow error from afterRequestMiddleware", async () => {
+    const error = new Error("after");
+    const before = vi.fn();
+    const after = vi.fn().mockRejectedValue(error);
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: before,
+      afterRequestMiddleware: after,
+    });
+    const logSpy = vi
+      .spyOn(logger, "error")
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .mockImplementation(() => undefined as any);
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info"),
+    );
+
+    await new Promise((r) => setImmediate(r));
+
+    expect(response).toBeInstanceOf(Response);
+    expect(after).toHaveBeenCalledWith(
+      expect.objectContaining({
+        runtime,
+        response: expect.any(Response),
+        path: expect.any(String),
+      }),
+    );
+
+    await new Promise((r) => setImmediate(r));
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        err: error,
+        url: "https://example.com/info",
+      }),
+      "Error running after request middleware",
+    );
+  });
+});

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

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