@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;" />
323 lines (319 loc) • 10.7 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/agui-to-gql.ts
var agui_to_gql_exports = {};
__export(agui_to_gql_exports, {
aguiMessageWithImageToGQLMessage: () => aguiMessageWithImageToGQLMessage,
aguiMessageWithRenderToGQL: () => aguiMessageWithRenderToGQL,
aguiTextMessageToGQLMessage: () => aguiTextMessageToGQLMessage,
aguiToGQL: () => aguiToGQL,
aguiToolCallToGQLActionExecution: () => aguiToolCallToGQLActionExecution,
aguiToolMessageToGQLResultMessage: () => aguiToolMessageToGQLResultMessage
});
module.exports = __toCommonJS(agui_to_gql_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
});
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
aguiMessageWithImageToGQLMessage,
aguiMessageWithRenderToGQL,
aguiTextMessageToGQLMessage,
aguiToGQL,
aguiToolCallToGQLActionExecution,
aguiToolMessageToGQLResultMessage
});
//# sourceMappingURL=agui-to-gql.js.map