@copilotkit/runtime 1.51.5-next.0 → 1.51.5-next.1

package/dist/service-adapters/openai/openai-adapter.d.mts

@@ -0,0 +1,47 @@
+import "reflect-metadata";
+import { CopilotRuntimeChatCompletionRequest, CopilotRuntimeChatCompletionResponse, CopilotServiceAdapter } from "../service-adapter.mjs";
+import OpenAI from "openai";
+
+//#region src/service-adapters/openai/openai-adapter.d.ts
+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;
+}
+declare class OpenAIAdapter implements CopilotServiceAdapter {
+  model: string;
+  provider: string;
+  private disableParallelToolCalls;
+  private _openai;
+  private keepSystemRole;
+  get openai(): OpenAI;
+  get name(): string;
+  constructor(params?: OpenAIAdapterParams);
+  private ensureOpenAI;
+  process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+}
+//#endregion
+export { OpenAIAdapter, OpenAIAdapterParams };
+//# sourceMappingURL=openai-adapter.d.mts.map

package/dist/service-adapters/openai/openai-adapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-adapter.d.mts","names":[],"sources":["../../../src/service-adapters/openai/openai-adapter.ts"],"mappings":";;;;;UAkEiB,mBAAA;;;;;EAKf,MAAA,GAAS,MAAA;;;;EAKT,KAAA;;;;;;;;;EAUA,wBAAA;;;;;;;EAQA,cAAA;AAAA;AAAA,cAGW,aAAA,YAAyB,qBAAA;EAC7B,KAAA;EACA,QAAA;EAAA,QAEC,wBAAA;EAAA,QACA,OAAA;EAAA,QACA,cAAA;EAAA,IAEG,MAAA,CAAA,GAAU,MAAA;EAAA,IAGV,IAAA,CAAA;cAIC,MAAA,GAAS,mBAAA;EAAA,QAab,YAAA;EASF,OAAA,CACJ,OAAA,EAAS,mCAAA,GACR,OAAA,CAAQ,oCAAA;AAAA"}

package/dist/service-adapters/openai/openai-adapter.mjs

@@ -0,0 +1,123 @@
+import "reflect-metadata";
+import { __require } from "../../_virtual/_rolldown/runtime.mjs";
+import { convertActionInputToOpenAITool, convertMessageToOpenAIMessage, limitMessagesToTokenCount } from "./utils.mjs";
+import { convertServiceAdapterError } from "../shared/error-utils.mjs";
+import { randomUUID } from "@copilotkit/shared";
+
+//#region src/service-adapters/openai/openai-adapter.ts
+const DEFAULT_MODEL = "gpt-4o";
+var OpenAIAdapter = class {
+	get openai() {
+		return this._openai;
+	}
+	get name() {
+		return "OpenAIAdapter";
+	}
+	constructor(params) {
+		this.model = DEFAULT_MODEL;
+		this.provider = "openai";
+		this.disableParallelToolCalls = false;
+		this.keepSystemRole = false;
+		if (params?.openai) this._openai = params.openai;
+		if (params?.model) this.model = params.model;
+		this.disableParallelToolCalls = params?.disableParallelToolCalls || false;
+		this.keepSystemRole = params?.keepSystemRole ?? false;
+	}
+	ensureOpenAI() {
+		if (!this._openai) {
+			const OpenAI = __require("openai").default;
+			this._openai = new OpenAI();
+		}
+		return this._openai;
+	}
+	async process(request) {
+		const { threadId: threadIdFromRequest, model = this.model, messages, actions, eventSource, forwardedParameters } = request;
+		const tools = actions.map(convertActionInputToOpenAITool);
+		const threadId = threadIdFromRequest ?? randomUUID();
+		const validToolUseIds = /* @__PURE__ */ new Set();
+		for (const message of messages) if (message.isActionExecutionMessage()) validToolUseIds.add(message.id);
+		let openaiMessages = messages.filter((message) => {
+			if (message.isResultMessage()) {
+				if (!validToolUseIds.has(message.actionExecutionId)) return false;
+				validToolUseIds.delete(message.actionExecutionId);
+				return true;
+			}
+			return true;
+		}).map((m) => convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }));
+		openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
+		let toolChoice = forwardedParameters?.toolChoice;
+		if (forwardedParameters?.toolChoice === "function") toolChoice = {
+			type: "function",
+			function: { name: forwardedParameters.toolChoiceFunctionName }
+		};
+		try {
+			const stream = this.ensureOpenAI().beta.chat.completions.stream({
+				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 = null;
+				let currentMessageId;
+				let currentToolCallId;
+				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;
+						if (mode === "message" && toolCall?.id) {
+							mode = null;
+							eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+						} else if (mode === "function" && (toolCall === void 0 || toolCall?.id)) {
+							mode = null;
+							eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+						}
+						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 });
+							}
+						}
+						if (mode === "message" && content) eventStream$.sendTextMessageContent({
+							messageId: currentMessageId,
+							content
+						});
+						else if (mode === "function" && toolCall?.function?.arguments) eventStream$.sendActionExecutionArgs({
+							actionExecutionId: currentToolCallId,
+							args: toolCall.function.arguments
+						});
+					}
+					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 };
+	}
+};
+
+//#endregion
+export { OpenAIAdapter };
+//# sourceMappingURL=openai-adapter.mjs.map

package/dist/service-adapters/openai/openai-adapter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-adapter.mjs","names":[],"sources":["../../../src/service-adapters/openai/openai-adapter.ts"],"sourcesContent":["/**\n * Copilot Runtime adapter for OpenAI.\n *\n * ## Example\n *\n * ```ts\n * import { CopilotRuntime, OpenAIAdapter } from \"@copilotkit/runtime\";\n * import OpenAI from \"openai\";\n *\n * const copilotKit = new CopilotRuntime();\n *\n * const openai = new OpenAI({\n *   organization: \"<your-organization-id>\", // optional\n *   apiKey: \"<your-api-key>\",\n * });\n *\n * return new OpenAIAdapter({ openai });\n * ```\n *\n * ## Example with Azure OpenAI\n *\n * ```ts\n * import { CopilotRuntime, OpenAIAdapter } from \"@copilotkit/runtime\";\n * import OpenAI from \"openai\";\n *\n * // The name of your Azure OpenAI Instance.\n * // https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource\n * const instance = \"<your instance name>\";\n *\n * // Corresponds to your Model deployment within your OpenAI resource, e.g. my-gpt35-16k-deployment\n * // Navigate to the Azure OpenAI Studio to deploy a model.\n * const model = \"<your model>\";\n *\n * const apiKey = process.env[\"AZURE_OPENAI_API_KEY\"];\n * if (!apiKey) {\n *   throw new Error(\"The AZURE_OPENAI_API_KEY environment variable is missing or empty.\");\n * }\n *\n * const copilotKit = new CopilotRuntime();\n *\n * const openai = new OpenAI({\n *   apiKey,\n *   baseURL: `https://${instance}.openai.azure.com/openai/deployments/${model}`,\n *   defaultQuery: { \"api-version\": \"2024-04-01-preview\" },\n *   defaultHeaders: { \"api-key\": apiKey },\n * });\n *\n * return new OpenAIAdapter({ openai });\n * ```\n */\nimport type OpenAI from \"openai\";\nimport {\n  CopilotServiceAdapter,\n  CopilotRuntimeChatCompletionRequest,\n  CopilotRuntimeChatCompletionResponse,\n} from \"../service-adapter\";\nimport {\n  convertActionInputToOpenAITool,\n  convertMessageToOpenAIMessage,\n  limitMessagesToTokenCount,\n} from \"./utils\";\nimport { randomUUID } from \"@copilotkit/shared\";\nimport { convertServiceAdapterError } from \"../shared\";\n\nconst DEFAULT_MODEL = \"gpt-4o\";\n\nexport interface OpenAIAdapterParams {\n  /**\n   * An optional OpenAI instance to use.  If not provided, a new instance will be\n   * created.\n   */\n  openai?: OpenAI;\n\n  /**\n   * The model to use.\n   */\n  model?: string;\n\n  /**\n   * Whether to disable parallel tool calls.\n   * You can disable parallel tool calls to force the model to execute tool calls sequentially.\n   * This is useful if you want to execute tool calls in a specific order so that the state changes\n   * introduced by one tool call are visible to the next tool call. (i.e. new actions or readables)\n   *\n   * @default false\n   */\n  disableParallelToolCalls?: boolean;\n\n  /**\n   * Whether to keep the role in system messages as \"System\".\n   * By default, it is converted to \"developer\", which is used by newer OpenAI models\n   *\n   * @default false\n   */\n  keepSystemRole?: boolean;\n}\n\nexport class OpenAIAdapter implements CopilotServiceAdapter {\n  public model: string = DEFAULT_MODEL;\n  public provider = \"openai\";\n\n  private disableParallelToolCalls: boolean = false;\n  private _openai: OpenAI;\n  private keepSystemRole: boolean = false;\n\n  public get openai(): OpenAI {\n    return this._openai;\n  }\n  public get name() {\n    return \"OpenAIAdapter\";\n  }\n\n  constructor(params?: OpenAIAdapterParams) {\n    if (params?.openai) {\n      this._openai = params.openai;\n    }\n    // If no instance provided, we'll lazy-load in ensureOpenAI()\n\n    if (params?.model) {\n      this.model = params.model;\n    }\n    this.disableParallelToolCalls = params?.disableParallelToolCalls || false;\n    this.keepSystemRole = params?.keepSystemRole ?? false;\n  }\n\n  private ensureOpenAI(): OpenAI {\n    if (!this._openai) {\n      // eslint-disable-next-line @typescript-eslint/no-var-requires\n      const OpenAI = require(\"openai\").default;\n      this._openai = new OpenAI();\n    }\n    return this._openai;\n  }\n\n  async process(\n    request: CopilotRuntimeChatCompletionRequest,\n  ): Promise<CopilotRuntimeChatCompletionResponse> {\n    const {\n      threadId: threadIdFromRequest,\n      model = this.model,\n      messages,\n      actions,\n      eventSource,\n      forwardedParameters,\n    } = request;\n    const tools = actions.map(convertActionInputToOpenAITool);\n    const threadId = threadIdFromRequest ?? randomUUID();\n\n    // ALLOWLIST APPROACH: Only include tool_result messages that correspond to valid tool_calls\n    // Step 1: Extract valid tool_call IDs\n    const validToolUseIds = new Set<string>();\n\n    for (const message of messages) {\n      if (message.isActionExecutionMessage()) {\n        validToolUseIds.add(message.id);\n      }\n    }\n\n    // Step 2: Filter messages, keeping only those with valid tool_call IDs\n    const filteredMessages = messages.filter((message) => {\n      if (message.isResultMessage()) {\n        // Skip if there's no corresponding tool_call\n        if (!validToolUseIds.has(message.actionExecutionId)) {\n          return false;\n        }\n\n        // Remove this ID from valid IDs so we don't process duplicates\n        validToolUseIds.delete(message.actionExecutionId);\n        return true;\n      }\n\n      // Keep all non-tool-result messages\n      return true;\n    });\n\n    let openaiMessages = filteredMessages.map((m) =>\n      convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }),\n    );\n    openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);\n\n    let toolChoice: any = forwardedParameters?.toolChoice;\n    if (forwardedParameters?.toolChoice === \"function\") {\n      toolChoice = {\n        type: \"function\",\n        function: { name: forwardedParameters.toolChoiceFunctionName },\n      };\n    }\n\n    try {\n      const openai = this.ensureOpenAI();\n      const stream = openai.beta.chat.completions.stream({\n        model: model,\n        stream: true,\n        messages: openaiMessages,\n        ...(tools.length > 0 && { tools }),\n        ...(forwardedParameters?.maxTokens && {\n          max_completion_tokens: forwardedParameters.maxTokens,\n        }),\n        ...(forwardedParameters?.stop && { stop: forwardedParameters.stop }),\n        ...(toolChoice && { tool_choice: toolChoice }),\n        ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),\n        ...(forwardedParameters?.temperature && {\n          temperature: forwardedParameters.temperature,\n        }),\n      });\n\n      eventSource.stream(async (eventStream$) => {\n        let mode: \"function\" | \"message\" | null = null;\n        let currentMessageId: string;\n        let currentToolCallId: string;\n\n        try {\n          for await (const chunk of stream) {\n            if (chunk.choices.length === 0) {\n              continue;\n            }\n\n            const toolCall = chunk.choices[0].delta.tool_calls?.[0];\n            const content = chunk.choices[0].delta.content;\n\n            // When switching from message to function or vice versa,\n            // send the respective end event.\n            // If toolCall?.id is defined, it means a new tool call starts.\n            if (mode === \"message\" && toolCall?.id) {\n              mode = null;\n              eventStream$.sendTextMessageEnd({ messageId: currentMessageId });\n            } else if (\n              mode === \"function\" &&\n              (toolCall === undefined || toolCall?.id)\n            ) {\n              mode = null;\n              eventStream$.sendActionExecutionEnd({\n                actionExecutionId: currentToolCallId,\n              });\n            }\n\n            // If we send a new message type, send the appropriate start event.\n            if (mode === null) {\n              if (toolCall?.id) {\n                mode = \"function\";\n                currentToolCallId = toolCall!.id;\n                eventStream$.sendActionExecutionStart({\n                  actionExecutionId: currentToolCallId,\n                  parentMessageId: chunk.id,\n                  actionName: toolCall!.function!.name,\n                });\n              } else if (content) {\n                mode = \"message\";\n                currentMessageId = chunk.id;\n                eventStream$.sendTextMessageStart({\n                  messageId: currentMessageId,\n                });\n              }\n            }\n\n            // send the content events\n            if (mode === \"message\" && content) {\n              eventStream$.sendTextMessageContent({\n                messageId: currentMessageId,\n                content: content,\n              });\n            } else if (mode === \"function\" && toolCall?.function?.arguments) {\n              eventStream$.sendActionExecutionArgs({\n                actionExecutionId: currentToolCallId,\n                args: toolCall.function.arguments,\n              });\n            }\n          }\n\n          // send the end events\n          if (mode === \"message\") {\n            eventStream$.sendTextMessageEnd({ messageId: currentMessageId });\n          } else if (mode === \"function\") {\n            eventStream$.sendActionExecutionEnd({\n              actionExecutionId: currentToolCallId,\n            });\n          }\n        } catch (error) {\n          console.error(\"[OpenAI] Error during API call:\", error);\n          throw convertServiceAdapterError(error, \"OpenAI\");\n        }\n\n        eventStream$.complete();\n      });\n    } catch (error) {\n      console.error(\"[OpenAI] Error during API call:\", error);\n      throw convertServiceAdapterError(error, \"OpenAI\");\n    }\n\n    return {\n      threadId,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/service-adapters/openai/openai-assistant-adapter.cjs

@@ -0,0 +1,157 @@
+require("reflect-metadata");
+const require_utils = require('./utils.cjs');
+
+//#region src/service-adapters/openai/openai-assistant-adapter.ts
+var OpenAIAssistantAdapter = class {
+	get name() {
+		return "OpenAIAssistantAdapter";
+	}
+	constructor(params) {
+		this.keepSystemRole = false;
+		if (params.openai) this._openai = params.openai;
+		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;
+	}
+	ensureOpenAI() {
+		if (!this._openai) {
+			const OpenAI = require("openai").default;
+			this._openai = new OpenAI({});
+		}
+		return this._openai;
+	}
+	async process(request) {
+		const { messages, actions, eventSource, runId, forwardedParameters } = request;
+		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 = void 0;
+		if (lastMessage.isResultMessage() && runId) nextRunId = await this.submitToolOutputs(threadId, runId, messages, eventSource);
+		else if (lastMessage.isTextMessage()) nextRunId = await this.submitUserMessage(threadId, messages, actions, eventSource, forwardedParameters);
+		else throw new Error("No actionable message found in the messages");
+		return {
+			runId: nextRunId,
+			threadId,
+			extensions: {
+				...request.extensions,
+				openaiAssistantAPI: {
+					threadId,
+					runId: nextRunId
+				}
+			}
+		};
+	}
+	async submitToolOutputs(threadId, runId, messages, eventSource) {
+		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");
+		const toolCallsIds = run.required_action.submit_tool_outputs.tool_calls.map((toolCall) => toolCall.id);
+		const resultMessages = messages.filter((message) => message.isResultMessage() && toolCallsIds.includes(message.actionExecutionId));
+		if (toolCallsIds.length != resultMessages.length) throw new Error("Number of function results does not match the number of tool calls");
+		const toolOutputs = 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;
+	}
+	async submitUserMessage(threadId, messages, actions, eventSource, forwardedParameters) {
+		const openai = this.ensureOpenAI();
+		messages = [...messages];
+		const instructionsMessage = messages.shift();
+		const instructions = instructionsMessage.isTextMessage() ? instructionsMessage.content : "";
+		const userMessage = messages.map((m) => require_utils.convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole })).map(require_utils.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 tools = [
+			...actions.map(require_utils.convertActionInputToOpenAITool),
+			...this.codeInterpreterEnabled ? [{ type: "code_interpreter" }] : [],
+			...this.fileSearchEnabled ? [{ type: "file_search" }] : []
+		];
+		let stream = openai.beta.threads.runs.stream(threadId, {
+			assistant_id: this.assistantId,
+			instructions,
+			tools,
+			...forwardedParameters?.maxTokens && { max_completion_tokens: forwardedParameters.maxTokens },
+			...this.disableParallelToolCalls && { parallel_tool_calls: false }
+		});
+		await this.streamResponse(stream, eventSource);
+		return getRunIdFromStream(stream);
+	}
+	async streamResponse(stream, eventSource) {
+		eventSource.stream(async (eventStream$) => {
+			let inFunctionCall = false;
+			let currentMessageId;
+			let currentToolCallId;
+			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;
+					let toolCallName;
+					let toolCallArgs;
+					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) {
+	return new Promise((resolve, reject) => {
+		let runIdGetter = (event) => {
+			if (event.event === "thread.run.created") {
+				const runId = event.data.id;
+				stream.off("event", runIdGetter);
+				resolve(runId);
+			}
+		};
+		stream.on("event", runIdGetter);
+	});
+}
+
+//#endregion
+exports.OpenAIAssistantAdapter = OpenAIAssistantAdapter;
+//# sourceMappingURL=openai-assistant-adapter.cjs.map

package/dist/service-adapters/openai/openai-assistant-adapter.cjs.map

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

package/dist/service-adapters/openai/openai-assistant-adapter.d.cts

@@ -0,0 +1,59 @@
+
+import { CopilotRuntimeChatCompletionRequest, CopilotRuntimeChatCompletionResponse, CopilotServiceAdapter } from "../service-adapter.cjs";
+import OpenAI from "openai";
+
+//#region src/service-adapters/openai/openai-assistant-adapter.d.ts
+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;
+}
+declare class OpenAIAssistantAdapter implements CopilotServiceAdapter {
+  private _openai;
+  private codeInterpreterEnabled;
+  private assistantId;
+  private fileSearchEnabled;
+  private disableParallelToolCalls;
+  private keepSystemRole;
+  get name(): string;
+  constructor(params: OpenAIAssistantAdapterParams);
+  private ensureOpenAI;
+  process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+  private submitToolOutputs;
+  private submitUserMessage;
+  private streamResponse;
+}
+//#endregion
+export { OpenAIAssistantAdapter, OpenAIAssistantAdapterParams };
+//# sourceMappingURL=openai-assistant-adapter.d.cts.map

package/dist/service-adapters/openai/openai-assistant-adapter.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-assistant-adapter.d.cts","names":[],"sources":["../../../src/service-adapters/openai/openai-assistant-adapter.ts"],"mappings":";;;;;UAkDiB,4BAAA;EA0C8B;;;EAtC7C,WAAA;EA0CQ;;;EArCR,MAAA,GAAS,MAAA;;;;;EAMT,sBAAA;EA8DW;;;;EAxDX,iBAAA;EAmKc;;;;;;;;EAzJd,wBAAA;;;;;;;EAQA,cAAA;AAAA;AAAA,cAGW,sBAAA,YAAkC,qBAAA;EAAA,QACrC,OAAA;EAAA,QACA,sBAAA;EAAA,QACA,WAAA;EAAA,QACA,iBAAA;EAAA,QACA,wBAAA;EAAA,QACA,cAAA;EAAA,IAEG,IAAA,CAAA;cAIC,MAAA,EAAQ,4BAAA;EAAA,QAaZ,YAAA;EASF,OAAA,CACJ,OAAA,EAAS,mCAAA,GACR,OAAA,CAAQ,oCAAA;EAAA,QAqDG,iBAAA;EAAA,QAqDA,iBAAA;EAAA,QA8DA,cAAA;AAAA"}

package/dist/service-adapters/openai/openai-assistant-adapter.d.mts

@@ -0,0 +1,59 @@
+import "reflect-metadata";
+import { CopilotRuntimeChatCompletionRequest, CopilotRuntimeChatCompletionResponse, CopilotServiceAdapter } from "../service-adapter.mjs";
+import OpenAI from "openai";
+
+//#region src/service-adapters/openai/openai-assistant-adapter.d.ts
+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;
+}
+declare class OpenAIAssistantAdapter implements CopilotServiceAdapter {
+  private _openai;
+  private codeInterpreterEnabled;
+  private assistantId;
+  private fileSearchEnabled;
+  private disableParallelToolCalls;
+  private keepSystemRole;
+  get name(): string;
+  constructor(params: OpenAIAssistantAdapterParams);
+  private ensureOpenAI;
+  process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+  private submitToolOutputs;
+  private submitUserMessage;
+  private streamResponse;
+}
+//#endregion
+export { OpenAIAssistantAdapter, OpenAIAssistantAdapterParams };
+//# sourceMappingURL=openai-assistant-adapter.d.mts.map

package/dist/service-adapters/openai/openai-assistant-adapter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-assistant-adapter.d.mts","names":[],"sources":["../../../src/service-adapters/openai/openai-assistant-adapter.ts"],"mappings":";;;;;UAkDiB,4BAAA;EA0C8B;;;EAtC7C,WAAA;EA0CQ;;;EArCR,MAAA,GAAS,MAAA;;;;;EAMT,sBAAA;EA8DW;;;;EAxDX,iBAAA;EAmKc;;;;;;;;EAzJd,wBAAA;;;;;;;EAQA,cAAA;AAAA;AAAA,cAGW,sBAAA,YAAkC,qBAAA;EAAA,QACrC,OAAA;EAAA,QACA,sBAAA;EAAA,QACA,WAAA;EAAA,QACA,iBAAA;EAAA,QACA,wBAAA;EAAA,QACA,cAAA;EAAA,IAEG,IAAA,CAAA;cAIC,MAAA,EAAQ,4BAAA;EAAA,QAaZ,YAAA;EASF,OAAA,CACJ,OAAA,EAAS,mCAAA,GACR,OAAA,CAAQ,oCAAA;EAAA,QAqDG,iBAAA;EAAA,QAqDA,iBAAA;EAAA,QA8DA,cAAA;AAAA"}