@copilotkit/runtime-client-gql 1.10.0 → 1.10.1-next.1

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

@@ -5,14 +5,14 @@ import {
   aguiToGQL,
   aguiToolCallToGQLActionExecution,
   aguiToolMessageToGQLResultMessage
-} from "../chunk-YNQMTL2P.mjs";
+} from "../chunk-SCACOKQX.mjs";
 import {
   describe,
   globalExpect,
   test
 } from "../chunk-2R7M2FWR.mjs";
 import "../chunk-7ECCT6PK.mjs";
-import "../chunk-PAQ6AHHC.mjs";
+import "../chunk-5V6B3OXS.mjs";
 import "../chunk-X2UAP3QY.mjs";
 import "../chunk-HEODM5TW.mjs";
 import "../chunk-4KTMZMM2.mjs";
@@ -561,5 +561,497 @@ describe("agui-to-gql", () => {
       globalExpect(result.role).toBe(Role.User);
     });
   });
+  describe("Wild Card Actions", () => {
+    test("should preserve render function for specific action", () => {
+      const mockRender = () => "Specific Action Render";
+      const aguiMessage = {
+        id: "assistant-1",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-1",
+            type: "function",
+            function: {
+              name: "specificAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        specificAction: { name: "specificAction" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions.specificAction.render).toBe(mockRender);
+    });
+    test("should preserve render function for wild card action", () => {
+      const mockRender = () => "Wild Card Action Render";
+      const aguiMessage = {
+        id: "assistant-2",
+        role: "assistant",
+        content: "I'll execute an unknown function",
+        toolCalls: [
+          {
+            id: "tool-call-2",
+            type: "function",
+            function: {
+              name: "unknownAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should prioritize specific action over wild card action", () => {
+      const mockRender = () => "Prioritized Render";
+      const aguiMessage = {
+        id: "assistant-3",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-3",
+            type: "function",
+            function: {
+              name: "specificAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        specificAction: { name: "specificAction" },
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions.specificAction.render).toBe(mockRender);
+      globalExpect(actions["*"].render).toBeUndefined();
+    });
+    test("should not preserve render function when no matching action", () => {
+      const mockRender = () => "Unmatched Render";
+      const aguiMessage = {
+        id: "assistant-4",
+        role: "assistant",
+        content: "I'll execute an unmatched function",
+        toolCalls: [
+          {
+            id: "tool-call-4",
+            type: "function",
+            function: {
+              name: "unmatchedAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        otherAction: { name: "otherAction" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions.otherAction.render).toBeUndefined();
+    });
+    test("should handle multiple tool calls with wild card action", () => {
+      const mockRender = () => "Wild Card Render";
+      const aguiMessage = {
+        id: "assistant-5",
+        role: "assistant",
+        content: "I'll execute multiple functions",
+        toolCalls: [
+          {
+            id: "tool-call-5",
+            type: "function",
+            function: {
+              name: "firstFunction",
+              arguments: JSON.stringify({ param: "value1" })
+            }
+          },
+          {
+            id: "tool-call-6",
+            type: "function",
+            function: {
+              name: "secondFunction",
+              arguments: JSON.stringify({ param: "value2" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(3);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(result[2]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should handle mixed specific and wild card actions", () => {
+      const mockRender = () => "Mixed Render";
+      const aguiMessage = {
+        id: "assistant-6",
+        role: "assistant",
+        content: "I'll execute mixed functions",
+        toolCalls: [
+          {
+            id: "tool-call-7",
+            type: "function",
+            function: {
+              name: "specificAction",
+              arguments: JSON.stringify({ param: "value1" })
+            }
+          },
+          {
+            id: "tool-call-8",
+            type: "function",
+            function: {
+              name: "unknownAction",
+              arguments: JSON.stringify({ param: "value2" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        specificAction: { name: "specificAction" },
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(3);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(result[2]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions.specificAction.render).toBe(mockRender);
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should handle no actions provided", () => {
+      const mockRender = () => "No Actions Render";
+      const aguiMessage = {
+        id: "assistant-7",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-9",
+            type: "function",
+            function: {
+              name: "anyAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const result = aguiToGQL(aguiMessage);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+    });
+    test("should handle empty actions object", () => {
+      const mockRender = () => "Empty Actions Render";
+      const aguiMessage = {
+        id: "assistant-8",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-10",
+            type: "function",
+            function: {
+              name: "anyAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {};
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+    });
+    test("should handle actions with null render functions", () => {
+      const mockRender = () => "Null Render Test";
+      const aguiMessage = {
+        id: "assistant-9",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-11",
+            type: "function",
+            function: {
+              name: "specificAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        specificAction: { name: "specificAction", render: null },
+        "*": { name: "*", render: null }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions.specificAction.render).toBe(mockRender);
+    });
+    test("should handle actions with undefined render functions", () => {
+      const mockRender = () => "Undefined Render Test";
+      const aguiMessage = {
+        id: "assistant-10",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-12",
+            type: "function",
+            function: {
+              name: "wildcardAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        "*": { name: "*", render: void 0 }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should handle tool calls with malformed arguments", () => {
+      const mockRender = () => "Malformed Args Test";
+      const aguiMessage = {
+        id: "assistant-11",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-13",
+            type: "function",
+            function: {
+              name: "wildcardAction",
+              arguments: "invalid json {"
+              // Malformed JSON
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should handle tool calls with empty arguments string", () => {
+      const mockRender = () => "Empty Args Test";
+      const aguiMessage = {
+        id: "assistant-12",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-14",
+            type: "function",
+            function: {
+              name: "wildcardAction",
+              arguments: ""
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should handle multiple wild card actions in same object", () => {
+      const mockRender = () => "Multiple Wildcards Test";
+      const aguiMessage = {
+        id: "assistant-13",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-15",
+            type: "function",
+            function: {
+              name: "unknownAction",
+              arguments: JSON.stringify({ param: "value" })
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        wildcard1: { name: "*" },
+        wildcard2: { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(actions.wildcard1.render).toBe(mockRender);
+      globalExpect(actions.wildcard2.render).toBeUndefined();
+    });
+    test("should handle tool calls with object arguments (backward compatibility)", () => {
+      const mockRender = () => "Object Args Test";
+      const aguiMessage = {
+        id: "assistant-14",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-16",
+            type: "function",
+            function: {
+              name: "objectArgsAction",
+              arguments: { param: "value" }
+              // Object instead of string
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(result[1].arguments).toEqual({ param: "value" });
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should handle tool calls with null/undefined arguments", () => {
+      const mockRender = () => "Null Args Test";
+      const aguiMessage = {
+        id: "assistant-15",
+        role: "assistant",
+        content: "I'll execute a function",
+        toolCalls: [
+          {
+            id: "tool-call-17",
+            type: "function",
+            function: {
+              name: "nullArgsAction",
+              arguments: null
+            }
+          }
+        ],
+        generativeUI: mockRender
+      };
+      const actions = {
+        "*": { name: "*" }
+      };
+      const result = aguiToGQL(aguiMessage, actions);
+      globalExpect(result).toHaveLength(2);
+      globalExpect(result[0]).toBeInstanceOf(TextMessage);
+      globalExpect(result[1]).toBeInstanceOf(ActionExecutionMessage);
+      globalExpect(result[1].arguments).toEqual({});
+      globalExpect(actions["*"].render).toBe(mockRender);
+    });
+    test("should handle tool result messages with object content", () => {
+      const aguiMessage = {
+        id: "tool-result-1",
+        role: "tool",
+        content: { status: "success", data: { value: 42 } },
+        toolCallId: "tool-call-1",
+        toolName: "testAction"
+      };
+      const toolCallNames = { "tool-call-1": "testAction" };
+      const result = aguiToGQL(aguiMessage);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toBeInstanceOf(ResultMessage);
+      globalExpect(result[0].result).toBe('{"status":"success","data":{"value":42}}');
+      globalExpect(result[0].actionExecutionId).toBe("tool-call-1");
+      globalExpect(result[0].actionName).toBe("testAction");
+    });
+    test("should handle tool result messages with non-string content types", () => {
+      const aguiMessage = {
+        id: "tool-result-2",
+        role: "tool",
+        content: 42,
+        toolCallId: "tool-call-2",
+        toolName: "numberAction"
+      };
+      const result = aguiToGQL(aguiMessage);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toBeInstanceOf(ResultMessage);
+      globalExpect(result[0].result).toBe("42");
+      globalExpect(result[0].actionExecutionId).toBe("tool-call-2");
+      globalExpect(result[0].actionName).toBe("numberAction");
+    });
+    test("should handle tool result messages with circular reference content", () => {
+      const circularObj = { status: "success" };
+      circularObj.self = circularObj;
+      const aguiMessage = {
+        id: "tool-result-3",
+        role: "tool",
+        content: circularObj,
+        toolCallId: "tool-call-3",
+        toolName: "circularAction"
+      };
+      const result = aguiToGQL(aguiMessage);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toBeInstanceOf(ResultMessage);
+      globalExpect(result[0].result).toBe("[object Object]");
+      globalExpect(result[0].actionExecutionId).toBe("tool-call-3");
+      globalExpect(result[0].actionName).toBe("circularAction");
+    });
+    test("should handle tool result messages with boolean content", () => {
+      const aguiMessage = {
+        id: "tool-result-4",
+        role: "tool",
+        content: true,
+        toolCallId: "tool-call-4",
+        toolName: "booleanAction"
+      };
+      const result = aguiToGQL(aguiMessage);
+      globalExpect(result).toHaveLength(1);
+      globalExpect(result[0]).toBeInstanceOf(ResultMessage);
+      globalExpect(result[0].result).toBe("true");
+      globalExpect(result[0].actionExecutionId).toBe("tool-call-4");
+      globalExpect(result[0].actionName).toBe("booleanAction");
+    });
+  });
 });
 //# sourceMappingURL=agui-to-gql.test.mjs.map