@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.1

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

@@ -1,344 +0,0 @@
-/**
- * Copilot Runtime adapter for the OpenAI Assistant API.
- *
- * ## Example
- *
- * ```ts
- * import { CopilotRuntime, OpenAIAssistantAdapter } from "@copilotkit/runtime";
- * import OpenAI from "openai";
- *
- * const copilotKit = new CopilotRuntime();
- *
- * const openai = new OpenAI({
- *   organization: "<your-organization-id>",
- *   apiKey: "<your-api-key>",
- * });
- *
- * return new OpenAIAssistantAdapter({
- *   openai,
- *   assistantId: "<your-assistant-id>",
- *   codeInterpreterEnabled: true,
- *   fileSearchEnabled: true,
- * });
- * ```
- */
-import type OpenAI from "openai";
-import type { RunSubmitToolOutputsStreamParams } from "openai/resources/beta/threads/runs/runs";
-import type { AssistantStream } from "openai/lib/AssistantStream";
-import type { AssistantStreamEvent, AssistantTool } from "openai/resources/beta/assistants";
-import {
-  CopilotServiceAdapter,
-  CopilotRuntimeChatCompletionRequest,
-  CopilotRuntimeChatCompletionResponse,
-} from "../service-adapter";
-import { Message, ResultMessage, TextMessage } from "../../graphql/types/converted";
-import {
-  convertActionInputToOpenAITool,
-  convertMessageToOpenAIMessage,
-  convertSystemMessageToAssistantAPI,
-} from "./utils";
-import { RuntimeEventSource } from "../events";
-import { ActionInput } from "../../graphql/inputs/action.input";
-import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
-
-export interface OpenAIAssistantAdapterParams {
-  /**
-   * The ID of the assistant to use.
-   */
-  assistantId: string;
-
-  /**
-   * An optional OpenAI instance to use. If not provided, a new instance will be created.
-   */
-  openai?: OpenAI;
-
-  /**
-   * Whether to enable code interpretation.
-   * @default true
-   */
-  codeInterpreterEnabled?: boolean;
-
-  /**
-   * Whether to enable file search.
-   * @default true
-   */
-  fileSearchEnabled?: boolean;
-
-  /**
-   * Whether to disable parallel tool calls.
-   * You can disable parallel tool calls to force the model to execute tool calls sequentially.
-   * This is useful if you want to execute tool calls in a specific order so that the state changes
-   * introduced by one tool call are visible to the next tool call. (i.e. new actions or readables)
-   *
-   * @default false
-   */
-  disableParallelToolCalls?: boolean;
-
-  /**
-   * Whether to keep the role in system messages as "System".
-   * By default, it is converted to "developer", which is used by newer OpenAI models
-   *
-   * @default false
-   */
-  keepSystemRole?: boolean;
-}
-
-export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
-  private _openai: OpenAI;
-  private codeInterpreterEnabled: boolean;
-  private assistantId: string;
-  private fileSearchEnabled: boolean;
-  private disableParallelToolCalls: boolean;
-  private keepSystemRole: boolean = false;
-
-  public get name() {
-    return "OpenAIAssistantAdapter";
-  }
-
-  constructor(params: OpenAIAssistantAdapterParams) {
-    if (params.openai) {
-      this._openai = params.openai;
-    }
-    // If no instance provided, we'll lazy-load in ensureOpenAI()
-    this.codeInterpreterEnabled = params.codeInterpreterEnabled === false || true;
-    this.fileSearchEnabled = params.fileSearchEnabled === false || true;
-    this.assistantId = params.assistantId;
-    this.disableParallelToolCalls = params?.disableParallelToolCalls || false;
-    this.keepSystemRole = params?.keepSystemRole ?? false;
-  }
-
-  private ensureOpenAI(): OpenAI {
-    if (!this._openai) {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      const OpenAI = require("openai").default;
-      this._openai = new OpenAI({});
-    }
-    return this._openai;
-  }
-
-  async process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse> {
-    const { messages, actions, eventSource, runId, forwardedParameters } = request;
-
-    // if we don't have a threadId, create a new thread
-    let threadId = request.extensions?.openaiAssistantAPI?.threadId;
-    const openai = this.ensureOpenAI();
-
-    if (!threadId) {
-      threadId = (await openai.beta.threads.create()).id;
-    }
-
-    const lastMessage = messages.at(-1);
-
-    let nextRunId: string | undefined = undefined;
-
-    // submit function outputs
-    if (lastMessage.isResultMessage() && runId) {
-      nextRunId = await this.submitToolOutputs(threadId, runId, messages, eventSource);
-    }
-    // submit user message
-    else if (lastMessage.isTextMessage()) {
-      nextRunId = await this.submitUserMessage(
-        threadId,
-        messages,
-        actions,
-        eventSource,
-        forwardedParameters,
-      );
-    }
-    // unsupported message
-    else {
-      throw new Error("No actionable message found in the messages");
-    }
-
-    return {
-      runId: nextRunId,
-      threadId,
-      extensions: {
-        ...request.extensions,
-        openaiAssistantAPI: {
-          threadId: threadId,
-          runId: nextRunId,
-        },
-      },
-    };
-  }
-
-  private async submitToolOutputs(
-    threadId: string,
-    runId: string,
-    messages: Message[],
-    eventSource: RuntimeEventSource,
-  ) {
-    const openai = this.ensureOpenAI();
-    let run = await openai.beta.threads.runs.retrieve(threadId, runId);
-
-    if (!run.required_action) {
-      throw new Error("No tool outputs required");
-    }
-
-    // get the required tool call ids
-    const toolCallsIds = run.required_action.submit_tool_outputs.tool_calls.map(
-      (toolCall) => toolCall.id,
-    );
-
-    // search for these tool calls
-    const resultMessages = messages.filter(
-      (message) => message.isResultMessage() && toolCallsIds.includes(message.actionExecutionId),
-    ) as ResultMessage[];
-
-    if (toolCallsIds.length != resultMessages.length) {
-      throw new Error("Number of function results does not match the number of tool calls");
-    }
-
-    // submit the tool outputs
-    const toolOutputs: RunSubmitToolOutputsStreamParams.ToolOutput[] = resultMessages.map(
-      (message) => {
-        return {
-          tool_call_id: message.actionExecutionId,
-          output: message.result,
-        };
-      },
-    );
-
-    const stream = openai.beta.threads.runs.submitToolOutputsStream(threadId, runId, {
-      tool_outputs: toolOutputs,
-      ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
-    });
-
-    await this.streamResponse(stream, eventSource);
-    return runId;
-  }
-
-  private async submitUserMessage(
-    threadId: string,
-    messages: Message[],
-    actions: ActionInput[],
-    eventSource: RuntimeEventSource,
-    forwardedParameters: ForwardedParametersInput,
-  ) {
-    const openai = this.ensureOpenAI();
-    messages = [...messages];
-
-    // get the instruction message
-    const instructionsMessage = messages.shift();
-    const instructions = instructionsMessage.isTextMessage() ? instructionsMessage.content : "";
-
-    // get the latest user message
-    const userMessage = messages
-      .map((m) => convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }))
-      .map(convertSystemMessageToAssistantAPI)
-      .at(-1);
-
-    if (userMessage.role !== "user") {
-      throw new Error("No user message found");
-    }
-
-    await openai.beta.threads.messages.create(threadId, {
-      role: "user",
-      content: userMessage.content,
-    });
-
-    const openaiTools = actions.map(convertActionInputToOpenAITool);
-
-    const tools = [
-      ...openaiTools,
-      ...(this.codeInterpreterEnabled ? [{ type: "code_interpreter" } as AssistantTool] : []),
-      ...(this.fileSearchEnabled ? [{ type: "file_search" } as AssistantTool] : []),
-    ];
-
-    let stream = openai.beta.threads.runs.stream(threadId, {
-      assistant_id: this.assistantId,
-      instructions,
-      tools: tools,
-      ...(forwardedParameters?.maxTokens && {
-        max_completion_tokens: forwardedParameters.maxTokens,
-      }),
-      ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
-    });
-
-    await this.streamResponse(stream, eventSource);
-
-    return getRunIdFromStream(stream);
-  }
-
-  private async streamResponse(stream: AssistantStream, eventSource: RuntimeEventSource) {
-    eventSource.stream(async (eventStream$) => {
-      let inFunctionCall = false;
-      let currentMessageId: string;
-      let currentToolCallId: string;
-
-      for await (const chunk of stream) {
-        switch (chunk.event) {
-          case "thread.message.created":
-            if (inFunctionCall) {
-              eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
-            }
-            currentMessageId = chunk.data.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
-            break;
-          case "thread.message.delta":
-            if (chunk.data.delta.content?.[0].type === "text") {
-              eventStream$.sendTextMessageContent({
-                messageId: currentMessageId,
-                content: chunk.data.delta.content?.[0].text.value,
-              });
-            }
-            break;
-          case "thread.message.completed":
-            eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-            break;
-          case "thread.run.step.delta":
-            let toolCallId: string | undefined;
-            let toolCallName: string | undefined;
-            let toolCallArgs: string | undefined;
-            if (
-              chunk.data.delta.step_details.type === "tool_calls" &&
-              chunk.data.delta.step_details.tool_calls?.[0].type === "function"
-            ) {
-              toolCallId = chunk.data.delta.step_details.tool_calls?.[0].id;
-              toolCallName = chunk.data.delta.step_details.tool_calls?.[0].function.name;
-              toolCallArgs = chunk.data.delta.step_details.tool_calls?.[0].function.arguments;
-            }
-
-            if (toolCallName && toolCallId) {
-              if (inFunctionCall) {
-                eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
-              }
-              inFunctionCall = true;
-              currentToolCallId = toolCallId;
-              eventStream$.sendActionExecutionStart({
-                actionExecutionId: currentToolCallId,
-                parentMessageId: chunk.data.id,
-                actionName: toolCallName,
-              });
-            } else if (toolCallArgs) {
-              eventStream$.sendActionExecutionArgs({
-                actionExecutionId: currentToolCallId,
-                args: toolCallArgs,
-              });
-            }
-            break;
-        }
-      }
-      if (inFunctionCall) {
-        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
-      }
-      eventStream$.complete();
-    });
-  }
-}
-
-function getRunIdFromStream(stream: AssistantStream): Promise<string> {
-  return new Promise<string>((resolve, reject) => {
-    let runIdGetter = (event: AssistantStreamEvent) => {
-      if (event.event === "thread.run.created") {
-        const runId = event.data.id;
-        stream.off("event", runIdGetter);
-        resolve(runId);
-      }
-    };
-    stream.on("event", runIdGetter);
-  });
-}

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

@@ -1,199 +0,0 @@
-import { Message } from "../../graphql/types/converted";
-import { ActionInput } from "../../graphql/inputs/action.input";
-import {
-  ChatCompletionAssistantMessageParam,
-  ChatCompletionMessageParam,
-  ChatCompletionSystemMessageParam,
-  ChatCompletionTool,
-  ChatCompletionUserMessageParam,
-  ChatCompletionDeveloperMessageParam,
-} from "openai/resources/chat";
-import { parseJson } from "@copilotkit/shared";
-
-export function limitMessagesToTokenCount(
-  messages: any[],
-  tools: any[],
-  model: string,
-  maxTokens?: number,
-): any[] {
-  maxTokens ||= maxTokensForOpenAIModel(model);
-
-  const result: any[] = [];
-  const toolsNumTokens = countToolsTokens(model, tools);
-  if (toolsNumTokens > maxTokens) {
-    throw new Error(`Too many tokens in function definitions: ${toolsNumTokens} > ${maxTokens}`);
-  }
-  maxTokens -= toolsNumTokens;
-
-  for (const message of messages) {
-    if (["system", "developer"].includes(message.role)) {
-      const numTokens = countMessageTokens(model, message);
-      maxTokens -= numTokens;
-
-      if (maxTokens < 0) {
-        throw new Error("Not enough tokens for system message.");
-      }
-    }
-  }
-
-  let cutoff: boolean = false;
-
-  const reversedMessages = [...messages].reverse();
-  for (const message of reversedMessages) {
-    if (["system", "developer"].includes(message.role)) {
-      result.unshift(message);
-      continue;
-    } else if (cutoff) {
-      continue;
-    }
-    let numTokens = countMessageTokens(model, message);
-    if (maxTokens < numTokens) {
-      cutoff = true;
-      continue;
-    }
-    result.unshift(message);
-    maxTokens -= numTokens;
-  }
-
-  return result;
-}
-
-export function maxTokensForOpenAIModel(model: string): number {
-  return maxTokensByModel[model] || DEFAULT_MAX_TOKENS;
-}
-
-const DEFAULT_MAX_TOKENS = 128000;
-
-const maxTokensByModel: { [key: string]: number } = {
-  // o1
-  o1: 200000,
-  "o1-2024-12-17": 200000,
-  "o1-mini": 128000,
-  "o1-mini-2024-09-12": 128000,
-  "o1-preview": 128000,
-  "o1-preview-2024-09-12": 128000,
-  // o3-mini
-  "o3-mini": 200000,
-  "o3-mini-2025-01-31": 200000,
-  // GPT-4
-  "gpt-4o": 128000,
-  "chatgpt-4o-latest": 128000,
-  "gpt-4o-2024-08-06": 128000,
-  "gpt-4o-2024-05-13": 128000,
-  "gpt-4o-mini": 128000,
-  "gpt-4o-mini-2024-07-18": 128000,
-  "gpt-4-turbo": 128000,
-  "gpt-4-turbo-2024-04-09": 128000,
-  "gpt-4-0125-preview": 128000,
-  "gpt-4-turbo-preview": 128000,
-  "gpt-4-1106-preview": 128000,
-  "gpt-4-vision-preview": 128000,
-  "gpt-4-1106-vision-preview": 128000,
-  "gpt-4-32k": 32768,
-  "gpt-4-32k-0613": 32768,
-  "gpt-4-32k-0314": 32768,
-  "gpt-4": 8192,
-  "gpt-4-0613": 8192,
-  "gpt-4-0314": 8192,
-
-  // GPT-3.5
-  "gpt-3.5-turbo-0125": 16385,
-  "gpt-3.5-turbo": 16385,
-  "gpt-3.5-turbo-1106": 16385,
-  "gpt-3.5-turbo-instruct": 4096,
-  "gpt-3.5-turbo-16k": 16385,
-  "gpt-3.5-turbo-0613": 4096,
-  "gpt-3.5-turbo-16k-0613": 16385,
-  "gpt-3.5-turbo-0301": 4097,
-};
-
-function countToolsTokens(model: string, tools: any[]): number {
-  if (tools.length === 0) {
-    return 0;
-  }
-  const json = JSON.stringify(tools);
-  return countTokens(model, json);
-}
-
-function countMessageTokens(model: string, message: any): number {
-  return countTokens(model, message.content || "");
-}
-
-function countTokens(model: string, text: string): number {
-  return text.length / 3;
-}
-
-export function convertActionInputToOpenAITool(action: ActionInput): ChatCompletionTool {
-  return {
-    type: "function",
-    function: {
-      name: action.name,
-      description: action.description,
-      parameters: parseJson(action.jsonSchema, {}),
-    },
-  };
-}
-
-type UsedMessageParams =
-  | ChatCompletionUserMessageParam
-  | ChatCompletionAssistantMessageParam
-  | ChatCompletionDeveloperMessageParam
-  | ChatCompletionSystemMessageParam;
-export function convertMessageToOpenAIMessage(
-  message: Message,
-  options?: { keepSystemRole: boolean },
-): ChatCompletionMessageParam {
-  const { keepSystemRole } = options || { keepSystemRole: false };
-  if (message.isTextMessage()) {
-    let role = message.role as UsedMessageParams["role"];
-    if (message.role === "system" && !keepSystemRole) {
-      role = "developer";
-    }
-    return {
-      role,
-      content: message.content,
-    } satisfies UsedMessageParams;
-  } else if (message.isImageMessage()) {
-    return {
-      role: "user",
-      content: [
-        {
-          type: "image_url",
-          image_url: {
-            url: `data:image/${message.format};base64,${message.bytes}`,
-          },
-        },
-      ],
-    } satisfies UsedMessageParams;
-  } else if (message.isActionExecutionMessage()) {
-    return {
-      role: "assistant",
-      tool_calls: [
-        {
-          id: message.id,
-          type: "function",
-          function: {
-            name: message.name,
-            arguments: JSON.stringify(message.arguments),
-          },
-        },
-      ],
-    };
-  } else if (message.isResultMessage()) {
-    return {
-      role: "tool",
-      content: message.result,
-      tool_call_id: message.actionExecutionId,
-    };
-  }
-}
-
-export function convertSystemMessageToAssistantAPI(message: ChatCompletionMessageParam) {
-  return {
-    ...message,
-    ...(["system", "developer"].includes(message.role) && {
-      role: "assistant",
-      content: "THE FOLLOWING MESSAGE IS A SYSTEM MESSAGE: " + message.content,
-    }),
-  };
-}

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

@@ -1,41 +0,0 @@
-import { Message } from "../graphql/types/converted";
-import { RuntimeEventSource } from "./events";
-import { ActionInput } from "../graphql/inputs/action.input";
-import { ForwardedParametersInput } from "../graphql/inputs/forwarded-parameters.input";
-import { ExtensionsInput } from "../graphql/inputs/extensions.input";
-import { ExtensionsResponse } from "../graphql/types/extensions-response.type";
-import { AgentSessionInput } from "../graphql/inputs/agent-session.input";
-import { AgentStateInput } from "../graphql/inputs/agent-state.input";
-
-export interface CopilotKitResponse {
-  stream: ReadableStream;
-  headers?: Record<string, string>;
-}
-
-export interface CopilotRuntimeChatCompletionRequest {
-  eventSource: RuntimeEventSource;
-  messages: Message[];
-  actions: ActionInput[];
-  model?: string;
-  threadId?: string;
-  runId?: string;
-  forwardedParameters?: ForwardedParametersInput;
-  extensions?: ExtensionsInput;
-  agentSession?: AgentSessionInput;
-  agentStates?: AgentStateInput[];
-}
-
-export interface CopilotRuntimeChatCompletionResponse {
-  threadId: string;
-  runId?: string;
-  extensions?: ExtensionsResponse;
-}
-
-export interface CopilotServiceAdapter {
-  provider?: string;
-  model?: string;
-  process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse>;
-  name?: string;
-}

package/src/service-adapters/shared/error-utils.ts

@@ -1,61 +0,0 @@
-import { CopilotKitLowLevelError, CopilotKitErrorCode } from "@copilotkit/shared";
-
-/**
- * Converts service adapter errors to structured CopilotKitError format using HTTP status codes.
- * This provides consistent error classification across all service adapters.
- */
-export function convertServiceAdapterError(
-  error: any,
-  adapterName: string,
-): CopilotKitLowLevelError {
-  const errorName = error?.constructor?.name || error.name;
-  const errorMessage = error?.message || String(error);
-  const statusCode = error.status || error.statusCode || error.response?.status;
-  const responseData = error.error || error.response?.data || error.data;
-
-  // Create the base error with the constructor signature
-  const structuredError = new CopilotKitLowLevelError({
-    error: error instanceof Error ? error : new Error(errorMessage),
-    url: `${adapterName} service adapter`,
-    message: `${adapterName} API error: ${errorMessage}`,
-  });
-
-  // Add additional properties after construction
-  if (statusCode) {
-    (structuredError as any).statusCode = statusCode;
-  }
-  if (responseData) {
-    (structuredError as any).responseData = responseData;
-  }
-  if (errorName) {
-    (structuredError as any).originalErrorType = errorName;
-  }
-
-  // Classify error based on HTTP status codes (reliable and provider-agnostic)
-  let newCode: CopilotKitErrorCode;
-
-  if (statusCode === 401) {
-    // 401 = Authentication/API key issues
-    newCode = CopilotKitErrorCode.AUTHENTICATION_ERROR;
-  } else if (statusCode >= 400 && statusCode < 500) {
-    // 4xx = Client errors (bad request, invalid params, etc.) - these are configuration issues
-    newCode = CopilotKitErrorCode.CONFIGURATION_ERROR;
-  } else if (statusCode >= 500) {
-    // 5xx = Server errors - keep as NETWORK_ERROR since it's infrastructure related
-    newCode = CopilotKitErrorCode.NETWORK_ERROR;
-  } else if (statusCode) {
-    // Any other HTTP status with an error - likely configuration
-    newCode = CopilotKitErrorCode.CONFIGURATION_ERROR;
-  } else {
-    // No status code - likely a genuine network/connection error
-    newCode = CopilotKitErrorCode.NETWORK_ERROR;
-  }
-
-  // Update both the instance property and the extensions
-  (structuredError as any).code = newCode;
-  if ((structuredError as any).extensions) {
-    (structuredError as any).extensions.code = newCode;
-  }
-
-  return structuredError;
-}

package/src/service-adapters/shared/index.ts

@@ -1 +0,0 @@
-export * from "./error-utils";