@copilotkit/runtime/dist/service-adapters/groq/groq-adapter.mjs

<img src="https://github.com/user-attachments/assets/0a6b64d9-e193-4940-a3f6-60334ac34084" alt="banner" style="border-radius: 12px; border: 2px solid #d6d4fa;" />

import "reflect-metadata";
import { __require } from "../../_virtual/_rolldown/runtime.mjs";
import { convertActionInputToOpenAITool, convertMessageToOpenAIMessage, limitMessagesToTokenCount } from "../openai/utils.mjs";
import { convertServiceAdapterError } from "../shared/error-utils.mjs";
import { getSdkClientOptions } from "../shared/sdk-client-utils.mjs";
import { createOpenAI } from "@ai-sdk/openai";
import { randomUUID } from "@copilotkit/shared";

//#region src/service-adapters/groq/groq-adapter.ts
const DEFAULT_MODEL = "llama-3.3-70b-versatile";
var GroqAdapter = class {
	get groq() {
		return this._groq;
	}
	get name() {
		return "GroqAdapter";
	}
	constructor(params) {
		this.model = DEFAULT_MODEL;
		this.provider = "groq";
		this.disableParallelToolCalls = false;
		if (params?.groq) this._groq = params.groq;
		if (params?.model) this.model = params.model;
		this.disableParallelToolCalls = params?.disableParallelToolCalls || false;
	}
	getLanguageModel() {
		const groq = this.ensureGroq();
		const options = getSdkClientOptions(groq);
		return createOpenAI({
			baseURL: groq.baseURL,
			apiKey: groq.apiKey,
			headers: options.defaultHeaders,
			fetch: options.fetch,
			name: "groq"
		})(this.model);
	}
	ensureGroq() {
		if (!this._groq) {
			const { Groq } = __require("groq-sdk");
			this._groq = new Groq({});
		}
		return this._groq;
	}
	async process(request) {
		const { threadId, model = this.model, messages, actions, eventSource, forwardedParameters } = request;
		const tools = actions.map(convertActionInputToOpenAITool);
		let openaiMessages = messages.map((m) => convertMessageToOpenAIMessage(m, { keepSystemRole: true }));
		openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
		let toolChoice = forwardedParameters?.toolChoice;
		if (forwardedParameters?.toolChoice === "function") toolChoice = {
			type: "function",
			function: { name: forwardedParameters.toolChoiceFunctionName }
		};
		let stream;
		try {
			stream = await this.ensureGroq().chat.completions.create({
				model,
				stream: true,
				messages: openaiMessages,
				...tools.length > 0 && { tools },
				...forwardedParameters?.maxTokens && { max_tokens: forwardedParameters.maxTokens },
				...forwardedParameters?.stop && { stop: forwardedParameters.stop },
				...toolChoice && { tool_choice: toolChoice },
				...this.disableParallelToolCalls && { parallel_tool_calls: false },
				...forwardedParameters?.temperature && { temperature: forwardedParameters.temperature }
			});
		} catch (error) {
			throw convertServiceAdapterError(error, "Groq");
		}
		eventSource.stream(async (eventStream$) => {
			let mode = null;
			let currentMessageId;
			let currentToolCallId;
			try {
				for await (const chunk of stream) {
					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,
								actionName: toolCall.function.name,
								parentMessageId: chunk.id
							});
						} 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) {
				throw convertServiceAdapterError(error, "Groq");
			}
			eventStream$.complete();
		});
		return { threadId: request.threadId || randomUUID() };
	}
};

//#endregion
export { GroqAdapter };
//# sourceMappingURL=groq-adapter.mjs.map