@copilotkit/runtime-client-gql 1.9.3-next.4 → 1.10.0-next.0

package/dist/message-conversion/gql-to-agui.test.mjs

@@ -0,0 +1,737 @@
+import {
+  gqlImageMessageToAGUIMessage,
+  gqlResultMessageToAGUIMessage,
+  gqlTextMessageToAGUIMessage,
+  gqlToAGUI
+} from "../chunk-MTD2RJDJ.mjs";
+import {
+  describe,
+  globalExpect,
+  test,
+  vi
+} from "../chunk-2R7M2FWR.mjs";
+import "../chunk-7ECCT6PK.mjs";
+import "../chunk-UQACSQNW.mjs";
+import "../chunk-X2UAP3QY.mjs";
+import "../chunk-HEODM5TW.mjs";
+import "../chunk-4KTMZMM2.mjs";
+import "../chunk-P2AUSQOK.mjs";
+import {
+  ActionExecutionMessage,
+  AgentStateMessage,
+  ImageMessage,
+  ResultMessage,
+  Role,
+  TextMessage
+} from "../chunk-ROUIRR4B.mjs";
+import "../chunk-WM3ARNBD.mjs";
+import "../chunk-DELDZXUX.mjs";
+
+// src/message-conversion/gql-to-agui.test.ts
+describe("message-conversion", () => {
+  describe("gqlTextMessageToAGUIMessage", () => {
+    test("should convert developer message", () => {
+      const gqlMessage = new TextMessage({
+        id: "dev-message-id",
+        content: "Hello from developer",
+        role: Role.Developer
+      });
+      const result = gqlTextMessageToAGUIMessage(gqlMessage);
+      globalExpect(result).toEqual({
+        id: "dev-message-id",
+        role: "developer",
+        content: "Hello from developer"
+      });
+    });
+    test("should convert system message", () => {
+      const gqlMessage = new TextMessage({
+        id: "system-message-id",
+        content: "System instruction",
+        role: Role.System
+      });
+      const result = gqlTextMessageToAGUIMessage(gqlMessage);
+      globalExpect(result).toEqual({
+        id: "system-message-id",
+        role: "system",
+        content: "System instruction"
+      });
+    });
+    test("should convert assistant message", () => {
+      const gqlMessage = new TextMessage({
+        id: "assistant-message-id",
+        content: "Assistant response",
+        role: Role.Assistant
+      });
+      const result = gqlTextMessageToAGUIMessage(gqlMessage);
+      globalExpect(result).toEqual({
+        id: "assistant-message-id",
+        role: "assistant",
+        content: "Assistant response"
+      });
+    });
+    test("should throw error for unknown role", () => {
+      const gqlMessage = new TextMessage({
+        id: "unknown-message-id",
+        content: "Unknown message",
+        role: "unknown"
+      });
+      globalExpect(() => gqlTextMessageToAGUIMessage(gqlMessage)).toThrow("Unknown message role");
+    });
+  });
+  describe("gqlResultMessageToAGUIMessage", () => {
+    test("should convert result message to tool message", () => {
+      const gqlMessage = new ResultMessage({
+        id: "result-id",
+        result: "Function result data",
+        actionExecutionId: "action-exec-123",
+        actionName: "testAction"
+      });
+      const result = gqlResultMessageToAGUIMessage(gqlMessage);
+      globalExpect(result).toEqual({
+        id: "result-id",
+        role: "tool",
+        content: "Function result data",
+        toolCallId: "action-exec-123",
+        toolName: "testAction"
+      });
+    });
+  });
+  describe("gqlToAGUI", () => {
+    test("should convert an array of text messages", () => {
+      const gqlMessages = [
+        new TextMessage({
+          id: "dev-1",
+          content: "Hello",
+          role: Role.Developer
+        }),
+        new TextMessage({
+          id: "assistant-1",
+          content: "Hi there",
+          role: Role.Assistant
+        })
+      ];
+      const result = gqlToAGUI(gqlMessages);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toEqual({
+        id: "dev-1",
+        role: "developer",
+        content: "Hello"
+      });
+      globalExpect(result[1]).toEqual({
+        id: "assistant-1",
+        role: "assistant",
+        content: "Hi there"
+      });
+    });
+    test("should handle agent state messages", () => {
+      const gqlMessages = [new AgentStateMessage({ id: "agent-state-1" })];
+      const result = gqlToAGUI(gqlMessages);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toEqual({
+        id: "agent-state-1",
+        role: "assistant"
+      });
+    });
+    test("should handle a mix of message types", () => {
+      const gqlMessages = [
+        new TextMessage({
+          id: "dev-1",
+          content: "Run action",
+          role: Role.Developer
+        }),
+        new TextMessage({
+          id: "assistant-1",
+          content: "I'll run the action",
+          role: Role.Assistant
+        }),
+        new ResultMessage({
+          id: "result-1",
+          result: "Action result",
+          actionExecutionId: "action-exec-1",
+          actionName: "testAction"
+        })
+      ];
+      const result = gqlToAGUI(gqlMessages);
+      globalExpect(result).toHaveLength(3);
+      globalExpect(result[0]).toEqual({
+        id: "dev-1",
+        role: "developer",
+        content: "Run action"
+      });
+      globalExpect(result[1]).toEqual({
+        id: "assistant-1",
+        role: "assistant",
+        content: "I'll run the action"
+      });
+      globalExpect(result[2]).toEqual({
+        id: "result-1",
+        role: "tool",
+        content: "Action result",
+        toolCallId: "action-exec-1",
+        toolName: "testAction"
+      });
+    });
+    test("should handle action execution messages with parent messages", () => {
+      const assistantMsg = new TextMessage({
+        id: "assistant-1",
+        content: "I'll execute an action",
+        role: Role.Assistant
+      });
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" },
+        parentMessageId: "assistant-1"
+      });
+      const result = gqlToAGUI([assistantMsg, actionExecMsg]);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toEqual({
+        id: "assistant-1",
+        role: "assistant",
+        content: "I'll execute an action"
+      });
+      globalExpect(result[1]).toEqual({
+        id: "action-1",
+        role: "assistant",
+        name: "testAction",
+        toolCalls: [
+          {
+            id: "action-1",
+            function: {
+              name: "testAction",
+              arguments: JSON.stringify({ param: "value" })
+            },
+            type: "function"
+          }
+        ]
+      });
+    });
+    test("should handle multiple action execution messages for the same parent", () => {
+      const assistantMsg = new TextMessage({
+        id: "assistant-1",
+        content: "I'll execute multiple actions",
+        role: Role.Assistant
+      });
+      const action1 = new ActionExecutionMessage({
+        id: "action-1",
+        name: "firstAction",
+        arguments: { param: "value1" },
+        parentMessageId: "assistant-1"
+      });
+      const action2 = new ActionExecutionMessage({
+        id: "action-2",
+        name: "secondAction",
+        arguments: { param: "value2" },
+        parentMessageId: "assistant-1"
+      });
+      const result = gqlToAGUI([assistantMsg, action1, action2]);
+      globalExpect(result).toHaveLength(3);
+      globalExpect(result[0]).toEqual({
+        id: "assistant-1",
+        role: "assistant",
+        content: "I'll execute multiple actions"
+      });
+      globalExpect(result[1]).toEqual({
+        id: "action-1",
+        role: "assistant",
+        name: "firstAction",
+        toolCalls: [
+          {
+            id: "action-1",
+            function: {
+              name: "firstAction",
+              arguments: JSON.stringify({ param: "value1" })
+            },
+            type: "function"
+          }
+        ]
+      });
+      globalExpect(result[2]).toEqual({
+        id: "action-2",
+        role: "assistant",
+        name: "secondAction",
+        toolCalls: [
+          {
+            id: "action-2",
+            function: {
+              name: "secondAction",
+              arguments: JSON.stringify({ param: "value2" })
+            },
+            type: "function"
+          }
+        ]
+      });
+    });
+    test("should not add toolCalls to non-assistant messages", () => {
+      const developerMsg = new TextMessage({
+        id: "dev-1",
+        content: "Developer message",
+        role: Role.Developer
+      });
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" },
+        parentMessageId: "dev-1"
+        // This should be ignored since parent is not assistant
+      });
+      const result = gqlToAGUI([developerMsg, actionExecMsg]);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toEqual({
+        id: "dev-1",
+        role: "developer",
+        content: "Developer message"
+      });
+      globalExpect(result[1]).toEqual({
+        id: "action-1",
+        role: "assistant",
+        name: "testAction",
+        toolCalls: [
+          {
+            id: "action-1",
+            function: {
+              name: "testAction",
+              arguments: JSON.stringify({ param: "value" })
+            },
+            type: "function"
+          }
+        ]
+      });
+    });
+    test("should handle action execution messages without actions context", () => {
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" }
+      });
+      const result = gqlToAGUI([actionExecMsg]);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toEqual({
+        id: "action-1",
+        role: "assistant",
+        name: "testAction",
+        toolCalls: [
+          {
+            id: "action-1",
+            function: {
+              name: "testAction",
+              arguments: JSON.stringify({ param: "value" })
+            },
+            type: "function"
+          }
+        ]
+      });
+      globalExpect(result[0]).not.toHaveProperty("render");
+      globalExpect(result[0]).not.toHaveProperty("renderAndWaitForResponse");
+    });
+    test("should handle action execution messages with actions context and render functions", () => {
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" },
+        status: { code: "Pending" /* Pending */ }
+      });
+      const mockRender = vi.fn();
+      const mockRenderAndWaitForResponse = (props) => "Test Render With Response";
+      const actions = {
+        testAction: {
+          name: "testAction",
+          render: mockRender,
+          renderAndWaitForResponse: mockRenderAndWaitForResponse
+        }
+      };
+      const result = gqlToAGUI([actionExecMsg], actions);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toMatchObject({
+        id: "action-1",
+        role: "assistant",
+        name: "testAction",
+        content: "",
+        toolCalls: [
+          {
+            id: "action-1",
+            function: {
+              name: "testAction",
+              arguments: JSON.stringify({ param: "value" })
+            },
+            type: "function"
+          }
+        ]
+      });
+      globalExpect(result[0]).toHaveProperty("generativeUI");
+      globalExpect(typeof result[0].generativeUI).toBe("function");
+    });
+    test("should provide correct status in generativeUI function props", () => {
+      var _a, _b;
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" },
+        status: { code: "Pending" /* Pending */ }
+      });
+      const mockRender = vi.fn();
+      const actions = {
+        testAction: {
+          name: "testAction",
+          render: mockRender
+        }
+      };
+      const result = gqlToAGUI([actionExecMsg], actions);
+      (_b = (_a = result[0]).generativeUI) == null ? void 0 : _b.call(_a);
+      globalExpect(mockRender).toHaveBeenCalledWith({
+        status: "inProgress",
+        args: { param: "value" },
+        result: void 0,
+        respond: globalExpect.any(Function),
+        messageId: "action-1"
+      });
+    });
+    test("should provide executing status when not pending", () => {
+      var _a, _b;
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" },
+        status: { code: "Success" /* Success */ }
+      });
+      const mockRender = vi.fn();
+      const actions = {
+        testAction: {
+          name: "testAction",
+          render: mockRender
+        }
+      };
+      const result = gqlToAGUI([actionExecMsg], actions);
+      (_b = (_a = result[0]).generativeUI) == null ? void 0 : _b.call(_a);
+      globalExpect(mockRender).toHaveBeenCalledWith({
+        status: "executing",
+        args: { param: "value" },
+        result: void 0,
+        respond: globalExpect.any(Function),
+        messageId: "action-1"
+      });
+    });
+    test("should provide complete status when result is available", () => {
+      var _a;
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" },
+        status: { code: "Success" /* Success */ }
+      });
+      const resultMsg = new ResultMessage({
+        id: "result-1",
+        result: "Action completed successfully",
+        actionExecutionId: "action-1",
+        actionName: "testAction"
+      });
+      const mockRender = vi.fn();
+      const actions = {
+        testAction: {
+          name: "testAction",
+          render: mockRender
+        }
+      };
+      const result = gqlToAGUI([actionExecMsg, resultMsg], actions);
+      const actionMessage = result.find((msg) => msg.role === "assistant" && "toolCalls" in msg);
+      (_a = actionMessage == null ? void 0 : actionMessage.generativeUI) == null ? void 0 : _a.call(actionMessage);
+      globalExpect(mockRender).toHaveBeenCalledWith({
+        status: "complete",
+        args: { param: "value" },
+        result: "Action completed successfully",
+        respond: globalExpect.any(Function),
+        messageId: "action-1"
+      });
+    });
+    test("should handle generativeUI function props override", () => {
+      var _a, _b;
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" },
+        status: { code: "Pending" /* Pending */ }
+      });
+      const mockRender = vi.fn();
+      const actions = {
+        testAction: {
+          name: "testAction",
+          render: mockRender
+        }
+      };
+      const result = gqlToAGUI([actionExecMsg], actions);
+      (_b = (_a = result[0]).generativeUI) == null ? void 0 : _b.call(_a, {
+        status: "custom",
+        customProp: "test",
+        respond: () => "custom respond"
+      });
+      globalExpect(mockRender).toHaveBeenCalledWith({
+        status: "custom",
+        args: { param: "value" },
+        result: void 0,
+        respond: globalExpect.any(Function),
+        customProp: "test",
+        messageId: "action-1"
+      });
+    });
+    test("should handle missing render functions gracefully", () => {
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "testAction",
+        arguments: { param: "value" }
+      });
+      const actions = {
+        testAction: {
+          name: "testAction"
+          // No render functions provided
+        }
+      };
+      const result = gqlToAGUI([actionExecMsg], actions);
+      globalExpect(result[0]).toMatchObject({
+        id: "action-1",
+        role: "assistant",
+        name: "testAction",
+        content: "",
+        toolCalls: [
+          {
+            id: "action-1",
+            function: {
+              name: "testAction",
+              arguments: JSON.stringify({ param: "value" })
+            },
+            type: "function"
+          }
+        ]
+      });
+      globalExpect(result[0].generativeUI).toBeUndefined();
+    });
+    test("should handle action not found in actions context", () => {
+      const actionExecMsg = new ActionExecutionMessage({
+        id: "action-1",
+        name: "unknownAction",
+        arguments: { param: "value" }
+      });
+      const actions = {
+        testAction: {
+          name: "testAction",
+          render: () => "Test"
+        }
+      };
+      const result = gqlToAGUI([actionExecMsg], actions);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toEqual({
+        id: "action-1",
+        role: "assistant",
+        name: "unknownAction",
+        toolCalls: [
+          {
+            id: "action-1",
+            function: {
+              name: "unknownAction",
+              arguments: JSON.stringify({ param: "value" })
+            },
+            type: "function"
+          }
+        ]
+      });
+      globalExpect(result[0]).not.toHaveProperty("generativeUI");
+    });
+    test("should handle agent state messages with coAgentStateRenders", () => {
+      var _a, _b;
+      const agentStateMsg = new AgentStateMessage({
+        id: "agent-state-1",
+        agentName: "testAgent",
+        state: { status: "running", data: "test data" },
+        role: Role.Assistant
+      });
+      const mockRender = vi.fn();
+      const coAgentStateRenders = {
+        testAgent: {
+          name: "testAgent",
+          render: mockRender
+        }
+      };
+      const result = gqlToAGUI([agentStateMsg], void 0, coAgentStateRenders);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toEqual({
+        id: "agent-state-1",
+        role: "assistant",
+        agentName: "testAgent",
+        state: { status: "running", data: "test data" },
+        generativeUI: globalExpect.any(Function)
+      });
+      globalExpect(result[0]).toHaveProperty("generativeUI");
+      globalExpect(typeof result[0].generativeUI).toBe("function");
+      (_b = (_a = result[0]).generativeUI) == null ? void 0 : _b.call(_a);
+      globalExpect(mockRender).toHaveBeenCalledWith({
+        state: { status: "running", data: "test data" }
+      });
+    });
+    test("should handle agent state messages without coAgentStateRenders", () => {
+      const agentStateMsg = new AgentStateMessage({
+        id: "agent-state-1",
+        agentName: "testAgent",
+        state: { status: "running", data: "test data" },
+        role: Role.Assistant
+      });
+      const result = gqlToAGUI([agentStateMsg]);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toEqual({
+        id: "agent-state-1",
+        role: "assistant",
+        agentName: "testAgent",
+        state: { status: "running", data: "test data" }
+      });
+      globalExpect(result[0]).not.toHaveProperty("generativeUI");
+    });
+    test("should handle agent state messages with agent not found in coAgentStateRenders", () => {
+      const agentStateMsg = new AgentStateMessage({
+        id: "agent-state-1",
+        agentName: "unknownAgent",
+        state: { status: "running", data: "test data" },
+        role: Role.Assistant
+      });
+      const coAgentStateRenders = {
+        testAgent: {
+          name: "testAgent",
+          render: () => "Test"
+        }
+      };
+      const result = gqlToAGUI([agentStateMsg], void 0, coAgentStateRenders);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toEqual({
+        id: "agent-state-1",
+        role: "assistant",
+        agentName: "unknownAgent",
+        state: { status: "running", data: "test data" }
+      });
+      globalExpect(result[0]).not.toHaveProperty("generativeUI");
+    });
+    test("should handle user role messages", () => {
+      const userMsg = new TextMessage({
+        id: "user-1",
+        content: "Hello from user",
+        role: Role.User
+      });
+      const result = gqlToAGUI([userMsg]);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toEqual({
+        id: "user-1",
+        role: "user",
+        content: "Hello from user"
+      });
+    });
+    test("should handle mixed message types including agent state messages", () => {
+      const textMsg = new TextMessage({
+        id: "text-1",
+        content: "Hello",
+        role: Role.Assistant
+      });
+      const agentStateMsg = new AgentStateMessage({
+        id: "agent-state-1",
+        agentName: "testAgent",
+        state: { status: "running" },
+        role: Role.Assistant
+      });
+      const mockRender = vi.fn();
+      const coAgentStateRenders = {
+        testAgent: {
+          name: "testAgent",
+          render: mockRender
+        }
+      };
+      const result = gqlToAGUI([textMsg, agentStateMsg], void 0, coAgentStateRenders);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toEqual({
+        id: "text-1",
+        role: "assistant",
+        content: "Hello"
+      });
+      globalExpect(result[1]).toMatchObject({
+        id: "agent-state-1",
+        role: "assistant",
+        agentName: "testAgent",
+        state: { status: "running" },
+        generativeUI: globalExpect.any(Function)
+      });
+      globalExpect(result[1]).toHaveProperty("generativeUI");
+    });
+  });
+  describe("gqlImageMessageToAGUIMessage", () => {
+    test("should throw error for invalid image format", () => {
+      const invalidImageMsg = new ImageMessage({
+        id: "img-1",
+        format: "bmp",
+        // not in VALID_IMAGE_FORMATS
+        bytes: "somebase64string",
+        role: Role.User
+      });
+      globalExpect(() => gqlImageMessageToAGUIMessage(invalidImageMsg)).toThrow("Invalid image format");
+    });
+    test("should throw error for empty image bytes", () => {
+      const invalidImageMsg = new ImageMessage({
+        id: "img-2",
+        format: "jpeg",
+        bytes: "",
+        role: Role.User
+      });
+      globalExpect(() => gqlImageMessageToAGUIMessage(invalidImageMsg)).toThrow(
+        "Image bytes must be a non-empty string"
+      );
+    });
+    test("should convert valid image message", () => {
+      const validImageMsg = new ImageMessage({
+        id: "img-3",
+        format: "jpeg",
+        bytes: "somebase64string",
+        role: Role.User
+      });
+      const result = gqlImageMessageToAGUIMessage(validImageMsg);
+      globalExpect(result).toMatchObject({
+        id: "img-3",
+        role: "user",
+        content: "",
+        image: {
+          format: "jpeg",
+          bytes: "somebase64string"
+        }
+      });
+    });
+    test("should convert valid user image message", () => {
+      const validImageMsg = new ImageMessage({
+        id: "img-user-1",
+        format: "jpeg",
+        bytes: "userbase64string",
+        role: Role.User
+      });
+      const result = gqlImageMessageToAGUIMessage(validImageMsg);
+      globalExpect(result).toMatchObject({
+        id: "img-user-1",
+        role: "user",
+        content: "",
+        image: {
+          format: "jpeg",
+          bytes: "userbase64string"
+        }
+      });
+    });
+    test("should convert valid assistant image message", () => {
+      const validImageMsg = new ImageMessage({
+        id: "img-assistant-1",
+        format: "png",
+        bytes: "assistantbase64string",
+        role: Role.Assistant
+      });
+      const result = gqlImageMessageToAGUIMessage(validImageMsg);
+      globalExpect(result).toMatchObject({
+        id: "img-assistant-1",
+        role: "assistant",
+        content: "",
+        image: {
+          format: "png",
+          bytes: "assistantbase64string"
+        }
+      });
+    });
+  });
+});
+//# sourceMappingURL=gql-to-agui.test.mjs.map