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

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

@@ -1,324 +0,0 @@
-/**
- * Copilot Runtime adapter for OpenAI.
- *
- * ## Example
- *
- * ```ts
- * import { CopilotRuntime, OpenAIAdapter } from "@copilotkit/runtime";
- * import OpenAI from "openai";
- *
- * const copilotKit = new CopilotRuntime();
- *
- * const openai = new OpenAI({
- *   organization: "<your-organization-id>", // optional
- *   apiKey: "<your-api-key>",
- * });
- *
- * return new OpenAIAdapter({ openai });
- * ```
- *
- * ## Example with Azure OpenAI
- *
- * ```ts
- * import { CopilotRuntime, OpenAIAdapter } from "@copilotkit/runtime";
- * import OpenAI from "openai";
- *
- * // The name of your Azure OpenAI Instance.
- * // https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
- * const instance = "<your instance name>";
- *
- * // Corresponds to your Model deployment within your OpenAI resource, e.g. my-gpt35-16k-deployment
- * // Navigate to the Azure OpenAI Studio to deploy a model.
- * const model = "<your model>";
- *
- * const apiKey = process.env["AZURE_OPENAI_API_KEY"];
- * if (!apiKey) {
- *   throw new Error("The AZURE_OPENAI_API_KEY environment variable is missing or empty.");
- * }
- *
- * const copilotKit = new CopilotRuntime();
- *
- * const openai = new OpenAI({
- *   apiKey,
- *   baseURL: `https://${instance}.openai.azure.com/openai/deployments/${model}`,
- *   defaultQuery: { "api-version": "2024-04-01-preview" },
- *   defaultHeaders: { "api-key": apiKey },
- * });
- *
- * return new OpenAIAdapter({ openai });
- * ```
- */
-import type { LanguageModel } from "ai";
-import { createOpenAI } from "@ai-sdk/openai";
-import type OpenAI from "openai";
-import Openai from "openai";
-import {
-  CopilotServiceAdapter,
-  CopilotRuntimeChatCompletionRequest,
-  CopilotRuntimeChatCompletionResponse,
-} from "../service-adapter";
-import {
-  convertActionInputToOpenAITool,
-  convertMessageToOpenAIMessage,
-  limitMessagesToTokenCount,
-  getChatCompletionsForStreaming,
-} from "./utils";
-import { randomUUID } from "@copilotkit/shared";
-import { convertServiceAdapterError, getSdkClientOptions } from "../shared";
-
-const DEFAULT_MODEL = "gpt-4o";
-
-export interface OpenAIAdapterParams {
-  /**
-   * An optional OpenAI instance to use.  If not provided, a new instance will be
-   * created.
-   */
-  openai?: OpenAI;
-
-  /**
-   * The model to use.
-   */
-  model?: string;
-
-  /**
-   * 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;
-
-  /**
-   * 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 {
-  public model: string = DEFAULT_MODEL;
-  public provider = "openai";
-
-  private disableParallelToolCalls: boolean = false;
-  private _openai: OpenAI;
-  private keepSystemRole: boolean = false;
-  private maxInputTokens?: number;
-
-  public get openai(): OpenAI {
-    return this._openai;
-  }
-  public get name() {
-    return "OpenAIAdapter";
-  }
-
-  constructor(params?: OpenAIAdapterParams) {
-    if (params?.openai) {
-      this._openai = params.openai;
-    }
-    // If no instance provided, we'll lazy-load in ensureOpenAI()
-
-    if (params?.model) {
-      this.model = params.model;
-    }
-    this.disableParallelToolCalls = params?.disableParallelToolCalls || false;
-    this.keepSystemRole = params?.keepSystemRole ?? false;
-    this.maxInputTokens = params?.maxInputTokens;
-  }
-
-  getLanguageModel(): LanguageModel {
-    const openai = this.ensureOpenAI();
-    const options = getSdkClientOptions(openai);
-    const provider = createOpenAI({
-      baseURL: openai.baseURL,
-      apiKey: openai.apiKey,
-      organization: openai.organization ?? undefined,
-      project: openai.project ?? undefined,
-      headers: options.defaultHeaders,
-      fetch: options.fetch,
-    });
-    return provider(this.model);
-  }
-
-  private ensureOpenAI(): OpenAI {
-    if (!this._openai) {
-      this._openai = new Openai();
-    }
-    return this._openai;
-  }
-
-  async process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse> {
-    const {
-      threadId: threadIdFromRequest,
-      model = this.model,
-      messages,
-      actions,
-      eventSource,
-      forwardedParameters,
-    } = request;
-    const tools = actions.map(convertActionInputToOpenAITool);
-    const threadId = threadIdFromRequest ?? randomUUID();
-
-    // ALLOWLIST APPROACH: Only include tool_result messages that correspond to valid tool_calls
-    // Step 1: Extract valid tool_call IDs
-    const validToolUseIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.isActionExecutionMessage()) {
-        validToolUseIds.add(message.id);
-      }
-    }
-
-    // Step 2: Filter messages, keeping only those with valid tool_call IDs
-    const filteredMessages = messages.filter((message) => {
-      if (message.isResultMessage()) {
-        // Skip if there's no corresponding tool_call
-        if (!validToolUseIds.has(message.actionExecutionId)) {
-          return false;
-        }
-
-        // Remove this ID from valid IDs so we don't process duplicates
-        validToolUseIds.delete(message.actionExecutionId);
-        return true;
-      }
-
-      // Keep all non-tool-result messages
-      return true;
-    });
-
-    let openaiMessages = filteredMessages.map((m) =>
-      convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }),
-    );
-    openaiMessages = limitMessagesToTokenCount(
-      openaiMessages,
-      tools,
-      model,
-      this.maxInputTokens,
-    );
-
-    let toolChoice: any = forwardedParameters?.toolChoice;
-    if (forwardedParameters?.toolChoice === "function") {
-      toolChoice = {
-        type: "function",
-        function: { name: forwardedParameters.toolChoiceFunctionName },
-      };
-    }
-
-    try {
-      const openai = this.ensureOpenAI();
-      const completions = getChatCompletionsForStreaming(openai);
-      const stream = completions.stream({
-        model: model,
-        stream: true,
-        messages: openaiMessages,
-        ...(tools.length > 0 && { tools }),
-        ...(forwardedParameters?.maxTokens && {
-          max_completion_tokens: forwardedParameters.maxTokens,
-        }),
-        ...(forwardedParameters?.stop && { stop: forwardedParameters.stop }),
-        ...(toolChoice && { tool_choice: toolChoice }),
-        ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
-        ...(forwardedParameters?.temperature && {
-          temperature: forwardedParameters.temperature,
-        }),
-      });
-
-      eventSource.stream(async (eventStream$) => {
-        let mode: "function" | "message" | null = null;
-        let currentMessageId: string;
-        let currentToolCallId: string;
-
-        try {
-          for await (const chunk of stream) {
-            if (chunk.choices.length === 0) {
-              continue;
-            }
-
-            const toolCall = chunk.choices[0].delta.tool_calls?.[0];
-            const content = chunk.choices[0].delta.content;
-
-            // When switching from message to function or vice versa,
-            // send the respective end event.
-            // If toolCall?.id is defined, it means a new tool call starts.
-            if (mode === "message" && toolCall?.id) {
-              mode = null;
-              eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-            } else if (
-              mode === "function" &&
-              (toolCall === undefined || toolCall?.id)
-            ) {
-              mode = null;
-              eventStream$.sendActionExecutionEnd({
-                actionExecutionId: currentToolCallId,
-              });
-            }
-
-            // If we send a new message type, send the appropriate start event.
-            if (mode === null) {
-              if (toolCall?.id) {
-                mode = "function";
-                currentToolCallId = toolCall!.id;
-                eventStream$.sendActionExecutionStart({
-                  actionExecutionId: currentToolCallId,
-                  parentMessageId: chunk.id,
-                  actionName: toolCall!.function!.name,
-                });
-              } else if (content) {
-                mode = "message";
-                currentMessageId = chunk.id;
-                eventStream$.sendTextMessageStart({
-                  messageId: currentMessageId,
-                });
-              }
-            }
-
-            // send the content events
-            if (mode === "message" && content) {
-              eventStream$.sendTextMessageContent({
-                messageId: currentMessageId,
-                content: content,
-              });
-            } else if (mode === "function" && toolCall?.function?.arguments) {
-              eventStream$.sendActionExecutionArgs({
-                actionExecutionId: currentToolCallId,
-                args: toolCall.function.arguments,
-              });
-            }
-          }
-
-          // send the end events
-          if (mode === "message") {
-            eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-          } else if (mode === "function") {
-            eventStream$.sendActionExecutionEnd({
-              actionExecutionId: currentToolCallId,
-            });
-          }
-        } catch (error) {
-          console.error("[OpenAI] Error during API call:", error);
-          throw convertServiceAdapterError(error, "OpenAI");
-        }
-
-        eventStream$.complete();
-      });
-    } catch (error) {
-      console.error("[OpenAI] Error during API call:", error);
-      throw convertServiceAdapterError(error, "OpenAI");
-    }
-
-    return {
-      threadId,
-    };
-  }
-}

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

@@ -1,385 +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,
-  retrieveThreadRun,
-  submitToolOutputsStream,
-} 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 retrieveThreadRun(openai, 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 = submitToolOutputsStream(openai, 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);
-  });
-}