@copilotkit/runtime/dist/graphql/message-conversion/agui-to-gql.cjs

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

require("reflect-metadata");
const require_index = require('../types/converted/index.cjs');

//#region src/graphql/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 normalizeMessageContent(content) {
	if (typeof content === "string" || typeof content === "undefined") return content || "";
	if (Array.isArray(content)) return content.map((part) => {
		if (part?.type === "text") return part.text;
		if (part?.type === "binary") return part.data || part.url || part.filename || `[binary:${part.mimeType}]`;
		return "";
	}).filter(Boolean).join("\n");
	if (content && typeof content === "object") try {
		return JSON.stringify(content);
	} catch (error) {
		console.warn("Failed to serialize message content", error);
	}
	return String(content ?? "");
}
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_index.AgentStateMessage({
				id: message.id,
				agentName,
				state,
				role: require_index.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_index.Role.developer;
	else if (message.role === "system") roleValue = require_index.Role.system;
	else if (message.role === "assistant") roleValue = require_index.Role.assistant;
	else roleValue = require_index.Role.user;
	return new require_index.TextMessage({
		id: message.id,
		content: normalizeMessageContent(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_index.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_index.ResultMessage({
		id: message.id,
		result: resultContent,
		actionExecutionId: message.toolCallId,
		actionName: message.toolName || actionName
	});
}
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_index.Role.assistant;
	else roleValue = require_index.Role.user;
	if (message.role !== "assistant" && message.role !== "user") throw new Error(`Cannot convert message with role ${message.role} to ImageMessage`);
	return new require_index.ImageMessage({
		id: message.id,
		format: message.image.format,
		bytes: message.image.bytes,
		role: roleValue
	});
}

//#endregion
exports.aguiToGQL = aguiToGQL;
//# sourceMappingURL=agui-to-gql.cjs.map