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

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

@@ -1,1447 +0,0 @@
-import {
-  gqlActionExecutionMessageToAGUIMessage,
-  gqlImageMessageToAGUIMessage,
-  gqlResultMessageToAGUIMessage,
-  gqlTextMessageToAGUIMessage,
-  gqlToAGUI
-} from "../chunk-VIHKTLUA.mjs";
-import {
-  describe,
-  globalExpect,
-  test,
-  vi
-} from "../chunk-A4INSSNE.mjs";
-import "../chunk-7ECCT6PK.mjs";
-import "../chunk-2XWNDVTL.mjs";
-import "../chunk-QUH7QWUA.mjs";
-import "../chunk-E5FOLXLN.mjs";
-import "../chunk-SDQPJXLL.mjs";
-import "../chunk-M4CK5HDR.mjs";
-import {
-  ActionExecutionMessage,
-  AgentStateMessage,
-  ImageMessage,
-  ResultMessage,
-  Role,
-  TextMessage
-} from "../chunk-UOAPP5IN.mjs";
-import "../chunk-OBDQ5BWD.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"
-        // Regular actions should NOT have the name property
-      });
-    });
-    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"
-        // Regular actions should NOT have the name property
-      });
-    });
-    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"
-        // Regular actions should NOT have the name property
-      });
-    });
-    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"
-        // Regular actions should NOT have the name property
-      });
-    });
-    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"
-        }
-      });
-    });
-  });
-  describe("Wild Card Actions", () => {
-    test("should handle action execution with specific action", () => {
-      const actions = {
-        testAction: {
-          name: "testAction",
-          render: vi.fn((props) => `Rendered: ${props.args.test}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-1",
-        name: "testAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-1"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-1",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-1",
-            function: {
-              name: "testAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with wild card action", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Wildcard rendered: ${props.args.test}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-2",
-        name: "unknownAction",
-        arguments: { test: "wildcard-value" },
-        parentMessageId: "parent-2"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-2",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-2",
-            function: {
-              name: "unknownAction",
-              arguments: '{"test":"wildcard-value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "unknownAction"
-      });
-    });
-    test("should pass tool name to wildcard action render function", () => {
-      var _a;
-      const mockRender = vi.fn(
-        (props) => `Wildcard rendered: ${props.name} with args: ${JSON.stringify(props.args)}`
-      );
-      const actions = {
-        "*": {
-          name: "*",
-          render: mockRender
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-wildcard-name",
-        name: "testTool",
-        arguments: { param: "value" },
-        parentMessageId: "parent-wildcard-name"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      (_a = result.generativeUI) == null ? void 0 : _a.call(result);
-      globalExpect(mockRender).toHaveBeenCalledWith(
-        globalExpect.objectContaining({
-          name: "testTool",
-          args: { param: "value" }
-        })
-      );
-    });
-    test("should pass tool name to regular action render function", () => {
-      var _a;
-      const mockRender = vi.fn(
-        (props) => `Regular action rendered: ${JSON.stringify(props.args)}`
-      );
-      const actions = {
-        testAction: {
-          name: "testAction",
-          render: mockRender
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-regular-name",
-        name: "testAction",
-        arguments: { param: "value" },
-        parentMessageId: "parent-regular-name"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      (_a = result.generativeUI) == null ? void 0 : _a.call(result);
-      globalExpect(mockRender).toHaveBeenCalledWith(
-        globalExpect.objectContaining({
-          args: { param: "value" }
-          // name property should NOT be present for regular actions
-        })
-      );
-      const callArgs = mockRender.mock.calls[0][0];
-      globalExpect(callArgs).not.toHaveProperty("name");
-    });
-    test("should prioritize specific action over wild card action", () => {
-      const actions = {
-        specificAction: {
-          name: "specificAction",
-          render: vi.fn((props) => "Specific action rendered")
-        },
-        "*": {
-          name: "*",
-          render: vi.fn((props) => "Wildcard action rendered")
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-3",
-        name: "specificAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-3"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-3",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-3",
-            function: {
-              name: "specificAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "specificAction"
-      });
-    });
-    test("should handle action execution without any matching actions", () => {
-      const actions = {
-        otherAction: {
-          name: "otherAction",
-          render: vi.fn()
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-4",
-        name: "unmatchedAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-4"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-4",
-        role: "assistant",
-        toolCalls: [
-          {
-            id: "action-4",
-            function: {
-              name: "unmatchedAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        name: "unmatchedAction"
-      });
-      globalExpect(result).not.toHaveProperty("generativeUI");
-    });
-    test("should handle action execution with no actions provided", () => {
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-5",
-        name: "anyAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-5"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(actionExecMsg);
-      globalExpect(result).toMatchObject({
-        id: "action-5",
-        role: "assistant",
-        toolCalls: [
-          {
-            id: "action-5",
-            function: {
-              name: "anyAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        name: "anyAction"
-      });
-      globalExpect(result).not.toHaveProperty("generativeUI");
-    });
-    test("should handle action execution with completed result", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Result: ${props.result}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-6",
-        name: "testAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-6"
-      });
-      const actionResults = /* @__PURE__ */ new Map([["action-6", "completed result"]]);
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions,
-        actionResults
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-6",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-6",
-            function: {
-              name: "testAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with executing status", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Status: ${props.status}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-7",
-        name: "testAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-7",
-        status: { code: "Success" /* Success */ }
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-7",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-7",
-            function: {
-              name: "testAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with pending status", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Status: ${props.status}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-8",
-        name: "testAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-8",
-        status: { code: "Pending" /* Pending */ }
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-8",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-8",
-            function: {
-              name: "testAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with failed status", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Status: ${props.status}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-9",
-        name: "testAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-9",
-        status: { code: "Failed" /* Failed */ }
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-9",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-9",
-            function: {
-              name: "testAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with undefined status", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Status: ${props.status}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-10",
-        name: "testAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-10"
-        // No status field
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-10",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-10",
-            function: {
-              name: "testAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with empty arguments", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Args: ${JSON.stringify(props.args)}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-11",
-        name: "testAction",
-        arguments: {},
-        parentMessageId: "parent-11"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-11",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-11",
-            function: {
-              name: "testAction",
-              arguments: "{}"
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with null arguments", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Args: ${JSON.stringify(props.args)}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-12",
-        name: "testAction",
-        arguments: null,
-        parentMessageId: "parent-12"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-12",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-12",
-            function: {
-              name: "testAction",
-              arguments: "null"
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle action execution with complex nested arguments", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Complex: ${JSON.stringify(props.args)}`)
-        }
-      };
-      const complexArgs = {
-        nested: {
-          array: [1, 2, 3],
-          object: { key: "value" },
-          nullValue: null,
-          undefinedValue: void 0
-        },
-        string: "test",
-        number: 42,
-        boolean: true
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-13",
-        name: "testAction",
-        arguments: complexArgs,
-        parentMessageId: "parent-13"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-13",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-13",
-            function: {
-              name: "testAction",
-              arguments: JSON.stringify(complexArgs)
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "testAction"
-      });
-    });
-    test("should handle multiple wild card actions (should use first one)", () => {
-      const actions = {
-        wildcard1: {
-          name: "*",
-          render: vi.fn((props) => "First wildcard")
-        },
-        wildcard2: {
-          name: "*",
-          render: vi.fn((props) => "Second wildcard")
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-14",
-        name: "unknownAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-14"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions
-      );
-      globalExpect(result).toMatchObject({
-        id: "action-14",
-        role: "assistant",
-        content: "",
-        toolCalls: [
-          {
-            id: "action-14",
-            function: {
-              name: "unknownAction",
-              arguments: '{"test":"value"}'
-            },
-            type: "function"
-          }
-        ],
-        generativeUI: globalExpect.any(Function),
-        name: "unknownAction"
-      });
-    });
-    test("should parse string results in generativeUI props", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Result: ${JSON.stringify(props.result)}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-string-result",
-        name: "stringResultAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-string"
-      });
-      const actionResults = /* @__PURE__ */ new Map();
-      actionResults.set(
-        "action-string-result",
-        '{"parsed": true, "value": 42}'
-      );
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions,
-        actionResults
-      );
-      globalExpect(result.generativeUI).toBeDefined();
-      const renderResult = result.generativeUI({
-        result: '{"from": "props", "data": "test"}'
-      });
-      globalExpect(actions["*"].render).toHaveBeenCalledWith(
-        globalExpect.objectContaining({
-          result: { from: "props", data: "test" },
-          // Should be parsed from string
-          args: { test: "value" },
-          status: "complete",
-          messageId: "action-string-result"
-        })
-      );
-    });
-    test("should handle malformed JSON strings gracefully in results", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Result: ${JSON.stringify(props.result)}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-malformed",
-        name: "malformedAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-malformed"
-      });
-      const actionResults = /* @__PURE__ */ new Map();
-      actionResults.set("action-malformed", "invalid json {");
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions,
-        actionResults
-      );
-      globalExpect(result.generativeUI).toBeDefined();
-      const renderResult = result.generativeUI({
-        result: "invalid json {"
-      });
-      globalExpect(actions["*"].render).toHaveBeenCalledWith(
-        globalExpect.objectContaining({
-          result: "invalid json {",
-          // Should remain as string due to parse error
-          args: { test: "value" },
-          status: "complete",
-          messageId: "action-malformed"
-        })
-      );
-    });
-    test("should handle non-string results without parsing", () => {
-      const actions = {
-        "*": {
-          name: "*",
-          render: vi.fn((props) => `Result: ${JSON.stringify(props.result)}`)
-        }
-      };
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-object-result",
-        name: "objectResultAction",
-        arguments: { test: "value" },
-        parentMessageId: "parent-object"
-      });
-      const actionResults = /* @__PURE__ */ new Map();
-      actionResults.set("action-object-result", '{"already": "parsed"}');
-      const result = gqlActionExecutionMessageToAGUIMessage(
-        actionExecMsg,
-        actions,
-        actionResults
-      );
-      globalExpect(result.generativeUI).toBeDefined();
-      const renderResult = result.generativeUI({
-        result: { from: "props", data: "object" }
-      });
-      globalExpect(actions["*"].render).toHaveBeenCalledWith(
-        globalExpect.objectContaining({
-          result: { from: "props", data: "object" },
-          // Should remain as object
-          args: { test: "value" },
-          status: "complete",
-          messageId: "action-object-result"
-        })
-      );
-    });
-    test("should handle action execution arguments correctly with simplified conversion", () => {
-      const actionExecMsg = new ActionExecutionMessage({
-        id: "action-simplified",
-        name: "simplifiedAction",
-        arguments: { complex: { nested: "value" }, array: [1, 2, 3] },
-        parentMessageId: "parent-simplified"
-      });
-      const result = gqlActionExecutionMessageToAGUIMessage(actionExecMsg);
-      globalExpect(result).toMatchObject({
-        id: "action-simplified",
-        role: "assistant",
-        toolCalls: [
-          {
-            id: "action-simplified",
-            function: {
-              name: "simplifiedAction",
-              arguments: '{"complex":{"nested":"value"},"array":[1,2,3]}'
-            },
-            type: "function"
-          }
-        ],
-        name: "simplifiedAction"
-      });
-    });
-  });
-});
-//# sourceMappingURL=gql-to-agui.test.mjs.map