llm-exe 2.2.1 → 2.3.0

package/dist/index.mjs

@@ -346,12 +346,56 @@ function assert(condition, message) {
   }
 }
 
+// src/utils/guards.ts
+var guards_exports = {};
+__export(guards_exports, {
+  hasFunctionCall: () => hasFunctionCall,
+  hasToolCall: () => hasToolCall,
+  isAssistantMessage: () => isAssistantMessage,
+  isFunctionCall: () => isFunctionCall,
+  isOutputResult: () => isOutputResult,
+  isOutputResultContentText: () => isOutputResultContentText,
+  isSystemMessage: () => isSystemMessage,
+  isToolCall: () => isToolCall,
+  isUserMessage: () => isUserMessage
+});
+function isOutputResult(obj) {
+  return !!(obj && typeof obj === "object" && "id" in obj && "stopReason" in obj && "content" in obj && Array.isArray(obj.content));
+}
+function isOutputResultContentText(obj) {
+  return !!(obj && typeof obj === "object" && "text" in obj && "type" in obj && obj.type === "text" && typeof obj.text === "string");
+}
+function isFunctionCall(result) {
+  return !!(result && typeof result === "object" && "functionId" in result && "type" in result && result.type === "function_use");
+}
+function isToolCall(result) {
+  return isFunctionCall(result);
+}
+function hasFunctionCall(results) {
+  return !!(results && Array.isArray(results) && results.some(isToolCall));
+}
+function hasToolCall(results) {
+  return hasFunctionCall(results);
+}
+function isUserMessage(message) {
+  return message.role === "user";
+}
+function isAssistantMessage(message) {
+  return message.role === "assistant" || message.role === "model";
+}
+function isSystemMessage(message) {
+  return message.role === "system";
+}
+
 // src/parser/parsers/StringParser.ts
 var StringParser = class extends BaseParser {
   constructor(options) {
     super("string", options);
   }
   parse(text, _options) {
+    if (isOutputResult(text)) {
+      return text.content?.[0]?.text ?? "";
+    }
     assert(
       typeof text === "string",
       `Invalid input. Expected string. Received ${typeof text}.`
@@ -1661,15 +1705,26 @@ function createCustomParser(name, parserFn) {
   return new CustomParser(name, parserFn);
 }
 
-// src/llm/output/_utils/getResultText.ts
-function getResultText(content) {
-  if (content.length === 1 && content.every((a) => a.type === "text")) {
-    return content[0]?.text || "";
-  }
-  return "";
-}
-
 // src/parser/parsers/LlmNativeFunctionParser.ts
+var LlmFunctionParser = class extends BaseParser {
+  constructor(options) {
+    super("functionCall", options, "function_call");
+    __publicField(this, "parser");
+    this.parser = options.parser;
+  }
+  parse(text, _options) {
+    if (typeof text === "string") {
+      return this.parser.parse(text);
+    }
+    const { content } = text;
+    const functionUses = content?.filter((a) => a.type === "function_use") || [];
+    if (functionUses.length === 0) {
+      const [item] = content;
+      return this.parser.parse(item.text);
+    }
+    return content;
+  }
+};
 var LlmNativeFunctionParser = class extends BaseParser {
   constructor(options) {
     super("openAiFunction", options, "function_call");
@@ -1677,14 +1732,15 @@ var LlmNativeFunctionParser = class extends BaseParser {
     this.parser = options.parser;
   }
   parse(text, _options) {
-    const functionUse = text?.find((a) => a.type === "function_use");
+    const { content } = text;
+    const functionUse = content?.find((a) => a.type === "function_use");
     if (functionUse && "name" in functionUse && "input" in functionUse) {
       return {
         name: functionUse.name,
         arguments: maybeParseJSON(functionUse.input)
       };
     }
-    return this.parser.parse(getResultText(text));
+    return this.parser.parse(text?.text ?? text);
   }
 };
 var OpenAiFunctionParser = LlmNativeFunctionParser;
@@ -1744,7 +1800,7 @@ var LlmExecutor = class extends BaseExecutor {
   }
   getHandlerOutput(out, _metadata) {
     if (this.parser.target === "function_call") {
-      const outToStr = out.getResultContent();
+      const outToStr = out.getResult();
       return this.parser.parse(outToStr, _metadata);
     } else {
       const outToStr = out.getResultText();
@@ -1769,7 +1825,7 @@ var LlmExecutorWithFunctions = class extends LlmExecutor {
   constructor(llmConfiguration, options) {
     super(
       Object.assign({}, llmConfiguration, {
-        parser: new LlmNativeFunctionParser({
+        parser: new LlmFunctionParser({
           parser: llmConfiguration.parser || new StringParser()
         })
       }),
@@ -1780,7 +1836,23 @@ var LlmExecutorWithFunctions = class extends LlmExecutor {
     return super.execute(_input, _options);
   }
 };
-var LlmExecutorOpenAiFunctions = class extends LlmExecutorWithFunctions {
+var LlmExecutorOpenAiFunctions = class extends LlmExecutor {
+  constructor(llmConfiguration, options) {
+    super(
+      Object.assign({}, llmConfiguration, {
+        parser: new LlmNativeFunctionParser({
+          parser: llmConfiguration.parser || new StringParser()
+        })
+      }),
+      options
+    );
+    console.warn(
+      `LlmExecutorOpenAiFunctions is deprecated. Please migrate to LlmExecutorWithFunctions`
+    );
+  }
+  async execute(_input, _options) {
+    return super.execute(_input, _options);
+  }
 };
 
 // src/executor/_functions.ts
@@ -1985,6 +2057,39 @@ function getEnvironmentVariable(name) {
   }
 }
 
+// src/llm/config/openai/promptSanitizeMessageCallback.ts
+function openaiPromptMessageCallback(_message) {
+  let message = { ..._message };
+  if (message.role === "function") {
+    message.role = "tool";
+    message.tool_call_id = message.id;
+    delete message.id;
+  }
+  if (message?.function_call) {
+    const { function_call } = message;
+    const toolsArr = Array.isArray(function_call) ? function_call : [function_call];
+    message.role = "assistant";
+    message.tool_calls = toolsArr.map((call) => {
+      const { id, ...functionCall } = call;
+      return {
+        id,
+        type: "function",
+        function: functionCall
+      };
+    });
+    delete message.function_call;
+  }
+  return message;
+}
+
+// src/llm/config/openai/promptSanitize.ts
+function openaiPromptSanitize(_messages, _inputBodyObj, _outputObj) {
+  if (typeof _messages === "string") {
+    return [{ role: "user", content: _messages }];
+  }
+  return _messages.map(openaiPromptMessageCallback);
+}
+
 // src/llm/config/openai/index.ts
 var openAiChatV1 = {
   key: "openai.chat.v1",
@@ -2003,12 +2108,7 @@ var openAiChatV1 = {
   mapBody: {
     prompt: {
       key: "messages",
-      sanitize: (v) => {
-        if (typeof v === "string") {
-          return [{ role: "user", content: v }];
-        }
-        return v;
-      }
+      sanitize: openaiPromptSanitize
     },
     model: {
       key: "model"
@@ -2059,14 +2159,54 @@ var openai = {
   "openai.gpt-4o-mini": withDefaultModel(openAiChatV1, "gpt-4o-mini")
 };
 
+// src/llm/config/anthropic/promptSanitizeMessageCallback.ts
+function anthropicPromptMessageCallback(_message) {
+  let message = { ..._message };
+  if (message.role === "function") {
+    message.role = "user";
+    message.content = [
+      {
+        type: "tool_result",
+        tool_use_id: message.id,
+        content: maybeStringifyJSON(message.content)
+      }
+    ];
+    delete message.name;
+    delete message.id;
+  }
+  if (message?.function_call) {
+    const { function_call } = message;
+    const toolsArr = Array.isArray(function_call) ? function_call : [function_call];
+    message.role = "assistant";
+    message.content = toolsArr.map((call) => {
+      const { id, name, arguments: input } = call;
+      return {
+        type: "tool_use",
+        id,
+        name,
+        input: maybeParseJSON(input)
+      };
+    });
+    delete message.function_call;
+  }
+  return message;
+}
+
 // src/llm/config/anthropic/promptSanitize.ts
 function anthropicPromptSanitize(_messages, _inputBodyObj, _outputObj) {
   if (typeof _messages === "string") {
-    return [{ role: "user", content: _messages }];
+    return [{ role: "user", content: _messages }].map(
+      anthropicPromptMessageCallback
+    );
   }
-  const [first, ...messages] = [..._messages.map((a) => ({ ...a }))];
+  const [first, ...messages] = [
+    ..._messages.map((a) => ({ ...a }))
+  ];
   if (first.role === "system" && messages.length === 0) {
-    return [{ role: "user", content: first.content }, ...messages];
+    return [
+      { role: "user", content: first.content },
+      ...messages
+    ].map(anthropicPromptMessageCallback);
   }
   if (first.role === "system" && messages.length > 0) {
     _outputObj.system = first.content;
@@ -2075,7 +2215,7 @@ function anthropicPromptSanitize(_messages, _inputBodyObj, _outputObj) {
         return { ...m, role: "user" };
       }
       return m;
-    });
+    }).map(anthropicPromptMessageCallback);
   }
   return [
     first,
@@ -2085,7 +2225,7 @@ function anthropicPromptSanitize(_messages, _inputBodyObj, _outputObj) {
       }
       return m;
     })
-  ];
+  ].map(anthropicPromptMessageCallback);
 }
 
 // src/llm/config/bedrock/index.ts
@@ -2304,30 +2444,49 @@ var ollama = {
   "ollama.qwq": withDefaultModel(ollamaChatV1, "qwq")
 };
 
-// src/utils/modules/modifyPromptRoleChange.ts
-function modifyPromptRoleChange(messages, roleChanges) {
-  const roleChangeMap = new Map(roleChanges.map(({ from, to }) => [from, to]));
-  if (Array.isArray(messages)) {
-    return messages.map((message) => {
-      const newRole2 = roleChangeMap.get(message.role);
-      return newRole2 ? { ...message, role: newRole2 } : message;
-    });
-  }
-  const newRole = roleChangeMap.get(messages.role);
-  return newRole ? { ...messages, role: newRole } : messages;
-}
-
 // src/llm/config/google/promptSanitizeMessageCallback.ts
 function googleGeminiPromptMessageCallback(_message) {
   let message = { ..._message };
-  message = modifyPromptRoleChange(_message, [
-    { from: "assistant", to: "model" }
-  ]);
-  const { role, ...payload } = message;
   const parts = [];
+  if (message.role === "assistant") {
+    message.role = "model";
+  }
+  if (message.role === "system") {
+    message.role = "model";
+  }
+  let { role, ...payload } = message;
   if (typeof payload.content === "string") {
     parts.push({ text: message.content });
   }
+  if (message.role === "function") {
+    role = "user";
+    parts.push({
+      functionResponse: {
+        name: message.name,
+        response: {
+          result: message.content
+        }
+      }
+    });
+    delete message.id;
+  }
+  if (message?.function_call) {
+    const { function_call } = message;
+    const toolsArr = Array.isArray(function_call) ? function_call : [function_call];
+    role = "model";
+    parts.push(
+      ...toolsArr.map((call) => {
+        const { name, arguments: input } = call;
+        return {
+          functionCall: {
+            name,
+            args: maybeParseJSON(input)
+          }
+        };
+      })
+    );
+    delete message.function_call;
+  }
   return {
     role,
     parts
@@ -2357,7 +2516,9 @@ function googleGeminiPromptSanitize(_messages, _inputBodyObj, _outputObj) {
         (message) => message.role !== "system"
       );
       _outputObj.system_instruction = {
-        parts: theSystemInstructions.map((message) => ({ text: message.content }))
+        parts: theSystemInstructions.map((message) => ({
+          text: message.content
+        }))
       };
       return withoutSystemInstructions.map(googleGeminiPromptMessageCallback);
     }
@@ -2478,7 +2639,7 @@ function getLlmConfig(provider) {
 
 // src/llm/output/_utils/getResultContent.ts
 function getResultContent(result, index) {
-  if (index && index > 0) {
+  if (typeof index === "number" && index > 0) {
     const arr = result?.options || [];
     const val = arr[index];
     return val ? val : [];
@@ -2486,6 +2647,16 @@ function getResultContent(result, index) {
   return [...result.content];
 }
 
+// src/llm/output/_utils/getResultText.ts
+function getResultText(result, index) {
+  if (typeof index === "number" && index > 0) {
+    const arr = result?.options || [];
+    const val = arr[index];
+    return isOutputResultContentText(val?.[0]) ? val[0]?.text : "";
+  }
+  return isOutputResultContentText(result?.content?.[0]) ? result.content[0]?.text : "";
+}
+
 // src/llm/output/base.ts
 function BaseLlmOutput2(result) {
   const __result = Object.freeze({
@@ -2510,7 +2681,7 @@ function BaseLlmOutput2(result) {
   }
   return {
     getResultContent: (index) => getResultContent(__result, index),
-    getResultText: () => getResultText(__result.content),
+    getResultText: (index) => getResultText(__result, index),
     getResult
   };
 }
@@ -2545,25 +2716,24 @@ function formatContent(response, handler) {
 
 // src/llm/output/openai.ts
 function formatResult(result) {
+  const out = [];
   if (typeof result?.message?.content === "string") {
-    return {
+    out.push({
       type: "text",
       text: result.message.content
-    };
-  } else if (result?.message && "tool_calls" in result.message) {
-    const tool_calls = result.message.tool_calls;
-    for (const call of tool_calls) {
-      return {
+    });
+  }
+  if (result?.message?.tool_calls) {
+    for (const call of result.message.tool_calls) {
+      out.push({
+        functionId: call.id,
         type: "function_use",
         name: call.function.name,
-        input: JSON.parse(call.function.arguments)
-      };
+        input: maybeParseJSON(call.function.arguments)
+      });
     }
   }
-  return {
-    type: "text",
-    text: ""
-  };
+  return out;
 }
 function OutputOpenAIChat(result, _config) {
   const id = result.id;
@@ -2571,7 +2741,7 @@ function OutputOpenAIChat(result, _config) {
   const created = result.created;
   const [_content, ..._options] = result?.choices || [];
   const stopReason = _content?.finish_reason;
-  const content = formatContent(_content, formatResult);
+  const content = formatResult(_content);
   const options = formatOptions(_options, formatResult);
   const usage = {
     output_tokens: result?.usage?.completion_tokens,
@@ -2602,6 +2772,7 @@ function formatResult2(response) {
       });
     } else if (result.type === "tool_use") {
       out.push({
+        functionId: result.id,
         type: "function_use",
         name: result.name,
         input: result.input
@@ -2679,12 +2850,15 @@ function formatResult3(result) {
     };
   } else if (result?.message && "tool_calls" in result.message) {
     const tool_calls = result.message.tool_calls;
-    for (const call of tool_calls) {
-      return {
-        type: "function_use",
-        name: call.function.name,
-        input: JSON.parse(call.function.arguments)
-      };
+    if (tool_calls) {
+      for (const call of tool_calls) {
+        return {
+          functionId: call.id,
+          type: "function_use",
+          name: call.function.name,
+          input: JSON.parse(call.function.arguments)
+        };
+      }
     }
   }
   return {
@@ -2789,37 +2963,36 @@ function OutputOllamaChat(result, _config) {
 }
 
 // src/llm/output/google.gemini/formatResult.ts
-function formatResult4(result) {
+function formatResult4(result, id) {
   const { parts = [] } = result?.content || {};
-  if (parts.length === 1) {
-    const answer = parts[0];
-    if (!!answer?.functionCall && typeof answer?.functionCall === "object") {
-      return {
-        type: "function_use",
-        name: answer.functionCall.name,
-        input: JSON.parse(answer.functionCall.args)
-      };
-    } else {
-      return {
+  const out = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (typeof part.text === "string") {
+      out.push({
         type: "text",
-        text: answer.text || ""
-      };
+        text: part.text
+      });
+    } else if (part?.functionCall) {
+      out.push({
+        functionId: `${id || uuidv4()}-${i}`,
+        type: "function_use",
+        name: part.functionCall.name,
+        input: maybeParseJSON(part.functionCall.args)
+      });
     }
   }
-  return {
-    type: "text",
-    text: ""
-  };
+  return out;
 }
 
 // src/llm/output/google.gemini/index.ts
 function OutputGoogleGeminiChat(result, _config) {
-  const id = "result.id";
-  const name = result.modelVersion;
+  const id = result.responseId;
+  const name = result.modelVersion || _config?.model || "gemini";
   const created = (/* @__PURE__ */ new Date()).getTime();
   const [_content, ..._options] = result?.candidates || [];
   const stopReason = _content?.finishReason?.toLowerCase();
-  const content = formatContent(_content, formatResult4);
+  const content = formatResult4(_content, id);
   const options = formatOptions(_options, formatResult4);
   const usage = {
     output_tokens: result?.usageMetadata?.candidatesTokenCount,
@@ -2838,7 +3011,7 @@ function OutputGoogleGeminiChat(result, _config) {
 }
 
 // src/llm/output/index.ts
-function getOutputParser(config, response) {
+function normalizeLlmOutputToInternalFormat(config, response) {
   switch (config?.key) {
     case "openai.chat.v1":
     case "openai.chat-mock.v1":
@@ -3154,6 +3327,12 @@ async function useLlm_call(state, messages, _options) {
         _options?.functionCall,
         "openai"
       );
+    } else if (state.provider.startsWith("google")) {
+      input["toolConfig"] = {
+        functionCallingConfig: {
+          mode: normalizeFunctionCall(_options?.functionCall, "google")
+        }
+      };
     }
   }
   if (_options && _options?.functions?.length) {
@@ -3181,6 +3360,16 @@ async function useLlm_call(state, messages, _options) {
           )
         };
       });
+    } else if (state.provider.startsWith("google")) {
+      input["tools"] = [
+        {
+          functionDeclarations: _options.functions.map((f) => ({
+            name: f.name,
+            description: f.description,
+            parameters: cleanJsonSchemaFor(f.parameters, "google.chat")
+          }))
+        }
+      ];
     }
   }
   const body = JSON.stringify(input);
@@ -3210,7 +3399,7 @@ async function useLlm_call(state, messages, _options) {
     body,
     headers
   });
-  return getOutputParser(state, response);
+  return normalizeLlmOutputToInternalFormat(state, response);
 }
 
 // src/llm/_utils.stateFromOptions.ts
@@ -3782,7 +3971,7 @@ var ChatPrompt = class extends BasePrompt {
       this.parseUserTemplates = options?.allowUnsafeUserTemplate;
     }
   }
-  addToPrompt(content, role, name) {
+  addToPrompt(content, role, name, id) {
     if (content) {
       switch (role) {
         case "system":
@@ -3796,11 +3985,11 @@ var ChatPrompt = class extends BasePrompt {
           break;
         case "function":
           assert(name, "Function message requires name");
-          this.addFunctionMessage(content, name);
+          this.addFunctionMessage(content, name, id);
           break;
         case "function_call":
           assert(name, "Function message requires name");
-          this.addFunctionCallMessage({ name, arguments: content });
+          this.addFunctionCallMessage({ name, arguments: content, id });
           break;
       }
     }
@@ -3840,11 +4029,12 @@ var ChatPrompt = class extends BasePrompt {
    * @param content The message content.
    * @return ChatPrompt so it can be chained.
    */
-  addFunctionMessage(content, name) {
+  addFunctionMessage(content, name, id) {
     this.messages.push({
       role: "function",
       name,
-      content
+      content,
+      id
     });
     return this;
   }
@@ -3856,8 +4046,9 @@ var ChatPrompt = class extends BasePrompt {
   addFunctionCallMessage(function_call) {
     if (function_call) {
       this.messages.push({
-        role: "assistant",
+        role: "function_call",
         function_call: {
+          id: function_call.id,
           name: function_call.name,
           arguments: maybeStringifyJSON(function_call.arguments)
         },
@@ -3879,17 +4070,16 @@ var ChatPrompt = class extends BasePrompt {
             this.addUserMessage(message.content, message?.name);
             break;
           case "assistant":
-            if (message.function_call) {
-              this.addFunctionCallMessage(message.function_call);
-            } else if (message?.content) {
-              this.addAssistantMessage(message?.content);
-            }
+            this.addAssistantMessage(message?.content);
             break;
           case "system":
             this.addSystemMessage(message.content);
             break;
+          case "function_call":
+            this.addFunctionCallMessage(message.function_call);
+            break;
           case "function":
-            this.addFunctionMessage(message.content, message.name);
+            this.addFunctionMessage(message.content, message.name, message.id);
             break;
         }
       }
@@ -3953,20 +4143,19 @@ var ChatPrompt = class extends BasePrompt {
             break;
           }
           case "assistant": {
-            if (message.function_call) {
-              messagesOut.push({
-                role: "assistant",
-                content: null,
-                function_call: message.function_call
-              });
-            } else if (message?.content) {
-              messagesOut.push({
-                role: "assistant",
-                content: message.content
-              });
-            }
+            messagesOut.push({
+              role: "assistant",
+              content: message.content
+            });
             break;
           }
+          case "function_call":
+            messagesOut.push({
+              role: "function_call",
+              content: null,
+              function_call: message.function_call
+            });
+            break;
           case "function":
             messagesOut.push({
               role: "function",
@@ -4145,20 +4334,19 @@ var ChatPrompt = class extends BasePrompt {
                     break;
                   }
                   case "assistant": {
-                    if (message2.function_call) {
-                      messagesOut.push({
-                        role: "assistant",
-                        content: null,
-                        function_call: message2.function_call
-                      });
-                    } else if (message2?.content) {
-                      messagesOut.push({
-                        role: "assistant",
-                        content: message2.content
-                      });
-                    }
+                    messagesOut.push({
+                      role: "assistant",
+                      content: message2.content
+                    });
                     break;
                   }
+                  case "function_call":
+                    messagesOut.push({
+                      role: "function_call",
+                      content: null,
+                      function_call: message2.function_call
+                    });
+                    break;
                   case "function":
                     messagesOut.push({
                       role: "function",
@@ -4382,10 +4570,17 @@ var Dialogue = class extends BaseStateItem {
   }
   setAssistantMessage(content) {
     if (content) {
-      this.value.push({
-        role: "assistant",
-        content
-      });
+      if (isOutputResultContentText(content)) {
+        this.value.push({
+          role: "assistant",
+          content: content.text
+        });
+      } else {
+        this.value.push({
+          role: "assistant",
+          content
+        });
+      }
     }
     return this;
   }
@@ -4398,28 +4593,57 @@ var Dialogue = class extends BaseStateItem {
     }
     return this;
   }
-  setFunctionMessage(content, name) {
+  setToolMessage(content, name, id) {
+    this.setFunctionMessage(content, name, id);
+  }
+  setFunctionMessage(content, name, id) {
     if (content) {
       this.value.push({
         role: "function",
+        id,
         name,
         content
       });
     }
     return this;
   }
+  /**
+   * Set
+   */
+  setToolCallMessage(input) {
+    this.setFunctionCallMessage(input);
+  }
   setFunctionCallMessage(input) {
-    if (!input?.function_call) {
+    if (!input || typeof input !== "object") {
       throw new LlmExeError(`Invalid arguments`, "state", {
-        error: `Invalid arguments: missing required function_call`,
+        error: `Invalid arguments: input must be an object`,
         module: "dialogue"
       });
     }
+    if ("function_call" in input) {
+      if (!input.function_call || typeof input.function_call !== "object") {
+        throw new LlmExeError(`Invalid arguments`, "state", {
+          error: `Invalid arguments: input must be an object`,
+          module: "dialogue"
+        });
+      }
+      this.value.push({
+        role: "function_call",
+        function_call: {
+          id: input?.function_call.id,
+          name: input?.function_call.name,
+          arguments: maybeStringifyJSON(input?.function_call.arguments)
+        },
+        content: null
+      });
+      return this;
+    }
     this.value.push({
-      role: "assistant",
+      role: "function_call",
       function_call: {
-        name: input?.function_call.name,
-        arguments: maybeStringifyJSON(input?.function_call.arguments)
+        id: input?.id,
+        name: input?.name,
+        arguments: maybeStringifyJSON(input?.arguments)
       },
       content: null
     });
@@ -4437,21 +4661,26 @@ var Dialogue = class extends BaseStateItem {
         case "user":
           this.setUserMessage(message?.content, message?.name);
           break;
+        case "model":
         case "assistant":
-          if (message.function_call) {
-            this.setFunctionCallMessage({
-              function_call: message.function_call
-            });
-          } else if (message?.content) {
-            this.setAssistantMessage(message?.content);
-          }
+          this.setAssistantMessage(message?.content);
           break;
         case "system":
           this.setSystemMessage(message?.content);
           break;
+        case "function_call":
+          this.setFunctionCallMessage({
+            function_call: message.function_call
+          });
+          break;
         case "function":
           this.setFunctionMessage(message?.content, message.name);
           break;
+        default:
+          this.value.push({
+            role: message.role,
+            content: message.content || ""
+          });
       }
     }
     return this;
@@ -4467,6 +4696,30 @@ var Dialogue = class extends BaseStateItem {
     };
   }
   // deserialize() {}
+  /**
+   * Add LLM output to dialogue history in the order it was returned
+   *
+   * @param output - The LLM output result from llm.call()
+   * @returns this for chaining
+   */
+  addFromOutput(output) {
+    const result = "getResult" in output ? output.getResult() : output;
+    if (!result || typeof result !== "object") {
+      return this;
+    }
+    for (const item of result.content) {
+      if (item.type === "text") {
+        this.setAssistantMessage(item.text);
+      } else if (item.type === "function_use") {
+        this.setToolCallMessage({
+          name: item.name,
+          arguments: maybeStringifyJSON(item.input),
+          id: item.functionId
+        });
+      }
+    }
+    return this;
+  }
 };
 
 // src/state/_base.ts
@@ -4590,6 +4843,7 @@ export {
   createState,
   createStateItem,
   defineSchema,
+  guards_exports as guards,
   registerHelpers,
   registerPartials,
   useExecutors,