@copilotkit/runtime 1.57.2 → 1.57.4

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

@@ -1,301 +0,0 @@
-import { handleTranscribe } from "../handlers/handle-transcribe";
-import { CopilotRuntime } from "../core/runtime";
-import {
-  TranscriptionService,
-  TranscribeFileOptions,
-} from "../transcription-service/transcription-service";
-import { describe, it, expect } from "vitest";
-
-// Mock TranscriptionService
-class MockTranscriptionService extends TranscriptionService {
-  public lastOptions?: TranscribeFileOptions;
-
-  constructor(
-    private shouldThrow = false,
-    private returnText = "Mock transcription",
-  ) {
-    super();
-  }
-
-  async transcribeFile(options: TranscribeFileOptions): Promise<string> {
-    this.lastOptions = options;
-    if (this.shouldThrow) {
-      throw new Error("Transcription service error");
-    }
-    return this.returnText;
-  }
-}
-
-describe("handleTranscribe", () => {
-  const createMockRuntime = (
-    transcriptionService?: TranscriptionService,
-  ): CopilotRuntime => {
-    return {
-      agents: Promise.resolve({}),
-      transcriptionService,
-      beforeRequestMiddleware: undefined,
-      afterRequestMiddleware: undefined,
-    } as CopilotRuntime;
-  };
-
-  const createMockAudioFile = (
-    name = "test.mp3",
-    type = "audio/mpeg",
-    size = 1024,
-  ): File => {
-    const content = new Uint8Array(size);
-    return new File([content], name, { type });
-  };
-
-  const createFormDataRequest = (audioFile?: File): Request => {
-    const formData = new FormData();
-    if (audioFile) {
-      formData.append("audio", audioFile);
-    }
-
-    return new Request("https://example.com/transcribe", {
-      method: "POST",
-      body: formData,
-    });
-  };
-
-  const createJsonRequest = (): Request => {
-    return new Request("https://example.com/transcribe", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ test: "data" }),
-    });
-  };
-
-  it("should successfully transcribe an audio file", async () => {
-    const mockService = new MockTranscriptionService(false, "Hello world");
-    const runtime = createMockRuntime(mockService);
-    const audioFile = createMockAudioFile("test.mp3", "audio/mpeg", 2048);
-    const request = createFormDataRequest(audioFile);
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(200);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body).toEqual({
-      text: "Hello world",
-      size: 2048,
-      type: "audio/mpeg",
-    });
-  });
-
-  it("should return 503 when transcription service is not configured", async () => {
-    const runtime = createMockRuntime(); // No transcription service
-    const audioFile = createMockAudioFile();
-    const request = createFormDataRequest(audioFile);
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(503);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body).toEqual({
-      error: "service_not_configured",
-      message: "Transcription service is not configured",
-      retryable: false,
-    });
-  });
-
-  it("should return 400 when request is not form data", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-    const request = createJsonRequest();
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(400);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body).toEqual({
-      error: "invalid_request",
-      message:
-        "Request must include 'audio' field with base64-encoded audio data",
-      retryable: false,
-    });
-  });
-
-  it("should return 400 when no audio file is provided", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-    const request = createFormDataRequest(); // No audio file
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(400);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body).toEqual({
-      error: "invalid_request",
-      message:
-        "No audio file found in form data. Please include an 'audio' field.",
-      retryable: false,
-    });
-  });
-
-  it("should accept various valid audio file types", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-
-    const validTypes = [
-      "audio/mpeg",
-      "audio/mp3",
-      "audio/mp4",
-      "audio/wav",
-      "audio/webm",
-      "audio/ogg",
-      "audio/flac",
-      "audio/aac",
-    ];
-
-    for (const type of validTypes) {
-      const audioFile = createMockAudioFile(`test.${type.split("/")[1]}`, type);
-      const request = createFormDataRequest(audioFile);
-
-      const response = await handleTranscribe({ runtime, request });
-      expect(response.status).toBe(200);
-    }
-  });
-
-  it("should accept files with empty type (some browsers/systems)", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-    const audioFile = createMockAudioFile("test.mp3", ""); // Empty type
-    const request = createFormDataRequest(audioFile);
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(200);
-  });
-
-  it("should accept files with application/octet-stream type (fallback)", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-    const audioFile = createMockAudioFile(
-      "test.mp3",
-      "application/octet-stream",
-    );
-    const request = createFormDataRequest(audioFile);
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(200);
-  });
-
-  it("should return 400 for invalid file types", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-    const audioFile = createMockAudioFile("test.txt", "text/plain");
-    const request = createFormDataRequest(audioFile);
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(400);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body.error).toBe("invalid_audio_format");
-    expect(body.message).toContain("Unsupported audio format: text/plain");
-    expect(body.retryable).toBe(false);
-  });
-
-  it("should return 500 when transcription service throws an error", async () => {
-    const mockService = new MockTranscriptionService(true); // Will throw error
-    const runtime = createMockRuntime(mockService);
-    const audioFile = createMockAudioFile();
-    const request = createFormDataRequest(audioFile);
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(500);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body).toEqual({
-      error: "provider_error",
-      message: "Transcription service error",
-      retryable: true,
-    });
-  });
-
-  it("should handle form data parsing errors gracefully", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-
-    // Create a request with malformed form data
-    const request = new Request("https://example.com/transcribe", {
-      method: "POST",
-      headers: { "Content-Type": "multipart/form-data; boundary=invalid" },
-      body: "invalid form data",
-    });
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(500);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body.error).toBe("provider_error");
-    expect(body.retryable).toBe(true);
-  });
-
-  it("should handle non-File objects in form data", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-
-    const formData = new FormData();
-    formData.append("audio", "not a file"); // String instead of File
-
-    const request = new Request("https://example.com/transcribe", {
-      method: "POST",
-      body: formData,
-    });
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(400);
-    expect(response.headers.get("Content-Type")).toBe("application/json");
-
-    const body = await response.json();
-    expect(body).toEqual({
-      error: "invalid_request",
-      message:
-        "No audio file found in form data. Please include an 'audio' field.",
-      retryable: false,
-    });
-  });
-
-  it("should pass file metadata to transcription service", async () => {
-    const mockService = new MockTranscriptionService();
-    const runtime = createMockRuntime(mockService);
-    const audioFile = createMockAudioFile(
-      "my-recording.wav",
-      "audio/wav",
-      2048,
-    );
-
-    const request = createFormDataRequest(audioFile);
-
-    const response = await handleTranscribe({ runtime, request });
-
-    expect(response.status).toBe(200);
-    expect(mockService.lastOptions).toEqual({
-      audioFile: expect.objectContaining({
-        name: "my-recording.wav",
-        type: "audio/wav",
-        size: 2048,
-      }),
-      mimeType: "audio/wav",
-      size: 2048,
-    });
-  });
-});

package/src/v2/runtime/__tests__/header-utils.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  shouldForwardHeader,
-  extractForwardableHeaders,
-} from "../handlers/header-utils";
-
-describe("header-utils", () => {
-  describe("shouldForwardHeader", () => {
-    it("forwards authorization header (case-insensitive)", () => {
-      expect(shouldForwardHeader("authorization")).toBe(true);
-      expect(shouldForwardHeader("Authorization")).toBe(true);
-      expect(shouldForwardHeader("AUTHORIZATION")).toBe(true);
-    });
-
-    it("forwards x-* custom headers", () => {
-      expect(shouldForwardHeader("x-custom")).toBe(true);
-      expect(shouldForwardHeader("X-Custom")).toBe(true);
-      expect(shouldForwardHeader("x-request-id")).toBe(true);
-      expect(shouldForwardHeader("X-Forwarded-For")).toBe(true);
-    });
-
-    it("blocks standard headers", () => {
-      expect(shouldForwardHeader("content-type")).toBe(false);
-      expect(shouldForwardHeader("Content-Type")).toBe(false);
-      expect(shouldForwardHeader("origin")).toBe(false);
-      expect(shouldForwardHeader("user-agent")).toBe(false);
-      expect(shouldForwardHeader("accept")).toBe(false);
-      expect(shouldForwardHeader("cookie")).toBe(false);
-      expect(shouldForwardHeader("host")).toBe(false);
-    });
-  });
-
-  describe("extractForwardableHeaders", () => {
-    it("extracts only forwardable headers from request", () => {
-      const request = new Request("https://example.com", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-Custom": "custom-value",
-          "X-Request-ID": "req-123",
-          Authorization: "Bearer token",
-          Origin: "http://localhost",
-        },
-      });
-
-      const result = extractForwardableHeaders(request);
-
-      expect(result).toEqual({
-        "x-custom": "custom-value",
-        "x-request-id": "req-123",
-        authorization: "Bearer token",
-      });
-    });
-
-    it("returns empty object when no forwardable headers present", () => {
-      const request = new Request("https://example.com", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Origin: "http://localhost",
-        },
-      });
-
-      const result = extractForwardableHeaders(request);
-
-      expect(result).toEqual({});
-    });
-
-    it("preserves header values exactly", () => {
-      const request = new Request("https://example.com", {
-        method: "POST",
-        headers: {
-          Authorization: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9",
-          "X-Complex-Value": "value with spaces and special=chars&more",
-        },
-      });
-
-      const result = extractForwardableHeaders(request);
-
-      expect(result.authorization).toBe(
-        "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9",
-      );
-      expect(result["x-complex-value"]).toBe(
-        "value with spaces and special=chars&more",
-      );
-    });
-  });
-});

package/src/v2/runtime/__tests__/hono-adapter.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-import {
-  createCopilotEndpoint,
-  createCopilotEndpointSingleRoute,
-} from "../endpoints";
-import { CopilotRuntime } from "../core/runtime";
-
-describe("Hono adapter with hooks", () => {
-  const createMockAgent = () => {
-    const agent: unknown = {
-      execute: async () => ({ events: [] }),
-    };
-    (agent as { clone: () => unknown }).clone = () => createMockAgent();
-    return agent as AbstractAgent;
-  };
-
-  const createMockRuntime = (opts?: Partial<CopilotRuntime>) =>
-    new CopilotRuntime({
-      agents: {
-        default: createMockAgent(),
-        myAgent: createMockAgent(),
-        testAgent: createMockAgent(),
-      },
-      ...opts,
-    });
-
-  describe("createCopilotEndpoint", () => {
-    const createEndpoint = (
-      hooks?: Parameters<typeof createCopilotEndpoint>[0]["hooks"],
-      runtimeOpts?: Partial<CopilotRuntime>,
-    ) => {
-      const runtime = createMockRuntime(runtimeOpts);
-      const endpoint = createCopilotEndpoint({
-        runtime,
-        basePath: "/",
-        hooks,
-      });
-      return { endpoint, runtime };
-    };
-
-    it("routes GET /info correctly", async () => {
-      const { endpoint } = createEndpoint();
-      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("routes POST /agent/:id/run correctly", async () => {
-      const { endpoint } = createEndpoint();
-      const response = await endpoint.fetch(
-        new Request("https://example.com/agent/myAgent/run", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            messages: [],
-            state: {},
-            threadId: "thread-1",
-          }),
-        }),
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-
-    it("forwards hooks — onRequest hook is called", async () => {
-      const onRequest = vi.fn();
-      const { endpoint, runtime } = createEndpoint({ onRequest });
-
-      await endpoint.fetch(new Request("https://example.com/info"));
-
-      expect(onRequest).toHaveBeenCalledTimes(1);
-      expect(onRequest).toHaveBeenCalledWith(
-        expect.objectContaining({
-          request: expect.any(Request),
-          path: expect.stringContaining("/info"),
-          runtime,
-        }),
-      );
-    });
-
-    it("hooks can modify response headers via onResponse", async () => {
-      const { endpoint } = createEndpoint({
-        onResponse: ({ response }) => {
-          const headers = new Headers(response.headers);
-          headers.set("x-custom-header", "hello-from-hook");
-          return new Response(response.body, {
-            status: response.status,
-            headers,
-          });
-        },
-      });
-
-      const response = await endpoint.fetch(
-        new Request("https://example.com/info"),
-      );
-
-      expect(response.status).toBe(200);
-      expect(response.headers.get("x-custom-header")).toBe("hello-from-hook");
-    });
-
-    it("Hono CORS headers are present", async () => {
-      const { endpoint } = createEndpoint();
-      const response = await endpoint.fetch(
-        new Request("https://example.com/info", {
-          method: "OPTIONS",
-          headers: {
-            Origin: "https://somesite.com",
-            "Access-Control-Request-Method": "GET",
-          },
-        }),
-      );
-
-      expect(response.headers.get("Access-Control-Allow-Origin")).toBe("*");
-    });
-  });
-
-  describe("createCopilotEndpointSingleRoute", () => {
-    it("dispatches single-route with method envelope", 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: "agent/run",
-            params: { agentId: "myAgent" },
-            body: {
-              messages: [],
-              state: {},
-              threadId: "thread-1",
-            },
-          }),
-        }),
-      );
-
-      expect(response.status).not.toBe(404);
-    });
-  });
-});

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

@@ -1,46 +0,0 @@
-/**
- * Integration test: Hono single-route adapter (deprecated path) + telemetry.
- *
- * `createCopilotEndpointSingleRoute` is the legacy direct single-route entry
- * point, superseded by `createCopilotHonoHandler({ mode: "single-route" })`
- * but still exported.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-import { telemetry } from "../telemetry";
-import { createCopilotEndpointSingleRoute } from "../endpoints/hono-single";
-import { CopilotRuntime } from "../core/runtime";
-
-function makeAgent(): AbstractAgent {
-  const a: unknown = { execute: async () => ({ events: [] }) };
-  (a as { clone: () => unknown }).clone = () => makeAgent();
-  return a as AbstractAgent;
-}
-
-describe("Hono single-route 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", async () => {
-    const runtime = new CopilotRuntime({ agents: { default: makeAgent() } });
-    createCopilotEndpointSingleRoute({ runtime, basePath: "/api/copilotkit" });
-
-    await vi.waitFor(() => {
-      expect(captureSpy).toHaveBeenCalledWith(
-        "oss.runtime.instance_created",
-        expect.objectContaining({
-          agentsAmount: 1,
-          "cloud.api_key_provided": false,
-        }),
-      );
-    });
-  });
-});

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

@@ -1,99 +0,0 @@
-/**
- * Integration test: Hono adapter + telemetry.
- *
- * Asserts both ends of the path-to-production chain that the v2 refactor
- * previously broke (2ac4a40b5, 2026-03-29):
- *   1. `oss.runtime.instance_created` fires once per handler factory.
- *   2. `oss.runtime.copilot_request_created` fires when a real HTTP request
- *      flows through the handler.
- *
- * If either regresses, this test fails.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import type { AbstractAgent } from "@ag-ui/client";
-
-import { telemetry } from "../telemetry";
-import { createCopilotHonoHandler } from "../endpoints/hono";
-import { CopilotRuntime } from "../core/runtime";
-
-function makeAgent(): AbstractAgent {
-  const a: unknown = {
-    execute: async () => ({ events: [] }),
-  };
-  (a as { clone: () => unknown }).clone = () => makeAgent();
-  return a as AbstractAgent;
-}
-
-describe("Hono 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 = new CopilotRuntime({ agents: { default: makeAgent() } });
-    createCopilotHonoHandler({ runtime, basePath: "/" });
-
-    await vi.waitFor(() => {
-      expect(captureSpy).toHaveBeenCalledWith(
-        "oss.runtime.instance_created",
-        expect.objectContaining({
-          agentsAmount: 1,
-          actionsAmount: 0,
-          endpointsAmount: 0,
-          "cloud.api_key_provided": false,
-        }),
-      );
-    });
-  });
-
-  it("fires copilot_request_created when a real HTTP request hits the handler", async () => {
-    const runtime = new CopilotRuntime({ agents: { default: makeAgent() } });
-    const endpoint = createCopilotHonoHandler({ runtime, basePath: "/" });
-
-    await endpoint.fetch(
-      new Request("https://example.com/agent/default/run", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ 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 = new CopilotRuntime({ agents: { default: makeAgent() } });
-    const endpoint = createCopilotHonoHandler({ runtime, basePath: "/" });
-
-    await endpoint.fetch(
-      new Request("https://example.com/agent/default/run", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-copilotcloud-public-api-key": "ck_pub_test_123",
-        },
-        body: JSON.stringify({ 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_123",
-      }),
-    );
-  });
-});