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

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

@@ -19013,8 +19013,14 @@ function aguiToGQL(messages, actions, coAgentStateRenders) {
         const actionExecMsg = aguiToolCallToGQLActionExecution(toolCall, message.id);
         if ("generativeUI" in message && message.generativeUI && actions) {
           const actionName = toolCall.function.name;
-          if (actions[actionName]) {
-            actions[actionName].render = message.generativeUI;
+          const specificAction = Object.values(actions).find(
+            (action) => action.name === actionName
+          );
+          const wildcardAction = Object.values(actions).find((action) => action.name === "*");
+          if (specificAction) {
+            specificAction.render = message.generativeUI;
+          } else if (wildcardAction) {
+            wildcardAction.render = message.generativeUI;
           }
         }
         gqlMessages.push(actionExecMsg);
@@ -19663,6 +19669,378 @@ describe("agui-to-gql", () => {
       globalExpect(result.role).toBe(Role.User);
     });
   });
+  describe("Wild Card Actions", () => {
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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();
+    });
+    test3("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();
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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();
+    });
+  });
 });
 /*! Bundled license information: