@copilotkit/runtime 1.52.0-next.8 → 1.52.1-next.0

package/tests/service-adapters/groq/groq-adapter-language-model.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { OpenAIProviderSettings } from "@ai-sdk/openai";
+import { GroqAdapter } from "../../../src/service-adapters/groq/groq-adapter";
+import { Groq } from "groq-sdk";
+
+// Groq uses createOpenAI (OpenAI-compatible API), so we check against
+// OpenAIProviderSettings. Same exhaustiveness guard as the OpenAI test.
+type ForwardedGroqKeys = "baseURL" | "apiKey" | "headers" | "fetch";
+
+// Keys we set ourselves or that don't apply to Groq.
+type ControlledGroqKeys = "name" | "organization" | "project";
+
+type _exhaustive =
+  Exclude<
+    keyof OpenAIProviderSettings,
+    ForwardedGroqKeys | ControlledGroqKeys
+  > extends never
+    ? true
+    : {
+        error: "OpenAIProviderSettings has unhandled keys";
+        unhandled: Exclude<
+          keyof OpenAIProviderSettings,
+          ForwardedGroqKeys | ControlledGroqKeys
+        >;
+      };
+const _check: _exhaustive = true;
+
+const { mockProviderFn, mockCreateOpenAI } = vi.hoisted(() => {
+  const mockProviderFn = vi.fn().mockReturnValue({ modelId: "test-model" });
+  const mockCreateOpenAI = vi.fn().mockReturnValue(mockProviderFn);
+  return { mockProviderFn, mockCreateOpenAI };
+});
+
+vi.mock("@ai-sdk/openai", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@ai-sdk/openai")>();
+  return { ...actual, createOpenAI: mockCreateOpenAI };
+});
+
+vi.mock("groq-sdk", () => {
+  return {
+    Groq: class MockGroq {
+      baseURL: string;
+      apiKey: string;
+      _options: Record<string, any>;
+      chat = { completions: { create: vi.fn() } };
+
+      constructor(opts: any = {}) {
+        this.baseURL = opts.baseURL ?? "https://api.groq.com";
+        this.apiKey = opts.apiKey ?? "default-key";
+        this._options = {
+          defaultHeaders: opts.defaultHeaders,
+          fetch: opts.fetch,
+          ...opts,
+        };
+      }
+    },
+  };
+});
+
+describe("GroqAdapter.getLanguageModel()", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("forwards all provider-relevant options from the Groq SDK client", () => {
+    const customFetch = vi.fn();
+    const groq = new Groq({
+      apiKey: "gsk-test",
+      baseURL: "https://custom-groq.example.com",
+      defaultHeaders: { "x-groq": "value" },
+      fetch: customFetch,
+    });
+
+    const adapter = new GroqAdapter({
+      groq,
+      model: "llama-3.3-70b-versatile",
+    });
+    adapter.getLanguageModel();
+
+    expect(mockCreateOpenAI).toHaveBeenCalledOnce();
+    const settings = mockCreateOpenAI.mock.calls[0][0];
+
+    expect(settings.baseURL).toBe("https://custom-groq.example.com");
+    expect(settings.apiKey).toBe("gsk-test");
+    expect(settings.headers).toEqual({ "x-groq": "value" });
+    expect(settings.fetch).toBe(customFetch);
+    expect(settings.name).toBe("groq");
+
+    expect(mockProviderFn).toHaveBeenCalledWith("llama-3.3-70b-versatile");
+  });
+
+  it("works with default Groq config (no custom options)", () => {
+    const groq = new Groq({ apiKey: "gsk-default" });
+    const adapter = new GroqAdapter({ groq });
+    adapter.getLanguageModel();
+
+    const settings = mockCreateOpenAI.mock.calls[0][0];
+    expect(settings.baseURL).toBe("https://api.groq.com");
+    expect(settings.apiKey).toBe("gsk-default");
+    expect(settings.name).toBe("groq");
+  });
+});

package/tests/service-adapters/openai/openai-adapter-language-model.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import type { OpenAIProviderSettings } from "@ai-sdk/openai";
+import { OpenAIAdapter } from "../../../src/service-adapters/openai/openai-adapter";
+import OpenAI from "openai";
+
+// Keys from OpenAIProviderSettings that we forward from the OpenAI SDK client.
+// If @ai-sdk/openai adds new keys, the type assertion below will fail at
+// compile time, forcing us to decide whether to forward them.
+type ForwardedOpenAIKeys =
+  | "baseURL"
+  | "apiKey"
+  | "organization"
+  | "project"
+  | "headers"
+  | "fetch";
+
+// We set `name` ourselves (not forwarded from the SDK client).
+type ControlledOpenAIKeys = "name";
+
+// Compile-time exhaustiveness check: every key in OpenAIProviderSettings must
+// be accounted for in either ForwardedOpenAIKeys or ControlledOpenAIKeys.
+// If this line errors, a new key was added to OpenAIProviderSettings that
+// needs to be handled.
+type _exhaustive =
+  Exclude<
+    keyof OpenAIProviderSettings,
+    ForwardedOpenAIKeys | ControlledOpenAIKeys
+  > extends never
+    ? true
+    : {
+        error: "OpenAIProviderSettings has unhandled keys";
+        unhandled: Exclude<
+          keyof OpenAIProviderSettings,
+          ForwardedOpenAIKeys | ControlledOpenAIKeys
+        >;
+      };
+const _check: _exhaustive = true;
+
+const { mockProviderFn, mockCreateOpenAI } = vi.hoisted(() => {
+  const mockProviderFn = vi.fn().mockReturnValue({ modelId: "test-model" });
+  const mockCreateOpenAI = vi.fn().mockReturnValue(mockProviderFn);
+  return { mockProviderFn, mockCreateOpenAI };
+});
+
+vi.mock("@ai-sdk/openai", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@ai-sdk/openai")>();
+  return { ...actual, createOpenAI: mockCreateOpenAI };
+});
+
+vi.mock("openai", () => {
+  return {
+    default: class MockOpenAI {
+      baseURL: string;
+      apiKey: string;
+      organization: string | null;
+      project: string | null;
+      _options: Record<string, any>;
+      beta = { chat: { completions: { stream: vi.fn() } } };
+
+      constructor(opts: any = {}) {
+        this.baseURL = opts.baseURL ?? "https://api.openai.com/v1";
+        this.apiKey = opts.apiKey ?? "default-key";
+        this.organization = opts.organization ?? null;
+        this.project = opts.project ?? null;
+        this._options = {
+          defaultHeaders: opts.defaultHeaders,
+          defaultQuery: opts.defaultQuery,
+          fetch: opts.fetch,
+          ...opts,
+        };
+      }
+    },
+  };
+});
+
+describe("OpenAIAdapter.getLanguageModel()", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("forwards all provider-relevant options from the OpenAI SDK client", () => {
+    const customFetch = vi.fn();
+    const openai = new OpenAI({
+      apiKey: "azure-key",
+      baseURL: "https://myinstance.openai.azure.com/openai/deployments/gpt-4o",
+      organization: "org-123",
+      project: "proj-456",
+      defaultHeaders: { "api-key": "azure-key" },
+      defaultQuery: { "api-version": "2024-04-01-preview" },
+      fetch: customFetch,
+    });
+
+    const adapter = new OpenAIAdapter({ openai, model: "gpt-4o" });
+    adapter.getLanguageModel();
+
+    expect(mockCreateOpenAI).toHaveBeenCalledOnce();
+    const settings = mockCreateOpenAI.mock.calls[0][0];
+
+    expect(settings.baseURL).toBe(
+      "https://myinstance.openai.azure.com/openai/deployments/gpt-4o",
+    );
+    expect(settings.apiKey).toBe("azure-key");
+    expect(settings.organization).toBe("org-123");
+    expect(settings.project).toBe("proj-456");
+    expect(settings.headers).toEqual({ "api-key": "azure-key" });
+    expect(settings.fetch).toBe(customFetch);
+
+    expect(mockProviderFn).toHaveBeenCalledWith("gpt-4o");
+  });
+
+  it("works with default OpenAI config (no custom options)", () => {
+    const openai = new OpenAI({ apiKey: "sk-test" });
+    const adapter = new OpenAIAdapter({ openai });
+    adapter.getLanguageModel();
+
+    const settings = mockCreateOpenAI.mock.calls[0][0];
+    expect(settings.baseURL).toBe("https://api.openai.com/v1");
+    expect(settings.apiKey).toBe("sk-test");
+    expect(settings.organization).toBeUndefined();
+    expect(settings.project).toBeUndefined();
+  });
+});

package/tests/service-adapters/shared/sdk-client-utils.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect, vi } from "vitest";
+import { getSdkClientOptions } from "../../../src/service-adapters/shared/sdk-client-utils";
+
+describe("getSdkClientOptions()", () => {
+  it("extracts defaultHeaders and fetch from _options", () => {
+    const customFetch = vi.fn();
+    const client = {
+      _options: {
+        defaultHeaders: { "x-api-key": "secret" },
+        fetch: customFetch,
+      },
+    };
+
+    const result = getSdkClientOptions(client);
+    expect(result.defaultHeaders).toEqual({ "x-api-key": "secret" });
+    expect(result.fetch).toBe(customFetch);
+  });
+
+  it("returns empty object when _options is missing", () => {
+    const client = { baseURL: "https://api.example.com" };
+    const result = getSdkClientOptions(client);
+    expect(result).toEqual({});
+  });
+
+  it("returns empty object when _options is null", () => {
+    const client = { _options: null };
+    const result = getSdkClientOptions(client);
+    expect(result).toEqual({});
+  });
+
+  it("returns empty object when _options is a primitive", () => {
+    const client = { _options: "not-an-object" };
+    const result = getSdkClientOptions(client);
+    expect(result).toEqual({});
+  });
+});