@copilotkit/runtime 1.54.1 → 1.55.0-next.7

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

@@ -0,0 +1,388 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  handleArchiveThread,
+  handleDeleteThread,
+  handleListThreads,
+  handleSubscribeToThreads,
+  handleUpdateThread,
+} from "../handlers/handle-threads";
+import { CopilotRuntime } from "../runtime";
+
+describe("thread handlers", () => {
+  const createIdentifyUser = () => vi.fn().mockResolvedValue({ id: "user-1" });
+
+  const createIntelligenceRuntime = (options?: {
+    identifyUser?: (
+      request: Request,
+    ) => { id: string } | Promise<{ id: string }>;
+    intelligence?: Record<string, unknown>;
+  }) =>
+    ({
+      agents: Promise.resolve({}),
+      transcriptionService: undefined,
+      beforeRequestMiddleware: undefined,
+      afterRequestMiddleware: undefined,
+      runner: {
+        run: vi.fn(),
+        connect: vi.fn(),
+        isRunning: vi.fn(),
+        stop: vi.fn(),
+      },
+      mode: "intelligence",
+      generateThreadNames: false,
+      identifyUser: options?.identifyUser ?? createIdentifyUser(),
+      intelligence: options?.intelligence,
+    }) as unknown as CopilotRuntime;
+
+  const createMutationRequest = (
+    path: string,
+    method: "PATCH" | "POST" | "DELETE",
+    body: Record<string, unknown>,
+  ) =>
+    new Request(`https://example.com${path}`, {
+      method,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+
+  it("returns 422 when intelligence is not configured for listThreads", async () => {
+    const runtime = new CopilotRuntime({ agents: {} });
+
+    const response = await handleListThreads({
+      runtime,
+      request: new Request("https://example.com/threads?agentId=agent-1"),
+    });
+
+    expect(response.status).toBe(422);
+    await expect(response.json()).resolves.toEqual({
+      error:
+        "Missing CopilotKitIntelligence configuration. Thread operations require a CopilotKitIntelligence instance to be provided in CopilotRuntime options.",
+    });
+  });
+
+  it("lists threads using identifyUser and the request agentId", async () => {
+    const intelligence = {
+      listThreads: vi.fn().mockResolvedValue({
+        threads: [{ id: "thread-1", name: "Hello" }],
+        joinCode: "jc-1",
+      }),
+    };
+    const identifyUser = createIdentifyUser();
+    const runtime = createIntelligenceRuntime({ intelligence, identifyUser });
+    const request = new Request("https://example.com/threads?agentId=agent-1");
+
+    const response = await handleListThreads({
+      runtime,
+      request,
+    });
+
+    expect(response.status).toBe(200);
+    expect(identifyUser).toHaveBeenCalledTimes(1);
+    expect(identifyUser).toHaveBeenCalledWith(request);
+    expect(intelligence.listThreads).toHaveBeenCalledWith({
+      userId: "user-1",
+      agentId: "agent-1",
+    });
+  });
+
+  it("returns 400 when identifyUser returns an invalid id for thread list", async () => {
+    const intelligence = {
+      listThreads: vi.fn(),
+    };
+    const runtime = createIntelligenceRuntime({
+      intelligence,
+      identifyUser: vi.fn().mockResolvedValue({ id: "" }),
+    });
+
+    const response = await handleListThreads({
+      runtime,
+      request: new Request("https://example.com/threads?agentId=agent-1"),
+    });
+
+    expect(response.status).toBe(400);
+    expect(intelligence.listThreads).not.toHaveBeenCalled();
+  });
+
+  it("returns 500 when identifyUser throws for thread subscription", async () => {
+    const intelligence = {
+      ɵsubscribeToThreads: vi.fn(),
+    };
+    const runtime = createIntelligenceRuntime({
+      intelligence,
+      identifyUser: vi.fn().mockRejectedValue(new Error("auth failed")),
+    });
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      const response = await handleSubscribeToThreads({
+        runtime,
+        request: new Request("https://example.com/threads/subscribe", {
+          method: "POST",
+        }),
+      });
+
+      expect(response.status).toBe(500);
+      expect(intelligence.ɵsubscribeToThreads).not.toHaveBeenCalled();
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("updates, archives, and deletes threads using identifyUser and ignoring request userId", async () => {
+    const intelligence = {
+      updateThread: vi
+        .fn()
+        .mockResolvedValue({ id: "thread-1", name: "Renamed" }),
+      archiveThread: vi.fn().mockResolvedValue(undefined),
+      deleteThread: vi.fn().mockResolvedValue(undefined),
+    };
+    const identifyUser = createIdentifyUser();
+    const runtime = createIntelligenceRuntime({ intelligence, identifyUser });
+    const mutationBody = {
+      userId: "ignored-user",
+      agentId: "agent-1",
+      name: "Renamed",
+    };
+
+    const updateRequest = createMutationRequest(
+      "/threads/thread-1",
+      "PATCH",
+      mutationBody,
+    );
+    const updateResponse = await handleUpdateThread({
+      runtime,
+      request: updateRequest,
+      threadId: "thread-1",
+    });
+    expect(updateResponse.status).toBe(200);
+    expect(identifyUser).toHaveBeenCalledWith(updateRequest);
+    expect(intelligence.updateThread).toHaveBeenCalledWith({
+      threadId: "thread-1",
+      userId: "user-1",
+      agentId: "agent-1",
+      updates: { name: "Renamed" },
+    });
+
+    const archiveRequest = createMutationRequest(
+      "/threads/thread-1/archive",
+      "POST",
+      mutationBody,
+    );
+    const archiveResponse = await handleArchiveThread({
+      runtime,
+      request: archiveRequest,
+      threadId: "thread-1",
+    });
+    expect(archiveResponse.status).toBe(200);
+    expect(identifyUser).toHaveBeenCalledWith(archiveRequest);
+    expect(intelligence.archiveThread).toHaveBeenCalledWith({
+      threadId: "thread-1",
+      userId: "user-1",
+      agentId: "agent-1",
+    });
+
+    const deleteRequest = createMutationRequest(
+      "/threads/thread-1",
+      "DELETE",
+      mutationBody,
+    );
+    const deleteResponse = await handleDeleteThread({
+      runtime,
+      request: deleteRequest,
+      threadId: "thread-1",
+    });
+    expect(deleteResponse.status).toBe(200);
+    expect(identifyUser).toHaveBeenCalledWith(deleteRequest);
+    expect(identifyUser).toHaveBeenCalledTimes(3);
+    expect(intelligence.deleteThread).toHaveBeenCalledWith({
+      threadId: "thread-1",
+      userId: "user-1",
+      agentId: "agent-1",
+    });
+  });
+
+  it("subscribes to threads using identifyUser", async () => {
+    const intelligence = {
+      ɵsubscribeToThreads: vi
+        .fn()
+        .mockResolvedValue({ joinToken: "join-token-1" }),
+    };
+    const identifyUser = createIdentifyUser();
+    const runtime = createIntelligenceRuntime({ intelligence, identifyUser });
+    const request = new Request("https://example.com/threads/subscribe", {
+      method: "POST",
+    });
+
+    const response = await handleSubscribeToThreads({
+      runtime,
+      request,
+    });
+
+    expect(response.status).toBe(200);
+    expect(identifyUser).toHaveBeenCalledTimes(1);
+    expect(identifyUser).toHaveBeenCalledWith(request);
+    await expect(response.json()).resolves.toEqual({
+      joinToken: "join-token-1",
+    });
+    expect(intelligence.ɵsubscribeToThreads).toHaveBeenCalledWith({
+      userId: "user-1",
+    });
+  });
+
+  it("returns 400 when agentId is invalid for thread mutations", async () => {
+    const intelligence = {
+      updateThread: vi.fn(),
+    };
+    const runtime = createIntelligenceRuntime({ intelligence });
+
+    const response = await handleUpdateThread({
+      runtime,
+      request: new Request("https://example.com/threads/thread-1", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ agentId: "" }),
+      }),
+      threadId: "thread-1",
+    });
+
+    expect(response.status).toBe(400);
+    expect(intelligence.updateThread).not.toHaveBeenCalled();
+  });
+
+  it("returns 400 when identifyUser returns an invalid id for thread mutations", async () => {
+    const intelligence = {
+      updateThread: vi.fn(),
+      archiveThread: vi.fn(),
+      deleteThread: vi.fn(),
+    };
+    const runtime = createIntelligenceRuntime({
+      intelligence,
+      identifyUser: vi.fn().mockResolvedValue({ id: "" }),
+    });
+
+    const updateResponse = await handleUpdateThread({
+      runtime,
+      request: createMutationRequest("/threads/thread-1", "PATCH", {
+        agentId: "agent-1",
+      }),
+      threadId: "thread-1",
+    });
+    expect(updateResponse.status).toBe(400);
+
+    const archiveResponse = await handleArchiveThread({
+      runtime,
+      request: createMutationRequest("/threads/thread-1/archive", "POST", {
+        agentId: "agent-1",
+      }),
+      threadId: "thread-1",
+    });
+    expect(archiveResponse.status).toBe(400);
+
+    const deleteResponse = await handleDeleteThread({
+      runtime,
+      request: createMutationRequest("/threads/thread-1", "DELETE", {
+        agentId: "agent-1",
+      }),
+      threadId: "thread-1",
+    });
+    expect(deleteResponse.status).toBe(400);
+
+    expect(intelligence.updateThread).not.toHaveBeenCalled();
+    expect(intelligence.archiveThread).not.toHaveBeenCalled();
+    expect(intelligence.deleteThread).not.toHaveBeenCalled();
+  });
+
+  it("returns 422 when intelligence is not configured for thread mutations", async () => {
+    const runtime = new CopilotRuntime({ agents: {} });
+    const mutationRequest = new Request(
+      "https://example.com/threads/thread-1",
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ userId: "user-1", agentId: "agent-1" }),
+      },
+    );
+
+    const updateResponse = await handleUpdateThread({
+      runtime,
+      request: mutationRequest.clone(),
+      threadId: "thread-1",
+    });
+    expect(updateResponse.status).toBe(422);
+
+    const archiveResponse = await handleArchiveThread({
+      runtime,
+      request: mutationRequest.clone(),
+      threadId: "thread-1",
+    });
+    expect(archiveResponse.status).toBe(422);
+
+    const deleteResponse = await handleDeleteThread({
+      runtime,
+      request: mutationRequest.clone(),
+      threadId: "thread-1",
+    });
+    expect(deleteResponse.status).toBe(422);
+  });
+
+  it("returns 422 when intelligence is not configured for thread subscription", async () => {
+    const runtime = new CopilotRuntime({ agents: {} });
+
+    const response = await handleSubscribeToThreads({
+      runtime,
+      request: new Request("https://example.com/threads/subscribe", {
+        method: "POST",
+      }),
+    });
+
+    expect(response.status).toBe(422);
+  });
+
+  it("forwards includeArchived, limit, and cursor query params to listThreads", async () => {
+    const intelligence = {
+      listThreads: vi.fn().mockResolvedValue({
+        threads: [{ id: "thread-1", name: "Hello" }],
+        joinCode: "jc-1",
+        nextCursor: "cursor-xyz",
+      }),
+    };
+    const identifyUser = createIdentifyUser();
+    const runtime = createIntelligenceRuntime({ intelligence, identifyUser });
+    const request = new Request(
+      "https://example.com/threads?agentId=agent-1&includeArchived=true&limit=10&cursor=prev-cursor",
+    );
+
+    const response = await handleListThreads({ runtime, request });
+
+    expect(response.status).toBe(200);
+    expect(intelligence.listThreads).toHaveBeenCalledWith({
+      userId: "user-1",
+      agentId: "agent-1",
+      includeArchived: true,
+      limit: 10,
+      cursor: "prev-cursor",
+    });
+    const body = await response.json();
+    expect(body.nextCursor).toBe("cursor-xyz");
+  });
+
+  it("omits includeArchived, limit, and cursor when not provided", async () => {
+    const intelligence = {
+      listThreads: vi.fn().mockResolvedValue({
+        threads: [],
+        joinCode: "jc-1",
+      }),
+    };
+    const identifyUser = createIdentifyUser();
+    const runtime = createIntelligenceRuntime({ intelligence, identifyUser });
+    const request = new Request("https://example.com/threads?agentId=agent-1");
+
+    await handleListThreads({ runtime, request });
+
+    expect(intelligence.listThreads).toHaveBeenCalledWith({
+      userId: "user-1",
+      agentId: "agent-1",
+    });
+  });
+});

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

@@ -0,0 +1,301 @@
+import { handleTranscribe } from "../handlers/handle-transcribe";
+import { CopilotRuntime } from "../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,
+    });
+  });
+});