@copilotkit/runtime-client-gql
Version:
<img src="https://github.com/user-attachments/assets/0a6b64d9-e193-4940-a3f6-60334ac34084" alt="banner" style="border-radius: 12px; border: 2px solid #d6d4fa;" />
534 lines (529 loc) • 17.5 kB
JavaScript
;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/message-conversion/index.ts
var message_conversion_exports = {};
__export(message_conversion_exports, {
aguiMessageWithImageToGQLMessage: () => aguiMessageWithImageToGQLMessage,
aguiMessageWithRenderToGQL: () => aguiMessageWithRenderToGQL,
aguiTextMessageToGQLMessage: () => aguiTextMessageToGQLMessage,
aguiToGQL: () => aguiToGQL,
aguiToolCallToGQLActionExecution: () => aguiToolCallToGQLActionExecution,
aguiToolMessageToGQLResultMessage: () => aguiToolMessageToGQLResultMessage,
gqlActionExecutionMessageToAGUIMessage: () => gqlActionExecutionMessageToAGUIMessage,
gqlImageMessageToAGUIMessage: () => gqlImageMessageToAGUIMessage,
gqlResultMessageToAGUIMessage: () => gqlResultMessageToAGUIMessage,
gqlTextMessageToAGUIMessage: () => gqlTextMessageToAGUIMessage,
gqlToAGUI: () => gqlToAGUI
});
module.exports = __toCommonJS(message_conversion_exports);
// src/graphql/@generated/graphql.ts
var MessageRole = /* @__PURE__ */ ((MessageRole2) => {
MessageRole2["Assistant"] = "assistant";
MessageRole2["Developer"] = "developer";
MessageRole2["System"] = "system";
MessageRole2["Tool"] = "tool";
MessageRole2["User"] = "user";
return MessageRole2;
})(MessageRole || {});
// src/client/types.ts
var import_shared = require("@copilotkit/shared");
var import_shared2 = require("@copilotkit/shared");
var Message = class {
constructor(props) {
props.id ?? (props.id = (0, import_shared.randomId)());
props.status ?? (props.status = { code: "Success" /* Success */ });
props.createdAt ?? (props.createdAt = /* @__PURE__ */ new Date());
Object.assign(this, props);
}
isTextMessage() {
return this.type === "TextMessage";
}
isActionExecutionMessage() {
return this.type === "ActionExecutionMessage";
}
isResultMessage() {
return this.type === "ResultMessage";
}
isAgentStateMessage() {
return this.type === "AgentStateMessage";
}
isImageMessage() {
return this.type === "ImageMessage";
}
};
var Role = MessageRole;
var TextMessage = class extends Message {
constructor(props) {
super(props);
this.type = "TextMessage";
}
};
var ActionExecutionMessage = class extends Message {
constructor(props) {
super(props);
this.type = "ActionExecutionMessage";
}
};
var ResultMessage = class extends Message {
constructor(props) {
super(props);
this.type = "ResultMessage";
}
static decodeResult(result) {
return (0, import_shared2.parseJson)(result, result);
}
static encodeResult(result) {
if (result === void 0) {
return "";
} else if (typeof result === "string") {
return result;
} else {
return JSON.stringify(result);
}
}
};
var AgentStateMessage = class extends Message {
constructor(props) {
super(props);
this.type = "AgentStateMessage";
}
};
var ImageMessage = class extends Message {
constructor(props) {
super(props);
this.type = "ImageMessage";
}
};
// 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) {
const canContainImage = message.role === "assistant" || message.role === "user";
if (!canContainImage || message.image === void 0) {
return false;
}
const isMalformed = message.image.format === void 0 || message.image.bytes === void 0;
if (isMalformed) {
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 AgentStateMessage({
id: message.id,
agentName,
state,
role: 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 === "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 = Role.Developer;
} else if (message.role === "system") {
roleValue = Role.System;
} else if (message.role === "assistant") {
roleValue = Role.Assistant;
} else {
roleValue = Role.User;
}
return new 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(`Failed to parse tool call arguments for ${toolCall.function.name}:`, error);
argumentsObj = {};
}
} else if (typeof toolCall.function.arguments === "object" && toolCall.function.arguments !== null) {
argumentsObj = toolCall.function.arguments;
} else {
console.warn(
`Invalid tool call arguments type for ${toolCall.function.name}:`,
typeof toolCall.function.arguments
);
argumentsObj = {};
}
return new 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 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 AgentStateMessage({
id: message.id,
agentName: "unknown",
state: {},
role: 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 = Role.Assistant;
} else {
roleValue = Role.User;
}
if (message.role !== "assistant" && message.role !== "user") {
throw new Error(`Cannot convert message with role ${message.role} to ImageMessage`);
}
return new ImageMessage({
id: message.id,
format: message.image.format,
bytes: message.image.bytes,
role: roleValue
});
}
// src/message-conversion/gql-to-agui.ts
var VALID_IMAGE_FORMATS = ["jpeg", "png", "webp", "gif"];
function validateImageFormat(format) {
return VALID_IMAGE_FORMATS.includes(format);
}
function gqlToAGUI(messages, actions, coAgentStateRenders) {
let aguiMessages = [];
messages = Array.isArray(messages) ? messages : [messages];
const actionResults = /* @__PURE__ */ new Map();
for (const message of messages) {
if (message.isResultMessage()) {
actionResults.set(message.actionExecutionId, message.result);
}
}
for (const message of messages) {
if (message.isTextMessage()) {
aguiMessages.push(gqlTextMessageToAGUIMessage(message));
} else if (message.isResultMessage()) {
aguiMessages.push(gqlResultMessageToAGUIMessage(message));
} else if (message.isActionExecutionMessage()) {
aguiMessages.push(gqlActionExecutionMessageToAGUIMessage(message, actions, actionResults));
} else if (message.isAgentStateMessage()) {
aguiMessages.push(gqlAgentStateMessageToAGUIMessage(message, coAgentStateRenders));
} else if (message.isImageMessage()) {
aguiMessages.push(gqlImageMessageToAGUIMessage(message));
} else {
throw new Error("Unknown message type");
}
}
return aguiMessages;
}
function gqlActionExecutionMessageToAGUIMessage(message, actions, actionResults) {
const hasSpecificAction = actions && Object.values(actions).some((action2) => action2.name === message.name);
const hasWildcardAction = actions && Object.values(actions).some((action2) => action2.name === "*");
if (!actions || !hasSpecificAction && !hasWildcardAction) {
return {
id: message.id,
role: "assistant",
toolCalls: [actionExecutionMessageToAGUIMessage(message)],
name: message.name
};
}
const action = Object.values(actions).find((action2) => action2.name === message.name) || Object.values(actions).find((action2) => action2.name === "*");
const createRenderWrapper = (originalRender) => {
if (!originalRender)
return void 0;
return (props) => {
var _a;
let actionResult = actionResults == null ? void 0 : actionResults.get(message.id);
let status = "inProgress";
if (actionResult !== void 0) {
status = "complete";
} else if (((_a = message.status) == null ? void 0 : _a.code) !== "Pending" /* Pending */) {
status = "executing";
}
if (typeof (props == null ? void 0 : props.result) === "string") {
try {
props.result = JSON.parse(props.result);
} catch (e) {
}
}
if (typeof actionResult === "string") {
try {
actionResult = JSON.parse(actionResult);
} catch (e) {
}
}
const baseProps = {
status: (props == null ? void 0 : props.status) || status,
args: message.arguments || {},
result: (props == null ? void 0 : props.result) || actionResult || void 0,
messageId: message.id
};
if (action.name === "*") {
return originalRender({
...baseProps,
...props,
name: message.name
});
} else {
const respond = (props == null ? void 0 : props.respond) ?? (() => {
});
return originalRender({
...baseProps,
...props,
respond
});
}
};
};
return {
id: message.id,
role: "assistant",
content: "",
toolCalls: [actionExecutionMessageToAGUIMessage(message)],
generativeUI: createRenderWrapper(action.render),
name: message.name
};
}
function gqlAgentStateMessageToAGUIMessage(message, coAgentStateRenders) {
if (coAgentStateRenders && Object.values(coAgentStateRenders).some((render) => render.name === message.agentName)) {
const render = Object.values(coAgentStateRenders).find(
(render2) => render2.name === message.agentName
);
const createRenderWrapper = (originalRender) => {
if (!originalRender)
return void 0;
return (props) => {
const state = message.state;
const renderProps = {
state
};
return originalRender(renderProps);
};
};
return {
id: message.id,
role: "assistant",
generativeUI: createRenderWrapper(render.render),
agentName: message.agentName,
state: message.state
};
}
return {
id: message.id,
role: "assistant",
agentName: message.agentName,
state: message.state
};
}
function actionExecutionMessageToAGUIMessage(actionExecutionMessage) {
return {
id: actionExecutionMessage.id,
function: {
name: actionExecutionMessage.name,
arguments: JSON.stringify(actionExecutionMessage.arguments)
},
type: "function"
};
}
function gqlTextMessageToAGUIMessage(message) {
switch (message.role) {
case Role.Developer:
return {
id: message.id,
role: "developer",
content: message.content
};
case Role.System:
return {
id: message.id,
role: "system",
content: message.content
};
case Role.Assistant:
return {
id: message.id,
role: "assistant",
content: message.content
};
case Role.User:
return {
id: message.id,
role: "user",
content: message.content
};
default:
throw new Error("Unknown message role");
}
}
function gqlResultMessageToAGUIMessage(message) {
return {
id: message.id,
role: "tool",
content: message.result,
toolCallId: message.actionExecutionId,
toolName: message.actionName
};
}
function gqlImageMessageToAGUIMessage(message) {
if (!validateImageFormat(message.format)) {
throw new Error(
`Invalid image format: ${message.format}. Supported formats are: ${VALID_IMAGE_FORMATS.join(", ")}`
);
}
if (!message.bytes || typeof message.bytes !== "string" || message.bytes.trim() === "") {
throw new Error("Image bytes must be a non-empty string");
}
const role = message.role === Role.Assistant ? "assistant" : "user";
const imageMessage = {
id: message.id,
role,
content: "",
image: {
format: message.format,
bytes: message.bytes
}
};
return imageMessage;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
aguiMessageWithImageToGQLMessage,
aguiMessageWithRenderToGQL,
aguiTextMessageToGQLMessage,
aguiToGQL,
aguiToolCallToGQLActionExecution,
aguiToolMessageToGQLResultMessage,
gqlActionExecutionMessageToAGUIMessage,
gqlImageMessageToAGUIMessage,
gqlResultMessageToAGUIMessage,
gqlTextMessageToAGUIMessage,
gqlToAGUI
});
//# sourceMappingURL=index.js.map