@copilotkit/runtime-client-gql 1.51.4 → 1.51.5-next.1

package/dist/message-conversion/index.js

@@ -1,563 +0,0 @@
-"use strict";
-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";
-    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