@copilotkit/runtime
Version:
<img src="https://github.com/user-attachments/assets/0a6b64d9-e193-4940-a3f6-60334ac34084" alt="banner" style="border-radius: 12px; border: 2px solid #d6d4fa;" />
137 lines (135 loc) • 5.57 kB
JavaScript
require("reflect-metadata");
const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
const require_utils = require('./utils.cjs');
const require_error_utils = require('../shared/error-utils.cjs');
const require_sdk_client_utils = require('../shared/sdk-client-utils.cjs');
let _ai_sdk_openai = require("@ai-sdk/openai");
let openai = require("openai");
openai = require_runtime.__toESM(openai);
let _copilotkit_shared = require("@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;
this.maxInputTokens = params?.maxInputTokens;
}
getLanguageModel() {
const openai$1 = this.ensureOpenAI();
const options = require_sdk_client_utils.getSdkClientOptions(openai$1);
return (0, _ai_sdk_openai.createOpenAI)({
baseURL: openai$1.baseURL,
apiKey: openai$1.apiKey,
organization: openai$1.organization ?? void 0,
project: openai$1.project ?? void 0,
headers: options.defaultHeaders,
fetch: options.fetch
})(this.model);
}
ensureOpenAI() {
if (!this._openai) this._openai = new openai.default();
return this._openai;
}
async process(request) {
const { threadId: threadIdFromRequest, model = this.model, messages, actions, eventSource, forwardedParameters } = request;
const tools = actions.map(require_utils.convertActionInputToOpenAITool);
const threadId = threadIdFromRequest ?? (0, _copilotkit_shared.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) => require_utils.convertMessageToOpenAIMessage(m, { keepSystemRole: this.keepSystemRole }));
openaiMessages = require_utils.limitMessagesToTokenCount(openaiMessages, tools, model, this.maxInputTokens);
let toolChoice = forwardedParameters?.toolChoice;
if (forwardedParameters?.toolChoice === "function") toolChoice = {
type: "function",
function: { name: forwardedParameters.toolChoiceFunctionName }
};
try {
const stream = require_utils.getChatCompletionsForStreaming(this.ensureOpenAI()).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 require_error_utils.convertServiceAdapterError(error, "OpenAI");
}
eventStream$.complete();
});
} catch (error) {
console.error("[OpenAI] Error during API call:", error);
throw require_error_utils.convertServiceAdapterError(error, "OpenAI");
}
return { threadId };
}
};
//#endregion
exports.OpenAIAdapter = OpenAIAdapter;
//# sourceMappingURL=openai-adapter.cjs.map