@copilotkit/runtime 1.57.3 → 1.58.0-canary.thread-id-propagation

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

@@ -1,122 +0,0 @@
-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/openai/openai-adapter.test.ts

@@ -1,291 +0,0 @@
-// Mock the modules first
-vi.mock("openai", () => {
-  function MockOpenAI() {}
-  return { default: MockOpenAI };
-});
-
-// Mock the OpenAIAdapter class to avoid the "new OpenAI()" issue
-vi.mock("../../../src/service-adapters/openai/openai-adapter", () => {
-  class MockOpenAIAdapter {
-    _openai: any;
-    model: string = "gpt-4o";
-    keepSystemRole: boolean = false;
-    disableParallelToolCalls: boolean = false;
-
-    constructor() {
-      this._openai = {
-        beta: {
-          chat: {
-            completions: {
-              stream: vi.fn(),
-            },
-          },
-        },
-      };
-    }
-
-    get openai() {
-      return this._openai;
-    }
-
-    async process(request: any) {
-      // Mock implementation that calls our event source but doesn't do the actual processing
-      request.eventSource.stream(async (stream: any) => {
-        stream.complete();
-        return Promise.resolve();
-      });
-
-      return { threadId: request.threadId || "mock-thread-id" };
-    }
-  }
-
-  return { OpenAIAdapter: MockOpenAIAdapter };
-});
-
-// Mock the Message classes since they use TypeGraphQL decorators
-vi.mock("../../../src/graphql/types/converted", () => {
-  // Create minimal implementations of the message classes
-  class MockTextMessage {
-    content: string;
-    role: string;
-    id: string;
-
-    constructor(role: string, content: string) {
-      this.role = role;
-      this.content = content;
-      this.id = "mock-text-" + Math.random().toString(36).substring(7);
-    }
-
-    isTextMessage() {
-      return true;
-    }
-    isImageMessage() {
-      return false;
-    }
-    isActionExecutionMessage() {
-      return false;
-    }
-    isResultMessage() {
-      return false;
-    }
-  }
-
-  class MockActionExecutionMessage {
-    id: string;
-    name: string;
-    arguments: string;
-
-    constructor(params: { id: string; name: string; arguments: string }) {
-      this.id = params.id;
-      this.name = params.name;
-      this.arguments = params.arguments;
-    }
-
-    isTextMessage() {
-      return false;
-    }
-    isImageMessage() {
-      return false;
-    }
-    isActionExecutionMessage() {
-      return true;
-    }
-    isResultMessage() {
-      return false;
-    }
-  }
-
-  class MockResultMessage {
-    actionExecutionId: string;
-    result: string;
-    id: string;
-
-    constructor(params: { actionExecutionId: string; result: string }) {
-      this.actionExecutionId = params.actionExecutionId;
-      this.result = params.result;
-      this.id = "mock-result-" + Math.random().toString(36).substring(7);
-    }
-
-    isTextMessage() {
-      return false;
-    }
-    isImageMessage() {
-      return false;
-    }
-    isActionExecutionMessage() {
-      return false;
-    }
-    isResultMessage() {
-      return true;
-    }
-  }
-
-  return {
-    TextMessage: MockTextMessage,
-    ActionExecutionMessage: MockActionExecutionMessage,
-    ResultMessage: MockResultMessage,
-  };
-});
-
-// Now import the modules (vi.mock is hoisted above imports, so these get the mocked versions)
-import { OpenAIAdapter } from "../../../src/service-adapters/openai/openai-adapter";
-import {
-  TextMessage,
-  ActionExecutionMessage,
-  ResultMessage,
-} from "../../../src/graphql/types/converted";
-
-describe("OpenAIAdapter", () => {
-  let adapter: OpenAIAdapter;
-  let mockEventSource: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    adapter = new OpenAIAdapter();
-    mockEventSource = {
-      stream: vi.fn((callback) => {
-        const mockStream = {
-          sendTextMessageStart: vi.fn(),
-          sendTextMessageContent: vi.fn(),
-          sendTextMessageEnd: vi.fn(),
-          sendActionExecutionStart: vi.fn(),
-          sendActionExecutionArgs: vi.fn(),
-          sendActionExecutionEnd: vi.fn(),
-          complete: vi.fn(),
-        };
-        callback(mockStream);
-      }),
-    };
-  });
-
-  describe("Tool ID handling", () => {
-    it("should filter out tool_result messages that don't have corresponding tool_call IDs", async () => {
-      // Create messages including one valid pair and one invalid tool_result
-      const systemMessage = new TextMessage("system", "System message");
-      const userMessage = new TextMessage("user", "User message");
-
-      // Valid tool execution message
-      const validToolExecution = new ActionExecutionMessage({
-        id: "valid-tool-id",
-        name: "validTool",
-        arguments: '{"arg":"value"}',
-      });
-
-      // Valid result for the above tool
-      const validToolResult = new ResultMessage({
-        actionExecutionId: "valid-tool-id",
-        result: '{"result":"success"}',
-      });
-
-      // Invalid tool result with no corresponding tool execution
-      const invalidToolResult = new ResultMessage({
-        actionExecutionId: "invalid-tool-id",
-        result: '{"result":"failure"}',
-      });
-
-      // Spy on the process method to test it's called properly
-      const processSpy = vi.spyOn(adapter, "process");
-
-      await adapter.process({
-        threadId: "test-thread",
-        model: "gpt-4o",
-        messages: [
-          systemMessage,
-          userMessage,
-          validToolExecution,
-          validToolResult,
-          invalidToolResult,
-        ],
-        actions: [],
-        eventSource: mockEventSource,
-        forwardedParameters: {},
-      });
-
-      // Verify the process method was called
-      expect(processSpy).toHaveBeenCalledTimes(1);
-
-      // Verify the stream function was called
-      expect(mockEventSource.stream).toHaveBeenCalled();
-    });
-
-    it("should handle duplicate tool IDs by only using each once", async () => {
-      // Create messages including duplicate tool results for the same ID
-      const systemMessage = new TextMessage("system", "System message");
-
-      // Valid tool execution message
-      const toolExecution = new ActionExecutionMessage({
-        id: "tool-id-1",
-        name: "someTool",
-        arguments: '{"arg":"value"}',
-      });
-
-      // Two results for the same tool ID
-      const firstToolResult = new ResultMessage({
-        actionExecutionId: "tool-id-1",
-        result: '{"result":"first"}',
-      });
-
-      const duplicateToolResult = new ResultMessage({
-        actionExecutionId: "tool-id-1",
-        result: '{"result":"duplicate"}',
-      });
-
-      // Spy on the process method to test it's called properly
-      const processSpy = vi.spyOn(adapter, "process");
-
-      await adapter.process({
-        threadId: "test-thread",
-        model: "gpt-4o",
-        messages: [
-          systemMessage,
-          toolExecution,
-          firstToolResult,
-          duplicateToolResult,
-        ],
-        actions: [],
-        eventSource: mockEventSource,
-        forwardedParameters: {},
-      });
-
-      // Verify the process method was called
-      expect(processSpy).toHaveBeenCalledTimes(1);
-
-      // Verify the stream function was called
-      expect(mockEventSource.stream).toHaveBeenCalled();
-    });
-
-    it("should call the stream method on eventSource", async () => {
-      // Create messages
-      const systemMessage = new TextMessage("system", "System message");
-      const userMessage = new TextMessage("user", "User message");
-
-      await adapter.process({
-        threadId: "test-thread",
-        model: "gpt-4o",
-        messages: [systemMessage, userMessage],
-        actions: [],
-        eventSource: mockEventSource,
-        forwardedParameters: {},
-      });
-
-      // Verify the stream function was called
-      expect(mockEventSource.stream).toHaveBeenCalled();
-    });
-
-    it("should return the provided threadId", async () => {
-      // Create a message
-      const systemMessage = new TextMessage("system", "System message");
-
-      const result = await adapter.process({
-        threadId: "test-thread",
-        model: "gpt-4o",
-        messages: [systemMessage],
-        actions: [],
-        eventSource: mockEventSource,
-        forwardedParameters: {},
-      });
-
-      expect(result.threadId).toBe("test-thread");
-    });
-  });
-});

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

@@ -1,36 +0,0 @@
-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({});
-  });
-});

package/tests/setup.vitest.ts

@@ -1,8 +0,0 @@
-// Import reflect-metadata to support TypeGraphQL
-import "reflect-metadata";
-
-import { vi } from "vitest";
-
-// Suppress console output during tests
-vi.spyOn(console, "log").mockImplementation(() => {});
-vi.spyOn(console, "error").mockImplementation(() => {});

package/tests/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "types": ["node", "vitest/globals"],
-    "esModuleInterop": true,
-    "noEmit": true,
-    "allowJs": true
-  },
-  "include": ["./**/*.ts"]
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "extends": "../tsconfig/base.json",
-  "compilerOptions": {
-    "types": ["node", "vitest/globals"],
-    "target": "es2022",
-    "lib": ["es2022", "dom", "dom.iterable"],
-    "useDefineForClassFields": false,
-    "emitDecoratorMetadata": true,
-    "experimentalDecorators": true,
-    "strict": false,
-    "resolveJsonModule": true
-  },
-  "include": [
-    "./src/**/*.ts",
-    "./src/**/*.test.ts",
-    "./src/**/__tests__/*",
-    "./tests/**/*.ts"
-  ],
-  "exclude": ["dist", "build", "node_modules"]
-}

package/tsdown.config.ts

@@ -1,45 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  entry: [
-    "src/index.ts",
-    "src/v2/index.ts",
-    "src/v2/express.ts",
-    "src/v2/hono.ts",
-    "src/v2/node.ts",
-    "src/langgraph.ts",
-  ],
-  format: ["esm", "cjs"],
-  dts: true,
-  sourcemap: true,
-  target: "es2022",
-  outDir: "dist",
-  unbundle: true,
-  banner: ({ format, fileName }) => {
-    // tsdown/rolldown reorders bare side-effect imports to the end of the entry chunk,
-    // breaking type-graphql which needs reflect-metadata at load time.
-    // The _virtual/_rolldown/runtime banner propagates to all output files per format,
-    // ensuring reflect-metadata is always the first thing that runs.
-    if (fileName.includes("_virtual/_rolldown/runtime")) {
-      return format === "cjs"
-        ? 'require("reflect-metadata");'
-        : 'import "reflect-metadata";';
-    }
-  },
-  external: [
-    "@ag-ui/langgraph",
-    "@langchain/core",
-    "@langchain/openai",
-    "@langchain/aws",
-    "@langchain/community",
-    "@langchain/google-gauth",
-    "@langchain/langgraph-sdk",
-    "langchain",
-    "@anthropic-ai/sdk",
-    "groq-sdk",
-    "@whatwg-node/fetch",
-    "@whatwg-node/server",
-    "rxjs",
-  ],
-  exports: true,
-});

package/typedoc.json

@@ -1,4 +0,0 @@
-{
-  "extends": ["../../typedoc.base.json"],
-  "entryPoints": ["src/index.ts"]
-}

package/vitest.config.mjs

@@ -1,13 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-    globals: true,
-    include: ["src/**/*.{test,spec}.ts", "tests/**/*.{test,spec}.ts"],
-    exclude: ["**/dist/**", "**/integration/bun/**"],
-    setupFiles: ["./tests/setup.vitest.ts"],
-    reporters: [["default", { summary: false }]],
-    silent: true,
-  },
-});