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

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);
@@ -19060,10 +19066,20 @@ function aguiToolCallToGQLActionExecution(toolCall, parentMessageId) {
     throw new Error(`Unsupported tool call type: ${toolCall.type}`);
   }
   let argumentsObj;
-  try {
-    argumentsObj = JSON.parse(toolCall.function.arguments);
-  } catch (error) {
-    console.warn(`Failed to parse tool call arguments for ${toolCall.function.name}:`, error);
+  if (typeof toolCall.function.arguments === "string") {
+    try {
+      argumentsObj = JSON.parse(toolCall.function.arguments);
+    } catch (error) {
+      console.warn(`Failed to parse tool call arguments for ${toolCall.function.name}:`, error);
+      argumentsObj = {};
+    }
+  } else if (typeof toolCall.function.arguments === "object" && toolCall.function.arguments !== null) {
+    argumentsObj = toolCall.function.arguments;
+  } else {
+    console.warn(
+      `Invalid tool call arguments type for ${toolCall.function.name}:`,
+      typeof toolCall.function.arguments
+    );
     argumentsObj = {};
   }
   return new ActionExecutionMessage({
@@ -19081,9 +19097,23 @@ function aguiToolMessageToGQLResultMessage(message, toolCallNames) {
     throw new Error("Tool message must have a toolCallId");
   }
   const actionName = toolCallNames[message.toolCallId] || "unknown";
+  let resultContent;
+  const messageContent = message.content || "";
+  if (typeof messageContent === "string") {
+    resultContent = messageContent;
+  } else if (typeof messageContent === "object" && messageContent !== null) {
+    try {
+      resultContent = JSON.stringify(messageContent);
+    } catch (error) {
+      console.warn(`Failed to stringify tool result for ${actionName}:`, error);
+      resultContent = String(messageContent);
+    }
+  } else {
+    resultContent = String(messageContent);
+  }
   return new ResultMessage({
     id: message.id,
-    result: message.content || "",
+    result: resultContent,
     actionExecutionId: message.toolCallId,
     actionName: message.toolName || actionName
   });
@@ -19663,6 +19693,498 @@ 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();
+    });
+    test3("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);
+    });
+    test3("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);
+    });
+    test3("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");
+    });
+    test3("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");
+    });
+    test3("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");
+    });
+    test3("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");
+    });
+  });
 });
 /*! Bundled license information: