@copilotkitnext/runtime 0.0.1

package/src/__tests__/middleware.test.ts

@@ -0,0 +1,432 @@
+import { vi, type MockedFunction } from "vitest";
+import { createCopilotEndpoint } from "../endpoint";
+import { CopilotRuntime } from "../runtime";
+import { logger } from "@copilotkitnext/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),
+    });
+    expect(after).toHaveBeenCalledWith({
+      runtime,
+      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("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({
+      runtime,
+      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"
+    );
+  });
+
+  it("processes request through webhook middleware URLs", async () => {
+    const beforeURL = "https://hooks.example.com/before";
+    const afterURL = "https://hooks.example.com/after";
+    setupFetchMock(beforeURL, afterURL);
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: beforeURL,
+      afterRequestMiddleware: afterURL,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info", {
+        headers: { foo: "bar" },
+        method: "GET",
+      })
+    );
+
+    // Wait a bit more for async afterRequestMiddleware
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+
+    // Assert payload for before-hook
+    const beforeCall = fetchMock!.mock.calls[0];
+    expect(beforeCall[0]).toBe(beforeURL);
+    expect(beforeCall[1]).toBeDefined();
+    expect(beforeCall[1]!.body).toBeDefined();
+    const beforePayload = JSON.parse(beforeCall[1]!.body as string);
+    expect(beforePayload).toMatchObject({
+      method: "GET",
+      path: "/info",
+      query: "",
+      headers: expect.objectContaining({ foo: "bar" }),
+    });
+    const headers = beforeCall[1]!.headers as Record<string, string>;
+    expect(headers["X-CopilotKit-Webhook-Stage"]).toBe(
+      WebhookStage.BeforeRequest
+    );
+
+    // Assert payload for after-hook
+    const afterCall = fetchMock!.mock.calls[1];
+    expect(afterCall[0]).toBe(afterURL);
+    expect(afterCall[1]).toBeDefined();
+    expect(afterCall[1]!.body).toBeDefined();
+    const afterPayload = JSON.parse(afterCall[1]!.body as string);
+    expect(afterPayload).toMatchObject({
+      status: 200,
+      headers: expect.objectContaining({
+        "content-type": "application/json",
+      }),
+      body: expect.any(String),
+    });
+    const afterHeaders = afterCall[1]!.headers as Record<string, string>;
+    expect(afterHeaders["X-CopilotKit-Webhook-Stage"]).toBe(
+      WebhookStage.AfterRequest
+    );
+
+    // Response should still be successful
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(body).toHaveProperty("version");
+  });
+
+  it("applies webhook middleware request modifications", async () => {
+    const beforeURL = "https://hooks.example.com/before";
+    const afterURL = "https://hooks.example.com/after";
+    setupFetchMock(beforeURL, afterURL);
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: beforeURL,
+      afterRequestMiddleware: afterURL,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+    // Make a POST request to info endpoint since it's simpler
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info", {
+        headers: { foo: "bar" },
+        method: "GET",
+      })
+    );
+
+    // Should get a successful response
+    expect(response.status).toBe(200);
+
+    // Wait for async afterRequestMiddleware
+    await new Promise((r) => setTimeout(r, 100));
+
+    // The webhook middleware should have been called
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("handles webhook middleware timeout", async () => {
+    const beforeURL = "https://hooks.example.com/before";
+    originalFetch = global.fetch;
+
+    // Create an AbortController to simulate timeout
+    let abortSignal: AbortSignal | undefined;
+    fetchMock = vi
+      .fn()
+      .mockImplementation(async (_url: string, init?: RequestInit) => {
+        abortSignal = init?.signal;
+        // Wait for abort signal
+        return new Promise<Response>((_resolve, reject) => {
+          if (abortSignal) {
+            abortSignal.addEventListener("abort", () => {
+              reject(new Error("Aborted"));
+            });
+          }
+        });
+      });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: beforeURL,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+    // Should return 502 on timeout
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info")
+    );
+
+    expect(response.status).toBe(502);
+
+    // Verify that the fetch was aborted due to timeout
+    expect(abortSignal?.aborted).toBe(true);
+  });
+
+  it("handles webhook middleware error responses", async () => {
+    const beforeURL = "https://hooks.example.com/before";
+    originalFetch = global.fetch;
+    fetchMock = vi.fn().mockImplementation(async () => {
+      return new Response("Bad request", { status: 400 });
+    });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: beforeURL,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+    // Should pass through error response
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info")
+    );
+
+    expect(response.status).toBe(400);
+    expect(await response.text()).toBe("Bad request");
+  });
+
+  it("handles webhook middleware server error", async () => {
+    const beforeURL = "https://hooks.example.com/before";
+    originalFetch = global.fetch;
+    fetchMock = vi.fn().mockImplementation(async () => {
+      return new Response("Server error", { status: 500 });
+    });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: beforeURL,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+    // Should return 502 on server error
+    const response = await endpoint.fetch(
+      new Request("https://example.com/info")
+    );
+
+    expect(response.status).toBe(502);
+  });
+
+  it("handles webhook middleware 204 response", async () => {
+    const beforeURL = "https://hooks.example.com/before";
+    originalFetch = global.fetch;
+    fetchMock = vi.fn().mockImplementation(async () => {
+      return new Response(null, { status: 204 });
+    });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.fetch = fetchMock as unknown as typeof fetch;
+
+    const runtime = dummyRuntime({
+      beforeRequestMiddleware: beforeURL,
+    });
+
+    const endpoint = createCopilotEndpoint({ runtime, basePath: "/" });
+
+    // Should continue with original request on 204
+    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");
+  });
+});

package/src/__tests__/routing.test.ts

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