rdesign/frontend/node_modules/@copilotkit/runtime-client-gql/dist/message-conversion/agui-to-gql.cjs

const require_types = require('../client/types.cjs');

//#region src/message-conversion/agui-to-gql.ts
function extractAgentName(message) {
	if (message.role !== "assistant") throw new Error(`Cannot extract agent name from message with role ${message.role}`);
	return message.agentName || "unknown";
}
function isAgentStateMessage(message) {
	return message.role === "assistant" && "agentName" in message && "state" in message;
}
function hasImageProperty(message) {
	if (!(message.role === "assistant" || message.role === "user") || message.image === void 0) return false;
	if (message.image.format === void 0 || message.image.bytes === void 0) return false;
	return true;
}
function aguiToGQL(messages, actions, coAgentStateRenders) {
	const gqlMessages = [];
	messages = Array.isArray(messages) ? messages : [messages];
	const toolCallNames = {};
	for (const message of messages) {
		if (isAgentStateMessage(message)) {
			const agentName = extractAgentName(message);
			const state = "state" in message && message.state ? message.state : {};
			gqlMessages.push(new require_types.AgentStateMessage({
				id: message.id,
				agentName,
				state,
				role: require_types.Role.Assistant
			}));
			if ("generativeUI" in message && message.generativeUI && coAgentStateRenders) coAgentStateRenders[agentName] = {
				name: agentName,
				render: message.generativeUI
			};
			continue;
		}
		if (hasImageProperty(message)) {
			gqlMessages.push(aguiMessageWithImageToGQLMessage(message));
			continue;
		}
		if (message.role === "assistant" && message.toolCalls) {
			gqlMessages.push(aguiTextMessageToGQLMessage(message));
			for (const toolCall of message.toolCalls) {
				toolCallNames[toolCall.id] = toolCall.function.name;
				const actionExecMsg = aguiToolCallToGQLActionExecution(toolCall, message.id);
				if ("generativeUI" in message && message.generativeUI && actions) {
					const actionName = toolCall.function.name;
					const specificAction = Object.values(actions).find((action) => action.name === actionName);
					const wildcardAction = Object.values(actions).find((action) => action.name === "*");
					if (specificAction) specificAction.render = message.generativeUI;
					else if (wildcardAction) wildcardAction.render = message.generativeUI;
				}
				gqlMessages.push(actionExecMsg);
			}
			continue;
		}
		if (message.role === "reasoning") continue;
		if (message.role === "developer" || message.role === "system" || message.role === "assistant" || message.role === "user") {
			gqlMessages.push(aguiTextMessageToGQLMessage(message));
			continue;
		}
		if (message.role === "tool") {
			gqlMessages.push(aguiToolMessageToGQLResultMessage(message, toolCallNames));
			continue;
		}
		throw new Error(`Unknown message role: "${message.role}" in message with id: ${message.id}`);
	}
	return gqlMessages;
}
function aguiTextMessageToGQLMessage(message) {
	if (message.role !== "developer" && message.role !== "system" && message.role !== "assistant" && message.role !== "user") throw new Error(`Cannot convert message with role ${message.role} to TextMessage`);
	let roleValue;
	if (message.role === "developer") roleValue = require_types.Role.Developer;
	else if (message.role === "system") roleValue = require_types.Role.System;
	else if (message.role === "assistant") roleValue = require_types.Role.Assistant;
	else roleValue = require_types.Role.User;
	return new require_types.TextMessage({
		id: message.id,
		content: message.content || "",
		role: roleValue
	});
}
function aguiToolCallToGQLActionExecution(toolCall, parentMessageId) {
	if (toolCall.type !== "function") throw new Error(`Unsupported tool call type: ${toolCall.type}`);
	let argumentsObj;
	if (typeof toolCall.function.arguments === "string") try {
		argumentsObj = JSON.parse(toolCall.function.arguments);
	} catch (error) {
		console.warn(`[CopilotKit] Failed to parse tool arguments, falling back to empty object`);
		argumentsObj = {};
	}
	else if (typeof toolCall.function.arguments === "object" && toolCall.function.arguments !== null) argumentsObj = toolCall.function.arguments;
	else {
		console.warn(`[CopilotKit] Tool arguments parsed to non-object (${typeof toolCall.function.arguments}), falling back to empty object`);
		argumentsObj = {};
	}
	if (typeof argumentsObj !== "object" || argumentsObj === null || Array.isArray(argumentsObj)) {
		console.warn(`[CopilotKit] Tool arguments parsed to non-object (${typeof argumentsObj}), falling back to empty object`);
		argumentsObj = {};
	}
	return new require_types.ActionExecutionMessage({
		id: toolCall.id,
		name: toolCall.function.name,
		arguments: argumentsObj,
		parentMessageId
	});
}
function aguiToolMessageToGQLResultMessage(message, toolCallNames) {
	if (message.role !== "tool") throw new Error(`Cannot convert message with role ${message.role} to ResultMessage`);
	if (!message.toolCallId) throw new Error("Tool message must have a toolCallId");
	const actionName = toolCallNames[message.toolCallId] || "unknown";
	let resultContent;
	const messageContent = message.content || "";
	if (typeof messageContent === "string") resultContent = messageContent;
	else if (typeof messageContent === "object" && messageContent !== null) try {
		resultContent = JSON.stringify(messageContent);
	} catch (error) {
		console.warn(`Failed to stringify tool result for ${actionName}:`, error);
		resultContent = String(messageContent);
	}
	else resultContent = String(messageContent);
	return new require_types.ResultMessage({
		id: message.id,
		result: resultContent,
		actionExecutionId: message.toolCallId,
		actionName: message.toolName || actionName
	});
}
function aguiMessageWithRenderToGQL(message, actions, coAgentStateRenders) {
	if (message.role === "assistant" && "generativeUI" in message && message.generativeUI && !message.toolCalls) {
		const gqlMessages = [];
		gqlMessages.push(new require_types.AgentStateMessage({
			id: message.id,
			agentName: "unknown",
			state: {},
			role: require_types.Role.Assistant
		}));
		if (coAgentStateRenders) coAgentStateRenders.unknown = {
			name: "unknown",
			render: message.generativeUI
		};
		return gqlMessages;
	}
	return aguiToGQL([message], actions, coAgentStateRenders);
}
function aguiMessageWithImageToGQLMessage(message) {
	if (!hasImageProperty(message)) throw new Error(`Cannot convert message to ImageMessage: missing format or bytes`);
	let roleValue;
	if (message.role === "assistant") roleValue = require_types.Role.Assistant;
	else roleValue = require_types.Role.User;
	if (message.role !== "assistant" && message.role !== "user") throw new Error(`Cannot convert message with role ${message.role} to ImageMessage`);
	return new require_types.ImageMessage({
		id: message.id,
		format: message.image.format,
		bytes: message.image.bytes,
		role: roleValue
	});
}

//#endregion
exports.aguiMessageWithImageToGQLMessage = aguiMessageWithImageToGQLMessage;
exports.aguiMessageWithRenderToGQL = aguiMessageWithRenderToGQL;
exports.aguiTextMessageToGQLMessage = aguiTextMessageToGQLMessage;
exports.aguiToGQL = aguiToGQL;
exports.aguiToolCallToGQLActionExecution = aguiToolCallToGQLActionExecution;
exports.aguiToolMessageToGQLResultMessage = aguiToolMessageToGQLResultMessage;
//# sourceMappingURL=agui-to-gql.cjs.map