llm-exe 2.2.0 → 2.3.0

package/dist/index.js

@@ -47,6 +47,8 @@ __export(index_exports, {
   DefaultState: () => DefaultState,
   DefaultStateItem: () => DefaultStateItem,
   LlmExecutorOpenAiFunctions: () => LlmExecutorOpenAiFunctions,
+  LlmExecutorWithFunctions: () => LlmExecutorWithFunctions,
+  LlmNativeFunctionParser: () => LlmNativeFunctionParser,
   OpenAiFunctionParser: () => OpenAiFunctionParser,
   TextPrompt: () => TextPrompt,
   createCallableExecutor: () => createCallableExecutor,
@@ -56,11 +58,13 @@ __export(index_exports, {
   createDialogue: () => createDialogue,
   createEmbedding: () => createEmbedding,
   createLlmExecutor: () => createLlmExecutor,
+  createLlmFunctionExecutor: () => createLlmFunctionExecutor,
   createParser: () => createParser,
   createPrompt: () => createPrompt,
   createState: () => createState,
   createStateItem: () => createStateItem,
   defineSchema: () => defineSchema,
+  guards: () => guards_exports,
   registerHelpers: () => registerHelpers,
   registerPartials: () => registerPartials,
   useExecutors: () => useExecutors,
@@ -390,6 +394,123 @@ var BaseParserWithJson = class extends BaseParser {
   }
 };
 
+// src/utils/modules/assert.ts
+function assert(condition, message) {
+  if (condition === void 0 || condition === null || condition === false) {
+    if (typeof message === "string") {
+      throw new Error(message);
+    } else if (message instanceof Error) {
+      throw message;
+    } else {
+      throw new Error(`Assertion error`);
+    }
+  }
+}
+
+// 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}.`
+    );
+    const parsed = text.toString();
+    return parsed;
+  }
+};
+
+// src/parser/parsers/BooleanParser.ts
+var BooleanParser = class extends BaseParser {
+  constructor(options) {
+    super("boolean", options);
+  }
+  parse(text) {
+    assert(
+      typeof text === "string",
+      `Invalid input. Expected string. Received ${typeof text}.`
+    );
+    const clean = text.toLowerCase().trim();
+    if (clean === "true") {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/utils/modules/isFinite.ts
+function isFinite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/utils/modules/toNumber.ts
+function toNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    return Number(value);
+  }
+  return NaN;
+}
+
+// src/parser/parsers/NumberParser.ts
+var NumberParser = class extends BaseParser {
+  constructor(options) {
+    super("number", options);
+  }
+  parse(text) {
+    const match = text.match(/\d/g);
+    return match && isFinite(toNumber(match[0])) ? toNumber(match[0]) : -1;
+  }
+};
+
 // src/utils/index.ts
 var utils_exports = {};
 __export(utils_exports, {
@@ -409,19 +530,6 @@ __export(utils_exports, {
   replaceTemplateStringAsync: () => replaceTemplateStringAsync
 });
 
-// src/utils/modules/assert.ts
-function assert(condition, message) {
-  if (condition === void 0 || condition === null || condition === false) {
-    if (typeof message === "string") {
-      throw new Error(message);
-    } else if (message instanceof Error) {
-      throw message;
-    } else {
-      throw new Error(`Assertion error`);
-    }
-  }
-}
-
 // src/utils/modules/defineSchema.ts
 var import_json_schema_to_ts = require("json-schema-to-ts");
 function defineSchema(obj) {
@@ -467,17 +575,6 @@ function importHelpers(_helpers) {
   return helpers;
 }
 
-// src/utils/modules/toNumber.ts
-function toNumber(value) {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    return Number(value);
-  }
-  return NaN;
-}
-
 // src/utils/modules/get.ts
 function get(obj, path, defaultValue) {
   if (obj == null || path === "" || Array.isArray(path) && path.length === 0) {
@@ -1377,82 +1474,6 @@ function registerPartials(partials2) {
   hbsAsync.registerPartials(partials2);
 }
 
-// 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/OpenAiFunctionParser.ts
-var OpenAiFunctionParser = class extends BaseParser {
-  constructor(options) {
-    super("openAiFunction", options, "function_call");
-    __publicField(this, "parser");
-    this.parser = options.parser;
-  }
-  parse(text, _options) {
-    const functionUse = text?.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));
-  }
-};
-
-// src/parser/parsers/StringParser.ts
-var StringParser = class extends BaseParser {
-  constructor(options) {
-    super("string", options);
-  }
-  parse(text, _options) {
-    assert(
-      typeof text === "string",
-      `Invalid input. Expected string. Received ${typeof text}.`
-    );
-    const parsed = text.toString();
-    return parsed;
-  }
-};
-
-// src/parser/parsers/BooleanParser.ts
-var BooleanParser = class extends BaseParser {
-  constructor(options) {
-    super("boolean", options);
-  }
-  parse(text) {
-    assert(
-      typeof text === "string",
-      `Invalid input. Expected string. Received ${typeof text}.`
-    );
-    const clean = text.toLowerCase().trim();
-    if (clean === "true") {
-      return true;
-    }
-    return false;
-  }
-};
-
-// src/utils/modules/isFinite.ts
-function isFinite(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-
-// src/parser/parsers/NumberParser.ts
-var NumberParser = class extends BaseParser {
-  constructor(options) {
-    super("number", options);
-  }
-  parse(text) {
-    const match = text.match(/\d/g);
-    return match && isFinite(toNumber(match[0])) ? toNumber(match[0]) : -1;
-  }
-};
-
 // src/parser/_utils.ts
 var import_jsonschema = require("jsonschema");
 function enforceParserSchema(schema, parsed) {
@@ -1745,6 +1766,46 @@ function createCustomParser(name, parserFn) {
   return new CustomParser(name, parserFn);
 }
 
+// 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");
+    __publicField(this, "parser");
+    this.parser = options.parser;
+  }
+  parse(text, _options) {
+    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(text?.text ?? text);
+  }
+};
+var OpenAiFunctionParser = LlmNativeFunctionParser;
+
 // src/executor/llm.ts
 var LlmExecutor = class extends BaseExecutor {
   constructor(llmConfiguration, options) {
@@ -1800,7 +1861,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();
@@ -1820,31 +1881,55 @@ var LlmExecutor = class extends BaseExecutor {
   }
 };
 
-// src/executor/_functions.ts
-function createCoreExecutor(handler, options) {
-  return new CoreExecutor({ handler }, options);
-}
-function createLlmExecutor(llmConfiguration, options) {
-  return new LlmExecutor(llmConfiguration, options);
-}
-
 // src/executor/llm-openai-function.ts
+var LlmExecutorWithFunctions = class extends LlmExecutor {
+  constructor(llmConfiguration, options) {
+    super(
+      Object.assign({}, llmConfiguration, {
+        parser: new LlmFunctionParser({
+          parser: llmConfiguration.parser || new StringParser()
+        })
+      }),
+      options
+    );
+  }
+  async execute(_input, _options) {
+    return super.execute(_input, _options);
+  }
+};
 var LlmExecutorOpenAiFunctions = class extends LlmExecutor {
   constructor(llmConfiguration, options) {
     super(
       Object.assign({}, llmConfiguration, {
-        parser: new OpenAiFunctionParser({
+        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
+function createCoreExecutor(handler, options) {
+  return new CoreExecutor({ handler }, options);
+}
+function createLlmExecutor(llmConfiguration, options) {
+  return new LlmExecutor(llmConfiguration, options);
+}
+function createLlmFunctionExecutor(llmConfiguration, options) {
+  return new LlmExecutorWithFunctions(
+    llmConfiguration,
+    options
+  );
+}
+
 // src/utils/modules/enforceResultAttributes.ts
 function enforceResultAttributes(input) {
   if (!input) {
@@ -2033,6 +2118,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",
@@ -2051,12 +2169,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"
@@ -2107,14 +2220,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;
@@ -2123,7 +2276,7 @@ function anthropicPromptSanitize(_messages, _inputBodyObj, _outputObj) {
         return { ...m, role: "user" };
       }
       return m;
-    });
+    }).map(anthropicPromptMessageCallback);
   }
   return [
     first,
@@ -2133,7 +2286,7 @@ function anthropicPromptSanitize(_messages, _inputBodyObj, _outputObj) {
       }
       return m;
     })
-  ];
+  ].map(anthropicPromptMessageCallback);
 }
 
 // src/llm/config/bedrock/index.ts
@@ -2352,30 +2505,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
@@ -2405,7 +2577,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);
     }
@@ -2526,7 +2700,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 : [];
@@ -2534,6 +2708,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({
@@ -2558,7 +2742,7 @@ function BaseLlmOutput2(result) {
   }
   return {
     getResultContent: (index) => getResultContent(__result, index),
-    getResultText: () => getResultText(__result.content),
+    getResultText: (index) => getResultText(__result, index),
     getResult
   };
 }
@@ -2593,25 +2777,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;
@@ -2619,7 +2802,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,
@@ -2650,6 +2833,7 @@ function formatResult2(response) {
       });
     } else if (result.type === "tool_use") {
       out.push({
+        functionId: result.id,
         type: "function_use",
         name: result.name,
         input: result.input
@@ -2727,12 +2911,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 {
@@ -2837,37 +3024,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 || (0, import_uuid.v4)()}-${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,
@@ -2886,7 +3072,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":
@@ -3134,11 +3320,20 @@ async function parseHeaders(config, replacements, payload) {
 
 // src/llm/output/_utils/cleanJsonSchemaFor.ts
 var providerFieldExclusions = {
-  "openai.chat": ["default"]
+  "openai.chat": ["default"],
+  // fields to exclude for openai.chat
+  "anthropic.chat": []
   // fields to exclude for openai.chat
 };
 function cleanJsonSchemaFor(schema = {}, provider) {
   const clone = deepClone(schema);
+  if (Object.keys(clone).length === 0) {
+    return {
+      type: "object",
+      properties: {},
+      required: []
+    };
+  }
   const exclusions = providerFieldExclusions[provider] || [];
   function removeDisallowedFields(obj) {
     if (Array.isArray(obj)) {
@@ -3167,7 +3362,7 @@ async function useLlm_call(state, messages, _options) {
     })
   );
   if (_options && _options?.jsonSchema) {
-    if (state.provider === "openai.chat") {
+    if (state.provider.startsWith("openai")) {
       const curr = input["response_format"] || {};
       input["response_format"] = Object.assign(curr, {
         type: "json_schema",
@@ -3180,7 +3375,7 @@ async function useLlm_call(state, messages, _options) {
     }
   }
   if (_options && _options?.functionCall) {
-    if (state.provider === "anthropic.chat") {
+    if (state.provider.startsWith("anthropic")) {
       if (_options?.functionCall === "none") {
         _options.functions = [];
       } else if (_options?.functionCall === "auto" || _options?.functionCall === "any") {
@@ -3188,21 +3383,27 @@ async function useLlm_call(state, messages, _options) {
       } else {
         input["tool_choice"] = _options?.functionCall;
       }
-    } else if (state.provider === "openai.chat") {
+    } else if (state.provider.startsWith("openai")) {
       input["tool_choice"] = normalizeFunctionCall(
         _options?.functionCall,
         "openai"
       );
+    } else if (state.provider.startsWith("google")) {
+      input["toolConfig"] = {
+        functionCallingConfig: {
+          mode: normalizeFunctionCall(_options?.functionCall, "google")
+        }
+      };
     }
   }
   if (_options && _options?.functions?.length) {
-    if (state.provider === "anthropic.chat") {
+    if (state.provider.startsWith("anthropic")) {
       input["tools"] = _options.functions.map((f) => ({
         name: f.name,
         description: f.description,
-        input_schema: f.parameters
+        input_schema: cleanJsonSchemaFor(f.parameters, "anthropic.chat")
       }));
-    } else if (state.provider === "openai.chat") {
+    } else if (state.provider.startsWith("openai")) {
       input["tools"] = _options.functions.map((f) => {
         const props = {
           name: f?.name,
@@ -3220,6 +3421,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);
@@ -3249,7 +3460,7 @@ async function useLlm_call(state, messages, _options) {
     body,
     headers
   });
-  return getOutputParser(state, response);
+  return normalizeLlmOutputToInternalFormat(state, response);
 }
 
 // src/llm/_utils.stateFromOptions.ts
@@ -3821,7 +4032,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":
@@ -3835,11 +4046,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;
       }
     }
@@ -3879,11 +4090,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;
   }
@@ -3895,8 +4107,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)
         },
@@ -3918,17 +4131,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;
         }
       }
@@ -3992,20 +4204,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",
@@ -4184,20 +4395,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",
@@ -4421,10 +4631,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;
   }
@@ -4437,22 +4654,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 || typeof input !== "object") {
+      throw new LlmExeError(`Invalid arguments`, "state", {
+        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
     });
@@ -4470,21 +4722,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;
@@ -4500,6 +4757,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
@@ -4607,6 +4888,8 @@ function createStateItem(name, defaultValue) {
   DefaultState,
   DefaultStateItem,
   LlmExecutorOpenAiFunctions,
+  LlmExecutorWithFunctions,
+  LlmNativeFunctionParser,
   OpenAiFunctionParser,
   TextPrompt,
   createCallableExecutor,
@@ -4616,11 +4899,13 @@ function createStateItem(name, defaultValue) {
   createDialogue,
   createEmbedding,
   createLlmExecutor,
+  createLlmFunctionExecutor,
   createParser,
   createPrompt,
   createState,
   createStateItem,
   defineSchema,
+  guards,
   registerHelpers,
   registerPartials,
   useExecutors,