@copilotkit/runtime 1.55.3 → 1.56.1

package/src/service-adapters/openai/__tests__/openai-v5-compat.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi } from "vitest";
+import {
+  isOpenAIV5,
+  getChatCompletionsForStreaming,
+  retrieveThreadRun,
+  submitToolOutputsStream,
+} from "../utils";
+import type OpenAI from "openai";
+
+/**
+ * Tests for OpenAI SDK v4/v5 compatibility layer.
+ *
+ * In v5, the `beta.chat` namespace was removed and promoted to `chat`.
+ * In v5, methods with multiple path params switched to named params
+ * (e.g. runs.retrieve(runId, { thread_id }) instead of runs.retrieve(threadId, runId)).
+ */
+
+function createMockV4Client() {
+  const streamFn = vi.fn();
+  return {
+    client: {
+      beta: {
+        chat: {
+          completions: { stream: streamFn },
+        },
+        threads: {
+          create: vi.fn(),
+          runs: {
+            retrieve: vi.fn().mockResolvedValue({ id: "run_xyz" }),
+            stream: vi.fn(),
+            submitToolOutputsStream: vi.fn(),
+          },
+          messages: {
+            create: vi.fn(),
+          },
+        },
+      },
+      chat: {
+        completions: {
+          stream: vi.fn(), // exists but should NOT be used for streaming in v4
+        },
+      },
+    } as unknown as OpenAI,
+    streamFn,
+  };
+}
+
+function createMockV5Client() {
+  const streamFn = vi.fn();
+  return {
+    client: {
+      // v5: beta.chat is gone, only beta.threads remains
+      beta: {
+        threads: {
+          create: vi.fn(),
+          runs: {
+            retrieve: vi.fn().mockResolvedValue({ id: "run_xyz" }),
+            stream: vi.fn(),
+            submitToolOutputsStream: vi.fn(),
+          },
+          messages: {
+            create: vi.fn(),
+          },
+        },
+      },
+      chat: {
+        completions: {
+          stream: streamFn,
+        },
+      },
+    } as unknown as OpenAI,
+    streamFn,
+  };
+}
+
+describe("isOpenAIV5", () => {
+  it("returns false for a v4 client (beta.chat exists)", () => {
+    const { client } = createMockV4Client();
+    expect(isOpenAIV5(client)).toBe(false);
+  });
+
+  it("returns true for a v5 client (beta.chat does not exist)", () => {
+    const { client } = createMockV5Client();
+    expect(isOpenAIV5(client)).toBe(true);
+  });
+
+  it("returns true when beta is entirely missing", () => {
+    const client = { chat: { completions: {} } } as unknown as OpenAI;
+    expect(isOpenAIV5(client)).toBe(true);
+  });
+});
+
+describe("getChatCompletionsForStreaming", () => {
+  it("returns beta.chat.completions for a v4 client", () => {
+    const { client } = createMockV4Client();
+    const completions = getChatCompletionsForStreaming(client);
+    // Should be the beta version, not the top-level one
+    expect(completions).not.toBe(client.chat.completions);
+  });
+
+  it("returns chat.completions for a v5 client", () => {
+    const { client } = createMockV5Client();
+    const completions = getChatCompletionsForStreaming(client);
+    expect(completions).toBe(client.chat.completions);
+  });
+
+  it("stream() on v4 calls beta.chat.completions.stream", () => {
+    const { client, streamFn } = createMockV4Client();
+    const completions = getChatCompletionsForStreaming(client);
+    completions.stream({ model: "gpt-4o", messages: [] });
+    expect(streamFn).toHaveBeenCalledWith({ model: "gpt-4o", messages: [] });
+  });
+
+  it("stream() on v5 calls chat.completions.stream", () => {
+    const { client, streamFn } = createMockV5Client();
+    const completions = getChatCompletionsForStreaming(client);
+    completions.stream({ model: "gpt-4o", messages: [] });
+    expect(streamFn).toHaveBeenCalledWith({ model: "gpt-4o", messages: [] });
+  });
+});
+
+describe("retrieveThreadRun", () => {
+  it("v4: calls retrieve with positional args (threadId, runId)", async () => {
+    const { client } = createMockV4Client();
+    const retrieveFn = client.beta.threads.runs.retrieve as ReturnType<
+      typeof vi.fn
+    >;
+
+    await retrieveThreadRun(client, "thread_abc", "run_xyz");
+
+    expect(retrieveFn).toHaveBeenCalledWith("thread_abc", "run_xyz");
+  });
+
+  it("v5: calls retrieve with named path params (runId, { thread_id })", async () => {
+    const { client } = createMockV5Client();
+    const retrieveFn = client.beta.threads.runs.retrieve as ReturnType<
+      typeof vi.fn
+    >;
+
+    await retrieveThreadRun(client, "thread_abc", "run_xyz");
+
+    expect(retrieveFn).toHaveBeenCalledWith("run_xyz", {
+      thread_id: "thread_abc",
+    });
+  });
+});
+
+describe("submitToolOutputsStream", () => {
+  it("v4: calls with positional args (threadId, runId, body)", () => {
+    const { client } = createMockV4Client();
+    const submitFn = client.beta.threads.runs
+      .submitToolOutputsStream as ReturnType<typeof vi.fn>;
+    const body = {
+      tool_outputs: [{ tool_call_id: "tc_1", output: "result" }],
+    };
+
+    submitToolOutputsStream(client, "thread_abc", "run_xyz", body);
+
+    expect(submitFn).toHaveBeenCalledWith("thread_abc", "run_xyz", body);
+  });
+
+  it("v5: calls with named path params (runId, { thread_id, ...body })", () => {
+    const { client } = createMockV5Client();
+    const submitFn = client.beta.threads.runs
+      .submitToolOutputsStream as ReturnType<typeof vi.fn>;
+    const body = {
+      tool_outputs: [{ tool_call_id: "tc_1", output: "result" }],
+    };
+
+    submitToolOutputsStream(client, "thread_abc", "run_xyz", body);
+
+    expect(submitFn).toHaveBeenCalledWith("run_xyz", {
+      thread_id: "thread_abc",
+      ...body,
+    });
+  });
+});

package/src/service-adapters/openai/openai-adapter.ts

@@ -61,6 +61,7 @@ import {
   convertActionInputToOpenAITool,
   convertMessageToOpenAIMessage,
   limitMessagesToTokenCount,
+  getChatCompletionsForStreaming,
 } from "./utils";
 import { randomUUID } from "@copilotkit/shared";
 import { convertServiceAdapterError, getSdkClientOptions } from "../shared";
@@ -96,6 +97,12 @@ export interface OpenAIAdapterParams {
    * @default false
    */
   keepSystemRole?: boolean;
+
+  /**
+   * Optional maximum input token limit. Overrides the default model-based limit
+   * used when trimming messages to fit the context window.
+   */
+  maxInputTokens?: number;
 }
 
 export class OpenAIAdapter implements CopilotServiceAdapter {
@@ -105,6 +112,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
   private disableParallelToolCalls: boolean = false;
   private _openai: OpenAI;
   private keepSystemRole: boolean = false;
+  private maxInputTokens?: number;
 
   public get openai(): OpenAI {
     return this._openai;
@@ -124,6 +132,7 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     }
     this.disableParallelToolCalls = params?.disableParallelToolCalls || false;
     this.keepSystemRole = params?.keepSystemRole ?? false;
+    this.maxInputTokens = params?.maxInputTokens;
   }
 
   getLanguageModel(): LanguageModel {
@@ -191,7 +200,12 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     let openaiMessages = filteredMessages.map((m) =>
       convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }),
     );
-    openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
+    openaiMessages = limitMessagesToTokenCount(
+      openaiMessages,
+      tools,
+      model,
+      this.maxInputTokens,
+    );
 
     let toolChoice: any = forwardedParameters?.toolChoice;
     if (forwardedParameters?.toolChoice === "function") {
@@ -203,7 +217,8 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
 
     try {
       const openai = this.ensureOpenAI();
-      const stream = openai.beta.chat.completions.stream({
+      const completions = getChatCompletionsForStreaming(openai);
+      const stream = completions.stream({
         model: model,
         stream: true,
         messages: openaiMessages,

package/src/service-adapters/openai/openai-assistant-adapter.ts

@@ -43,6 +43,8 @@ import {
   convertActionInputToOpenAITool,
   convertMessageToOpenAIMessage,
   convertSystemMessageToAssistantAPI,
+  retrieveThreadRun,
+  submitToolOutputsStream,
 } from "./utils";
 import { RuntimeEventSource } from "../events";
 import { ActionInput } from "../../graphql/inputs/action.input";
@@ -186,7 +188,7 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
     eventSource: RuntimeEventSource,
   ) {
     const openai = this.ensureOpenAI();
-    let run = await openai.beta.threads.runs.retrieve(threadId, runId);
+    let run = await retrieveThreadRun(openai, threadId, runId);
 
     if (!run.required_action) {
       throw new Error("No tool outputs required");
@@ -219,14 +221,10 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
         };
       });
 
-    const stream = openai.beta.threads.runs.submitToolOutputsStream(
-      threadId,
-      runId,
-      {
-        tool_outputs: toolOutputs,
-        ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
-      },
-    );
+    const stream = submitToolOutputsStream(openai, threadId, runId, {
+      tool_outputs: toolOutputs,
+      ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
+    });
 
     await this.streamResponse(stream, eventSource);
     return runId;

package/src/service-adapters/openai/utils.ts

@@ -1,3 +1,4 @@
+import type OpenAI from "openai";
 import { Message } from "../../graphql/types/converted";
 import { ActionInput } from "../../graphql/inputs/action.input";
 import {
@@ -10,6 +11,105 @@ import {
 } from "openai/resources/chat";
 import { parseJson } from "@copilotkit/shared";
 
+/**
+ * OpenAI v4 exposes streaming completions under `beta.chat.completions`.
+ * v5 removed `beta.chat` and promoted streaming to `chat.completions`.
+ * These interfaces model the v4-specific shape so we can detect and access
+ * the beta namespace safely without `as any`.
+ */
+interface OpenAIV4BetaChat {
+  chat: {
+    completions: OpenAI["chat"]["completions"];
+  };
+}
+
+interface OpenAIV4Beta extends OpenAI.Beta {
+  chat: OpenAIV4BetaChat["chat"];
+}
+
+/**
+ * Type guard: checks whether the OpenAI client has the v4-era `beta.chat`
+ * namespace. Returns `false` for v5+ clients where `beta.chat` was removed.
+ */
+function hasV4BetaChat(beta: OpenAI["beta"] | undefined): beta is OpenAIV4Beta {
+  return beta != null && "chat" in beta && (beta as OpenAIV4Beta).chat != null;
+}
+
+/**
+ * Detects whether the provided OpenAI client is v5+ by checking for the
+ * removal of the `beta.chat` namespace (which was promoted to `chat` in v5).
+ */
+export function isOpenAIV5(openai: OpenAI): boolean {
+  return !hasV4BetaChat(openai.beta);
+}
+
+/**
+ * Returns the chat completions object that supports `.stream()`.
+ * In v4 this lives under `openai.beta.chat.completions`;
+ * in v5 it was promoted to `openai.chat.completions`.
+ */
+export function getChatCompletionsForStreaming(
+  openai: OpenAI,
+): OpenAI["chat"]["completions"] {
+  if (hasV4BetaChat(openai.beta)) {
+    return openai.beta.chat.completions;
+  }
+  return openai.chat.completions;
+}
+
+/**
+ * Retrieves a thread run, handling the v4→v5 API signature change.
+ * v4: retrieve(threadId, runId)
+ * v5: retrieve(runId, { thread_id: threadId })
+ */
+export async function retrieveThreadRun(
+  openai: OpenAI,
+  threadId: string,
+  runId: string,
+): Promise<OpenAI.Beta.Threads.Runs.Run> {
+  if (isOpenAIV5(openai)) {
+    // v5 switched to named path params. The type definitions from whichever
+    // SDK version is installed won't match both signatures, so we call through
+    // a generic function reference. This is the one unavoidable boundary
+    // between two incompatible SDK type surfaces.
+    const retrieve = openai.beta.threads.runs.retrieve as {
+      (...args: unknown[]): Promise<OpenAI.Beta.Threads.Runs.Run>;
+    };
+    return retrieve(runId, { thread_id: threadId });
+  }
+  return openai.beta.threads.runs.retrieve(threadId, runId);
+}
+
+/**
+ * Submits tool outputs as a stream, handling the v4→v5 API signature change.
+ * v4: submitToolOutputsStream(threadId, runId, body)
+ * v5: submitToolOutputsStream(runId, { thread_id, ...body })
+ */
+export function submitToolOutputsStream(
+  openai: OpenAI,
+  threadId: string,
+  runId: string,
+  body: {
+    tool_outputs: Array<{ tool_call_id: string; output: string }>;
+    parallel_tool_calls?: false;
+  },
+) {
+  if (isOpenAIV5(openai)) {
+    // Same boundary as retrieveThreadRun — v5 uses named path params.
+    const submit = openai.beta.threads.runs.submitToolOutputsStream as {
+      (
+        ...args: unknown[]
+      ): ReturnType<typeof openai.beta.threads.runs.submitToolOutputsStream>;
+    };
+    return submit(runId, { thread_id: threadId, ...body });
+  }
+  return openai.beta.threads.runs.submitToolOutputsStream(
+    threadId,
+    runId,
+    body,
+  );
+}
+
 export function limitMessagesToTokenCount(
   messages: any[],
   tools: any[],

package/src/v2/runtime/__tests__/agents-factory.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi } from "vitest";
+import { HttpAgent } from "@ag-ui/client";
+import {
+  resolveAgents,
+  type AgentsConfig,
+  type AgentFactoryContext,
+} from "../core/runtime";
+import { handleRunAgent } from "../handlers/handle-run";
+import { handleGetRuntimeInfo } from "../handlers/get-runtime-info";
+import { CopilotRuntime } from "../core/runtime";
+
+function createMockAgent(name = "test") {
+  return new HttpAgent({ url: `https://example.com/${name}` });
+}
+
+function createMockRuntime(agents: AgentsConfig) {
+  return {
+    agents,
+    transcriptionService: undefined,
+    beforeRequestMiddleware: undefined,
+    afterRequestMiddleware: undefined,
+    runner: { stop: vi.fn().mockResolvedValue(true) },
+    mode: "sse",
+  } as unknown as CopilotRuntime;
+}
+
+function createMockRequest(headers?: Record<string, string>) {
+  return new Request("https://example.com/agent/test/run", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...headers },
+    body: JSON.stringify({ threadId: "thread-1", messages: [], state: {} }),
+  });
+}
+
+describe("resolveAgents", () => {
+  it("resolves a static record", async () => {
+    const agents = { default: createMockAgent() };
+    const result = await resolveAgents(agents);
+    expect(result).toBe(agents);
+  });
+
+  it("resolves a Promise", async () => {
+    const agents = { default: createMockAgent() };
+    const result = await resolveAgents(Promise.resolve(agents));
+    expect(result).toEqual(agents);
+  });
+
+  it("calls a factory function with request context", async () => {
+    const agent = createMockAgent();
+    const factory = vi.fn().mockReturnValue({ default: agent });
+    const request = createMockRequest({ "x-tenant-id": "tenant-123" });
+
+    const result = await resolveAgents(factory, request);
+
+    expect(factory).toHaveBeenCalledTimes(1);
+    expect(factory).toHaveBeenCalledWith({ request });
+    expect(result).toEqual({ default: agent });
+  });
+
+  it("calls an async factory function", async () => {
+    const agent = createMockAgent();
+    const factory = vi.fn().mockResolvedValue({ default: agent });
+    const request = createMockRequest();
+
+    const result = await resolveAgents(factory, request);
+    expect(factory).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({ default: agent });
+  });
+
+  it("throws when factory is used without a request", async () => {
+    const factory = vi.fn().mockReturnValue({ default: createMockAgent() });
+
+    await expect(resolveAgents(factory)).rejects.toThrow(
+      "Agent factory function requires a request context",
+    );
+    expect(factory).not.toHaveBeenCalled();
+  });
+
+  it("factory can read request headers for per-tenant resolution", async () => {
+    const tenantAgentA = createMockAgent("tenant-a");
+    const tenantAgentB = createMockAgent("tenant-b");
+
+    const factory = ({ request }: AgentFactoryContext) => {
+      const tenantId = request.headers.get("x-tenant-id");
+      if (tenantId === "a") return { default: tenantAgentA };
+      return { default: tenantAgentB };
+    };
+
+    const requestA = createMockRequest({ "x-tenant-id": "a" });
+    const requestB = createMockRequest({ "x-tenant-id": "b" });
+
+    const resultA = await resolveAgents(factory, requestA);
+    expect(resultA.default).toBe(tenantAgentA);
+
+    const resultB = await resolveAgents(factory, requestB);
+    expect(resultB.default).toBe(tenantAgentB);
+  });
+});
+
+describe("handleRunAgent with agents factory", () => {
+  it("returns 404 when factory returns no matching agent", async () => {
+    const factory = vi.fn().mockReturnValue({
+      other: createMockAgent("other"),
+    });
+    const runtime = createMockRuntime(factory);
+    const request = createMockRequest();
+
+    const response = await handleRunAgent({
+      runtime,
+      request,
+      agentId: "nonexistent",
+    });
+
+    expect(response.status).toBe(404);
+    expect(factory).toHaveBeenCalledWith({ request });
+  });
+});
+
+describe("handleGetRuntimeInfo with agents factory", () => {
+  it("resolves factory and lists agents", async () => {
+    const factory = vi.fn().mockReturnValue({
+      support: createMockAgent("support"),
+      technical: createMockAgent("technical"),
+    });
+    const runtime = createMockRuntime(factory);
+    const request = createMockRequest();
+
+    const response = await handleGetRuntimeInfo({ runtime, request });
+
+    expect(response.status).toBe(200);
+    const body = await response.json();
+    expect(Object.keys(body.agents)).toContain("support");
+    expect(Object.keys(body.agents)).toContain("technical");
+    expect(factory).toHaveBeenCalledWith({ request });
+  });
+});