@copilotkit/runtime-client-gql/dist/chunk-MTD2RJDJ.mjs

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

import {
  Role
} from "./chunk-ROUIRR4B.mjs";

// 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) {
  if (actions && Object.values(actions).some((action) => action.name === message.name)) {
    const action = Object.values(actions).find((action2) => action2.name === message.name);
    const createRenderWrapper = (originalRender) => {
      if (!originalRender)
        return void 0;
      return (props) => {
        var _a;
        const 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";
        }
        const renderProps = {
          status: (props == null ? void 0 : props.status) || status,
          args: message.arguments || {},
          result: (props == null ? void 0 : props.result) || actionResult || void 0,
          respond: (props == null ? void 0 : props.respond) || (() => {
          }),
          messageId: message.id,
          ...props
        };
        return originalRender(renderProps);
      };
    };
    return {
      id: message.id,
      role: "assistant",
      content: "",
      toolCalls: [actionExecutionMessageToAGUIMessage(message)],
      generativeUI: createRenderWrapper(action.render),
      name: message.name
    };
  }
  return {
    id: message.id,
    role: "assistant",
    toolCalls: [actionExecutionMessageToAGUIMessage(message)],
    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;
}

export {
  gqlToAGUI,
  gqlTextMessageToAGUIMessage,
  gqlResultMessageToAGUIMessage,
  gqlImageMessageToAGUIMessage
};
//# sourceMappingURL=chunk-MTD2RJDJ.mjs.map