@workglow/ai-provider 0.1.1 → 0.2.0

package/dist/provider-llamacpp/runtime.js

@@ -644,6 +644,1391 @@ var LlamaCpp_TextSummary_Stream = async function* (input, model, signal) {
   }
 };
 
+// src/provider-llamacpp/common/LlamaCpp_ToolCalling.ts
+import { filterValidToolCalls } from "@workglow/ai/worker";
+
+// src/common/ToolCallParsers.ts
+function stripModelArtifacts(text) {
+  return text.replace(/<think>(?:[^<]|<(?!\/think>))*<\/think>/g, "").replace(/<\|[a-z_]+\|>/g, "").trim();
+}
+function makeToolCall(name, args, id = null) {
+  return { name, arguments: args, id };
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+function findBalancedBlocks(source, openChar, closeChar, startFrom = 0) {
+  const results = [];
+  const length = source.length;
+  let i = startFrom;
+  while (i < length) {
+    if (source[i] !== openChar) {
+      i++;
+      continue;
+    }
+    let depth = 1;
+    let j = i + 1;
+    let inString = false;
+    let escape = false;
+    while (j < length && depth > 0) {
+      const ch = source[j];
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === '"') {
+          inString = false;
+        }
+      } else {
+        if (ch === '"') {
+          inString = true;
+        } else if (ch === openChar) {
+          depth++;
+        } else if (ch === closeChar) {
+          depth--;
+        }
+      }
+      j++;
+    }
+    if (depth === 0) {
+      results.push({ text: source.slice(i, j), start: i, end: j });
+      i = j;
+    } else {
+      break;
+    }
+  }
+  return results;
+}
+function parseJsonToolCallArray(jsonStr, nameKey = "name", argsKeys = ["arguments", "parameters"]) {
+  const parsed = tryParseJson(jsonStr.trim());
+  if (!parsed)
+    return;
+  const arr = Array.isArray(parsed) ? parsed : [parsed];
+  const calls = arr.filter((c) => !!c && typeof c === "object" && !!c[nameKey]).map((c) => {
+    const args = argsKeys.reduce((found, key) => found ?? c[key], undefined);
+    return makeToolCall(c[nameKey], args ?? {}, c.id ?? null);
+  });
+  return calls.length > 0 ? calls : undefined;
+}
+function parseKeyValueArgs(argsStr) {
+  const args = {};
+  if (!argsStr)
+    return args;
+  const argRegex = /(?<!\w)(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s,]+))/g;
+  let match;
+  while ((match = argRegex.exec(argsStr)) !== null) {
+    const key = match[1];
+    const value = match[2] ?? match[3] ?? match[4];
+    args[key] = coerceArgValue(value);
+  }
+  return args;
+}
+function coerceArgValue(value) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value !== "" && !isNaN(Number(value)))
+    return Number(value);
+  return value;
+}
+function parseFunctionGemmaArgumentValue(rawValue) {
+  const trimmed = rawValue.trim();
+  if (trimmed.length === 0)
+    return "";
+  if (trimmed === "true")
+    return true;
+  if (trimmed === "false")
+    return false;
+  if (trimmed === "null")
+    return null;
+  const numeric = Number(trimmed);
+  if (!Number.isNaN(numeric) && /^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+    return numeric;
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {}
+  }
+  return trimmed;
+}
+function parseFunctionGemmaLooseObject(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return;
+  }
+  const inner = trimmed.slice(1, -1).trim();
+  if (inner.length === 0) {
+    return {};
+  }
+  const result = {};
+  const pairs = inner.matchAll(/([A-Za-z0-9_]+)\s*:\s*('[^']*'|"[^"]*"|[^,}]+)/g);
+  for (const [_, rawKey, rawValue] of pairs) {
+    const key = rawKey.trim();
+    const valueText = rawValue.trim().replace(/^'([^']*)'$/, '"$1"');
+    result[key] = parseFunctionGemmaArgumentValue(valueText);
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+var parseLlama = (text) => {
+  const calls = [];
+  let content = text;
+  const pythonTagMatch = text.match(/<\|python_tag\|>((?:[^<]|<(?!\|eot_id\|>|\|eom_id\|>))*)(?:<\|eot_id\|>|<\|eom_id\|>|$)/);
+  if (pythonTagMatch) {
+    content = text.slice(0, text.indexOf("<|python_tag|>")).trim();
+    const jsonSection = pythonTagMatch[1].trim();
+    for (const line of jsonSection.split(`
+`)) {
+      const trimmed = line.trim();
+      if (!trimmed)
+        continue;
+      const parsed = tryParseJson(trimmed);
+      if (parsed?.name) {
+        calls.push(makeToolCall(parsed.name, parsed.parameters ?? parsed.arguments ?? {}, parsed.id ?? null));
+      }
+    }
+  }
+  if (calls.length === 0) {
+    const funcTagRegex = /<function=(\w+)>((?:[^<]|<(?!\/function>))*)<\/function>/g;
+    let funcMatch;
+    while ((funcMatch = funcTagRegex.exec(text)) !== null) {
+      const args = tryParseJson(funcMatch[2].trim());
+      if (args) {
+        calls.push(makeToolCall(funcMatch[1], args));
+      }
+    }
+    if (calls.length > 0) {
+      content = text.replace(/<function=\w+>(?:[^<]|<(?!\/function>))*<\/function>/g, "").trim();
+    }
+  }
+  if (calls.length === 0) {
+    const blocks = findBalancedBlocks(text, "{", "}");
+    for (const block of blocks) {
+      const parsed = tryParseJson(block.text);
+      if (parsed?.name && (parsed.parameters !== undefined || parsed.arguments !== undefined)) {
+        calls.push(makeToolCall(parsed.name, parsed.parameters ?? parsed.arguments ?? {}, parsed.id ?? null));
+      }
+    }
+    if (calls.length > 0) {
+      content = text.slice(0, text.indexOf(calls[0].name) - '{"name": "'.length).trim();
+    }
+  }
+  return calls.length > 0 ? { tool_calls: calls, content, parser: "llama" } : null;
+};
+var parseMistral = (text) => {
+  const marker = "[TOOL_CALLS]";
+  const idx = text.indexOf(marker);
+  if (idx === -1)
+    return null;
+  const content = text.slice(0, idx).trim();
+  const jsonStr = text.slice(idx + marker.length).trim();
+  const calls = parseJsonToolCallArray(jsonStr);
+  return calls ? { tool_calls: calls, content, parser: "mistral" } : null;
+};
+var parseHermes = (text) => {
+  const regex = /<tool_call>((?:[^<]|<(?!\/tool_call>))*)<\/tool_call>/g;
+  const calls = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const parsed = tryParseJson(match[1].trim());
+    if (parsed) {
+      calls.push(makeToolCall(parsed.name ?? "", parsed.arguments ?? parsed.parameters ?? {}, parsed.id ?? null));
+    }
+  }
+  if (calls.length === 0)
+    return null;
+  const content = text.replace(/<tool_call>(?:[^<]|<(?!\/tool_call>))*<\/tool_call>/g, "").trim();
+  return { tool_calls: calls, content, parser: "hermes" };
+};
+var parseCohere = (text) => {
+  const blockMatch = text.match(/Action:\s*```(?:json)?\n?((?:[^`]|`(?!``))*)\n?```/);
+  let inlineJsonStr;
+  if (!blockMatch) {
+    const actionIdx2 = text.indexOf("Action:");
+    if (actionIdx2 !== -1) {
+      const afterAction = text.slice(actionIdx2 + "Action:".length).trimStart();
+      if (afterAction.startsWith("[")) {
+        const blocks = findBalancedBlocks(afterAction, "[", "]");
+        if (blocks.length > 0) {
+          inlineJsonStr = blocks[0].text;
+        }
+      }
+    }
+  }
+  const jsonStr = blockMatch?.[1] ?? inlineJsonStr;
+  if (!jsonStr)
+    return null;
+  const calls = parseJsonToolCallArray(jsonStr, "tool_name", ["parameters", "arguments"]);
+  if (!calls) {
+    const fallbackCalls = parseJsonToolCallArray(jsonStr);
+    if (!fallbackCalls)
+      return null;
+    const actionIdx2 = text.indexOf("Action:");
+    const content2 = text.slice(0, actionIdx2).trim();
+    return { tool_calls: fallbackCalls, content: content2, parser: "cohere" };
+  }
+  const actionIdx = text.indexOf("Action:");
+  const content = text.slice(0, actionIdx).trim();
+  return { tool_calls: calls, content, parser: "cohere" };
+};
+var parseDeepSeek = (text) => {
+  const calls = [];
+  const bar = "(?:｜|\\|)";
+  const sep = "[\\s▁]";
+  const v31Regex = new RegExp(`<${bar}tool${sep}call${sep}begin${bar}>\\s*(\\w+)\\s*<${bar}tool${sep}sep${bar}>\\s*([^<]*(?:<(?!${bar}tool${sep}call${sep}end${bar}>)[^<]*)*)\\s*<${bar}tool${sep}call${sep}end${bar}>`, "g");
+  let match;
+  while ((match = v31Regex.exec(text)) !== null) {
+    const args = tryParseJson(match[2].trim());
+    if (args) {
+      calls.push(makeToolCall(match[1], args));
+    }
+  }
+  if (calls.length === 0) {
+    const v2Regex = new RegExp(`<${bar}tool${sep}call${sep}begin${bar}>\\s*(\\w+)\\s*\\n\`\`\`(?:json)?\\n([^\`]*(?:\`(?!\`\`)[^\`]*)*)\\n\`\`\`\\s*<${bar}tool${sep}call${sep}end${bar}>`, "g");
+    while ((match = v2Regex.exec(text)) !== null) {
+      const args = tryParseJson(match[2].trim());
+      if (args) {
+        calls.push(makeToolCall(match[1], args));
+      }
+    }
+  }
+  if (calls.length === 0)
+    return null;
+  const content = text.replace(new RegExp(`<${bar}tool${sep}calls?${sep}(?:begin|end)${bar}>`, "g"), "").replace(new RegExp(`<${bar}tool${sep}call${sep}(?:begin|end)${bar}>[^<]*(?:<(?!${bar}tool${sep}call${sep}end${bar}>)[^<]*)*<${bar}tool${sep}call${sep}end${bar}>`, "g"), "").replace(new RegExp(`<${bar}tool${sep}sep${bar}>`, "g"), "").trim();
+  return { tool_calls: calls, content, parser: "deepseek" };
+};
+var parsePhi = (text) => {
+  const match = text.match(/<\|tool_calls\|>((?:[^<]|<(?!\|\/tool_calls\|>))*)<\|\/tool_calls\|>/);
+  if (!match)
+    return null;
+  const calls = parseJsonToolCallArray(match[1]);
+  if (!calls)
+    return null;
+  const content = text.slice(0, text.indexOf("<|tool_calls|>")).trim();
+  return { tool_calls: calls, content, parser: "phi" };
+};
+var parsePhiFunctools = (text) => {
+  const idx = text.indexOf("functools");
+  if (idx === -1)
+    return null;
+  let start = idx + "functools".length;
+  while (start < text.length && /\s/.test(text[start]))
+    start++;
+  if (start >= text.length || text[start] !== "[")
+    return null;
+  const blocks = findBalancedBlocks(text, "[", "]", start);
+  if (blocks.length === 0)
+    return null;
+  const calls = parseJsonToolCallArray(blocks[0].text);
+  if (!calls)
+    return null;
+  const content = text.slice(0, idx).trim();
+  return { tool_calls: calls, content, parser: "phi_functools" };
+};
+var parseInternLM = (text) => {
+  const regex = /<\|action_start\|>\s*<\|plugin\|>((?:[^<]|<(?!\|action_end\|>))*)<\|action_end\|>/g;
+  const calls = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const parsed = tryParseJson(match[1].trim());
+    if (parsed) {
+      calls.push(makeToolCall(parsed.name ?? "", parsed.parameters ?? parsed.arguments ?? {}, parsed.id ?? null));
+    }
+  }
+  if (calls.length === 0)
+    return null;
+  const content = text.replace(/<\|action_start\|>\s*<\|plugin\|>(?:[^<]|<(?!\|action_end\|>))*<\|action_end\|>/g, "").trim();
+  return { tool_calls: calls, content, parser: "internlm" };
+};
+var parseChatGLM = (text) => {
+  const match = text.match(/^(\w+)\n(\{[\s\S]*\})\s*$/m);
+  if (!match)
+    return null;
+  const args = tryParseJson(match[2].trim());
+  if (!args)
+    return null;
+  return {
+    tool_calls: [makeToolCall(match[1], args)],
+    content: "",
+    parser: "chatglm"
+  };
+};
+var parseFunctionary = (text) => {
+  const regex = />>>\s*(\w+)\s*\n((?:(?!>>>)[\s\S])*)/g;
+  const calls = [];
+  let content = "";
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const funcName = match[1].trim();
+    const body = match[2].trim();
+    if (funcName === "all") {
+      content += body;
+      continue;
+    }
+    const args = tryParseJson(body);
+    calls.push(makeToolCall(funcName, args ?? { content: body }));
+  }
+  if (calls.length === 0)
+    return null;
+  return { tool_calls: calls, content: content.trim(), parser: "functionary" };
+};
+var parseGorilla = (text) => {
+  const regex = /<<function>>\s{0,20}(\w+)\(([^)]*)\)/g;
+  const calls = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    calls.push(makeToolCall(match[1], parseKeyValueArgs(match[2].trim())));
+  }
+  if (calls.length === 0)
+    return null;
+  const content = text.replace(/<<function>>\s{0,20}\w+\([^)]*\)/g, "").trim();
+  return { tool_calls: calls, content, parser: "gorilla" };
+};
+var parseNexusRaven = (text) => {
+  const regex = /Call:\s{0,20}(\w+)\(([^)]*)\)/g;
+  const calls = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    calls.push(makeToolCall(match[1], parseKeyValueArgs(match[2].trim())));
+  }
+  if (calls.length === 0)
+    return null;
+  const thoughtMatch = text.match(/Thought:\s*((?:(?!Call:)[\s\S])*)/);
+  const content = thoughtMatch?.[1]?.trim() ?? text.replace(/Call:\s{0,20}\w+\([^)]*\)/g, "").trim();
+  return { tool_calls: calls, content, parser: "nexusraven" };
+};
+var parseXLAM = (text) => {
+  const codeBlockMatch = text.match(/```(?:json)?\n?((?:[^`]|`(?!``))*)\n?```/);
+  let jsonStr;
+  let isCodeBlock = false;
+  if (codeBlockMatch) {
+    const inner = codeBlockMatch[1].trim();
+    if (inner.startsWith("[")) {
+      jsonStr = inner;
+      isCodeBlock = true;
+    }
+  }
+  if (!jsonStr) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("["))
+      return null;
+    jsonStr = trimmed;
+  }
+  const calls = parseJsonToolCallArray(jsonStr);
+  if (!calls)
+    return null;
+  const content = isCodeBlock ? text.slice(0, text.indexOf("```")).trim() : "";
+  return { tool_calls: calls, content, parser: "xlam" };
+};
+var parseFireFunction = (text) => {
+  const toolCallsIdx = text.indexOf('"tool_calls"');
+  if (toolCallsIdx === -1)
+    return null;
+  let bracketStart = text.indexOf("[", toolCallsIdx);
+  if (bracketStart === -1)
+    return null;
+  const blocks = findBalancedBlocks(text, "[", "]", bracketStart);
+  if (blocks.length === 0)
+    return null;
+  const parsed = tryParseJson(blocks[0].text);
+  if (!parsed || !Array.isArray(parsed))
+    return null;
+  const calls = [];
+  for (const c of parsed) {
+    const fn = c.function;
+    if (!fn?.name)
+      continue;
+    let args = fn.arguments ?? {};
+    if (typeof args === "string") {
+      args = tryParseJson(args) ?? {};
+    }
+    calls.push(makeToolCall(fn.name, args, c.id ?? null));
+  }
+  return calls.length > 0 ? { tool_calls: calls, content: "", parser: "firefunction" } : null;
+};
+var parseGranite = (text) => {
+  const regex = /<\|tool_call\|>((?:[^<]|<(?!\|\/tool_call\|>|\|end_of_text\|>))*?)(?:<\|\/tool_call\|>|<\|end_of_text\|>|$)/g;
+  const calls = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const parsed = tryParseJson(match[1].trim());
+    if (parsed) {
+      calls.push(makeToolCall(parsed.name ?? "", parsed.arguments ?? parsed.parameters ?? {}, parsed.id ?? null));
+    }
+  }
+  if (calls.length === 0)
+    return null;
+  const content = text.replace(/<\|tool_call\|>(?:[^<]|<(?!\|\/tool_call\|>|\|end_of_text\|>))*(?:<\|\/tool_call\|>|$)/g, "").trim();
+  return { tool_calls: calls, content, parser: "granite" };
+};
+var parseGemma = (text) => {
+  const openMarker = "```tool_code";
+  const openIdx = text.indexOf(openMarker);
+  if (openIdx === -1)
+    return null;
+  const lineStart = text.indexOf(`
+`, openIdx + openMarker.length);
+  if (lineStart === -1)
+    return null;
+  let closeIdx = -1;
+  let searchFrom = lineStart + 1;
+  while (searchFrom < text.length) {
+    const candidate = text.indexOf("```", searchFrom);
+    if (candidate === -1)
+      break;
+    const lineBegin = text.lastIndexOf(`
+`, candidate - 1);
+    if (lineBegin >= lineStart && text.slice(lineBegin + 1, candidate).trim() === "") {
+      closeIdx = candidate;
+      break;
+    }
+    searchFrom = candidate + 3;
+  }
+  if (closeIdx === -1)
+    return null;
+  const rawCode = text.slice(lineStart + 1, closeIdx).replace(/\n[ \t]*$/, "");
+  const code = rawCode.trim();
+  const funcMatch = code.match(/^(\w+)\(([\s\S]*)\)$/);
+  if (!funcMatch)
+    return null;
+  const blockEnd = closeIdx + 3;
+  const content = (text.slice(0, openIdx) + text.slice(blockEnd)).trim();
+  return {
+    tool_calls: [makeToolCall(funcMatch[1], parseKeyValueArgs(funcMatch[2].trim()))],
+    content,
+    parser: "gemma"
+  };
+};
+function parseFunctionGemmaArgs(argsStr) {
+  const args = {};
+  if (!argsStr.trim())
+    return args;
+  const escapeRegex = /(?<![A-Za-z0-9_])([A-Za-z0-9_]+)\s*:\s*<escape>((?:[^<]|<(?!escape>))*)<escape>/g;
+  let escapeMatch;
+  while ((escapeMatch = escapeRegex.exec(argsStr)) !== null) {
+    args[escapeMatch[1]] = coerceArgValue(escapeMatch[2]);
+  }
+  if (Object.keys(args).length > 0)
+    return args;
+  const plainRegex = /(?<![A-Za-z0-9_])(?=([A-Za-z0-9_]+))\1\s*:\s*(?:'([^']*)'|"([^"]*)"|([^,}]+))/g;
+  let plainMatch;
+  while ((plainMatch = plainRegex.exec(argsStr)) !== null) {
+    const key = plainMatch[1].trim();
+    const value = (plainMatch[2] ?? plainMatch[3] ?? plainMatch[4] ?? "").replace(/<escape>/g, "").trim();
+    args[key] = parseFunctionGemmaArgumentValue(value);
+  }
+  if (Object.keys(args).length > 0)
+    return args;
+  const jsonResult = tryParseJson(`{${argsStr}}`);
+  if (jsonResult && typeof jsonResult === "object")
+    return jsonResult;
+  return args;
+}
+var parseFunctionGemma = (text) => {
+  const regex = /(?:<start_function_call>\s*)?call:(?=([\w.]+))\1\s*\{([^}]*)\}(?:\s*<end_function_call>)?/g;
+  const calls = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    calls.push(makeToolCall(match[1].trim(), parseFunctionGemmaArgs(match[2])));
+  }
+  if (calls.length === 0) {
+    const fallbackRegex = /^:([A-Za-z_]\w*)\s*\{([^}]*)\}$/;
+    const fallbackMatch = text.trim().match(fallbackRegex);
+    if (fallbackMatch) {
+      calls.push(makeToolCall(fallbackMatch[1].trim(), parseFunctionGemmaArgs(fallbackMatch[2])));
+    }
+  }
+  if (calls.length === 0)
+    return null;
+  const content = text.replace(/(?:<start_function_call>\s*)?(?:call)?:(?=([\w.]+))\1\s*\{[^}]*\}(?:\s*<end_function_call>)?/g, "").trim();
+  return { tool_calls: calls, content, parser: "functiongemma" };
+};
+function parseLiquidArgs(argsStr) {
+  const trimmed = argsStr.trim();
+  const paramsMatch = trimmed.match(/^params\s*=\s*(\{[\s\S]*\})$/);
+  if (paramsMatch) {
+    const jsonStr = paramsMatch[1].replace(/'/g, '"');
+    const parsed = tryParseJson(jsonStr);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    const jsonified = trimmed.replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":');
+    const parsed = tryParseJson(jsonified);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  }
+  return parseKeyValueArgs(argsStr);
+}
+function extractPythonicCalls(text) {
+  const calls = [];
+  const startRegex = /(?<!\w)(\w+)\(/g;
+  let startMatch;
+  while ((startMatch = startRegex.exec(text)) !== null) {
+    const funcName = startMatch[1];
+    const argsStart = startMatch.index + startMatch[0].length;
+    let depth = 1;
+    let i = argsStart;
+    while (i < text.length && depth > 0) {
+      if (text[i] === "(")
+        depth++;
+      else if (text[i] === ")")
+        depth--;
+      i++;
+    }
+    if (depth === 0) {
+      const argsStr = text.slice(argsStart, i - 1);
+      calls.push(makeToolCall(funcName, parseLiquidArgs(argsStr)));
+      startRegex.lastIndex = i;
+    }
+  }
+  return calls;
+}
+var parseLiquid = (text) => {
+  const specialMatch = text.match(/<\|tool_call_start\|>((?:[^<]|<(?!\|tool_call_end\|>))*)<\|tool_call_end\|>/);
+  if (specialMatch) {
+    const inner = specialMatch[1].trim();
+    const unwrapped = inner.startsWith("[") && inner.endsWith("]") ? inner.slice(1, -1) : inner;
+    const calls = extractPythonicCalls(unwrapped);
+    if (calls.length > 0) {
+      const content = stripModelArtifacts(text.replace(/<\|tool_call_start\|>(?:[^<]|<(?!\|tool_call_end\|>))*<\|tool_call_end\|>/g, ""));
+      return { tool_calls: calls, content, parser: "liquid" };
+    }
+  }
+  const bracketCalls = [];
+  const bracketSpans = [];
+  {
+    const bracketOpenRegex = /\[(?=\w+\()/g;
+    let bm;
+    while ((bm = bracketOpenRegex.exec(text)) !== null) {
+      const innerStart = bm.index + 1;
+      let depth = 0;
+      let i = innerStart;
+      let foundClose = false;
+      while (i < text.length) {
+        const ch = text[i];
+        if (ch === "(")
+          depth++;
+        else if (ch === ")") {
+          depth--;
+          if (depth === 0 && i + 1 < text.length && text[i + 1] === "]") {
+            const inner = text.slice(innerStart, i + 1);
+            const calls = extractPythonicCalls(inner);
+            bracketCalls.push(...calls);
+            bracketSpans.push([bm.index, i + 2]);
+            bracketOpenRegex.lastIndex = i + 2;
+            foundClose = true;
+            break;
+          }
+        }
+        i++;
+      }
+      if (!foundClose)
+        break;
+    }
+  }
+  if (bracketCalls.length > 0) {
+    let content = text;
+    for (let k = bracketSpans.length - 1;k >= 0; k--) {
+      content = content.slice(0, bracketSpans[k][0]) + content.slice(bracketSpans[k][1]);
+    }
+    return { tool_calls: bracketCalls, content: stripModelArtifacts(content), parser: "liquid" };
+  }
+  const callPrefixRegex = /\|?\|?Call:\s*/g;
+  let callPrefixMatch;
+  const callCalls = [];
+  while ((callPrefixMatch = callPrefixRegex.exec(text)) !== null) {
+    const afterPrefix = text.slice(callPrefixMatch.index + callPrefixMatch[0].length);
+    const calls = extractPythonicCalls(afterPrefix);
+    if (calls.length > 0) {
+      callCalls.push(calls[0]);
+    }
+  }
+  if (callCalls.length > 0) {
+    const content = stripModelArtifacts(text.replace(/\|?\|?Call:\s{0,20}\w+\([^)]*\)/g, ""));
+    return { tool_calls: callCalls, content, parser: "liquid" };
+  }
+  return null;
+};
+var parseJamba = (text) => {
+  const tagMatch = text.match(/<tool_calls>((?:[^<]|<(?!\/tool_calls>))*)<\/tool_calls>/);
+  if (tagMatch) {
+    const parsed = tryParseJson(tagMatch[1].trim());
+    if (parsed) {
+      const arr = Array.isArray(parsed) ? parsed : [parsed];
+      const calls = [];
+      for (const c of arr) {
+        if (!c.name)
+          continue;
+        let args = c.arguments ?? c.parameters ?? {};
+        if (typeof args === "string") {
+          args = tryParseJson(args) ?? {};
+        }
+        calls.push(makeToolCall(c.name, args, c.id ?? null));
+      }
+      if (calls.length > 0) {
+        const content = text.slice(0, text.indexOf("<tool_calls>")).trim();
+        return { tool_calls: calls, content, parser: "jamba" };
+      }
+    }
+  }
+  return parseFireFunction(text);
+};
+var parseQwen35Xml = (text) => {
+  const toolCallMatches = text.matchAll(/<tool_call>((?:[^<]|<(?!\/tool_call>))*)<\/tool_call>/g);
+  const calls = [];
+  for (const [_, toolCallBody] of toolCallMatches) {
+    const functionMatch = toolCallBody.trim().match(/<function=([^>\n<]+)>((?:[^<]|<(?!\/function>))*)<\/function>/);
+    if (!functionMatch) {
+      continue;
+    }
+    const [, rawName, functionBody] = functionMatch;
+    const parsedInput = {};
+    const parameterMatches = functionBody.matchAll(/<parameter=([^>\n<]+)>((?:[^<]|<(?!\/parameter>))*)<\/parameter>/g);
+    for (const [__, rawParamName, rawValue] of parameterMatches) {
+      const paramName = rawParamName.trim();
+      const valueText = rawValue.trim();
+      if (paramName === "params") {
+        try {
+          const parsedValue = JSON.parse(valueText);
+          if (parsedValue && typeof parsedValue === "object" && !Array.isArray(parsedValue)) {
+            Object.assign(parsedInput, parsedValue);
+            continue;
+          }
+        } catch {}
+      }
+      parsedInput[paramName] = valueText;
+    }
+    calls.push(makeToolCall(rawName.trim(), parsedInput));
+  }
+  if (calls.length === 0)
+    return null;
+  const content = text.replace(/<tool_call>(?:[^<]|<(?!\/tool_call>))*<\/tool_call>/g, "").trim();
+  return { tool_calls: calls, content, parser: "qwen35xml" };
+};
+var MODEL_PARSERS = {
+  llama: [parseLlama, parseHermes],
+  mistral: [parseMistral, parseHermes],
+  mixtral: [parseMistral, parseHermes],
+  qwen: [parseHermes, parseLlama],
+  qwen2: [parseHermes, parseLlama],
+  qwen3: [parseHermes, parseQwen35Xml, parseLlama],
+  qwen35: [parseQwen35Xml, parseHermes, parseLlama],
+  cohere: [parseCohere, parseHermes],
+  command: [parseCohere, parseHermes],
+  deepseek: [parseDeepSeek, parseHermes],
+  hermes: [parseHermes],
+  phi: [parsePhi, parsePhiFunctools, parseHermes],
+  internlm: [parseInternLM, parseHermes],
+  chatglm: [parseChatGLM],
+  glm: [parseChatGLM],
+  functiongemma: [parseFunctionGemma, parseGemma, parseHermes],
+  gemma: [parseFunctionGemma, parseGemma, parseHermes],
+  functionary: [parseFunctionary],
+  gorilla: [parseGorilla],
+  nexusraven: [parseNexusRaven],
+  xlam: [parseXLAM],
+  firefunction: [parseFireFunction, parsePhiFunctools],
+  granite: [parseGranite, parseHermes],
+  solar: [parseHermes],
+  jamba: [parseJamba, parseHermes],
+  liquid: [parseLiquid, parseHermes],
+  lfm: [parseLiquid, parseHermes],
+  yi: [parseHermes, parseLlama],
+  falcon: [parseHermes, parseLlama]
+};
+var DEFAULT_PARSER_CHAIN = [
+  parsePhi,
+  parseMistral,
+  parseDeepSeek,
+  parseInternLM,
+  parseGranite,
+  parseFunctionGemma,
+  parseQwen35Xml,
+  parseHermes,
+  parseCohere,
+  parseFunctionary,
+  parseGorilla,
+  parseNexusRaven,
+  parseFireFunction,
+  parsePhiFunctools,
+  parseLiquid,
+  parseLlama,
+  parseGemma,
+  parseXLAM
+];
+function detectModelFamily(tokenizerOrName) {
+  let name = "";
+  if (typeof tokenizerOrName === "string") {
+    name = tokenizerOrName.toLowerCase();
+  } else if (tokenizerOrName) {
+    const config = tokenizerOrName.config ?? {};
+    name = (config.name_or_path ?? config._name_or_path ?? config.model_type ?? tokenizerOrName.name_or_path ?? "").toLowerCase();
+  }
+  if (!name)
+    return null;
+  for (const family of Object.keys(MODEL_PARSERS)) {
+    if (name.includes(family)) {
+      return family;
+    }
+  }
+  return null;
+}
+function parseToolCalls(text, { tokenizer = null, model = null, parser = null } = {}) {
+  if (!text || typeof text !== "string") {
+    return { tool_calls: [], content: text ?? "", parser: "none" };
+  }
+  let parsersToTry;
+  if (parser) {
+    const key = parser.toLowerCase();
+    const found = MODEL_PARSERS[key];
+    if (!found) {
+      throw new Error(`Unknown parser "${parser}". Available parsers: ${Object.keys(MODEL_PARSERS).join(", ")}`);
+    }
+    parsersToTry = found;
+  } else {
+    const family = detectModelFamily(tokenizer ?? model ?? null);
+    parsersToTry = family ? MODEL_PARSERS[family] : DEFAULT_PARSER_CHAIN;
+  }
+  for (const parserFn of parsersToTry) {
+    const result = parserFn(text);
+    if (result)
+      return result;
+  }
+  return { tool_calls: [], content: text, parser: "none" };
+}
+function hasToolCalls(text) {
+  if (!text)
+    return false;
+  return text.includes("<tool_call>") || text.includes("[TOOL_CALLS]") || text.includes("<|python_tag|>") || text.includes("<function=") || text.includes("<|tool_calls|>") || text.includes("<tool_calls>") || text.includes("<|action_start|>") || text.includes("<<function>>") || text.includes(">>>") || text.includes("Call:") || text.includes("Action:") || text.includes("functools") || text.includes("<start_function_call>") || text.includes("<|tool_call|>") || text.includes("<|tool_call_start|>") || /tool[\s\u2581]call[\s\u2581]begin/.test(text);
+}
+function getAvailableParsers() {
+  return Object.keys(MODEL_PARSERS);
+}
+function getGenerationPrefix(family, forcedToolName) {
+  if (!family)
+    return;
+  switch (family) {
+    case "functiongemma":
+      return forcedToolName ? `<start_function_call>call:${forcedToolName}{` : "<start_function_call>call:";
+    default:
+      return;
+  }
+}
+function parseToolCallsFromText(responseText) {
+  const functionGemmaResult = parseFunctionGemma(responseText);
+  if (functionGemmaResult && functionGemmaResult.tool_calls.length > 0) {
+    return {
+      text: functionGemmaResult.content,
+      toolCalls: functionGemmaResult.tool_calls.map((call, index) => ({
+        id: call.id ?? `call_${index}`,
+        name: call.name,
+        input: call.arguments
+      }))
+    };
+  }
+  const looseObject = parseFunctionGemmaLooseObject(responseText);
+  if (looseObject) {
+    return {
+      text: "",
+      toolCalls: [{ id: "call_0", name: "", input: looseObject }]
+    };
+  }
+  const hermesResult = parseHermes(responseText);
+  if (hermesResult && hermesResult.tool_calls.length > 0) {
+    return {
+      text: hermesResult.content,
+      toolCalls: hermesResult.tool_calls.map((call, index) => ({
+        id: call.id ?? `call_${index}`,
+        name: call.name,
+        input: call.arguments
+      }))
+    };
+  }
+  const toolCalls = [];
+  let callIndex = 0;
+  const jsonCandidates = findBalancedBlocks(responseText, "{", "}");
+  const matchedRanges = [];
+  for (const candidate of jsonCandidates) {
+    try {
+      const parsed = JSON.parse(candidate.text);
+      if (parsed.name && (parsed.arguments !== undefined || parsed.parameters !== undefined)) {
+        const id = `call_${callIndex++}`;
+        toolCalls.push({
+          id,
+          name: parsed.name,
+          input: parsed.arguments ?? parsed.parameters ?? {}
+        });
+        matchedRanges.push({ start: candidate.start, end: candidate.end });
+      } else if (parsed.function?.name) {
+        let functionArgs = parsed.function.arguments ?? {};
+        if (typeof functionArgs === "string") {
+          try {
+            functionArgs = JSON.parse(functionArgs);
+          } catch {
+            functionArgs = {};
+          }
+        }
+        const id = `call_${callIndex++}`;
+        toolCalls.push({
+          id,
+          name: parsed.function.name,
+          input: functionArgs ?? {}
+        });
+        matchedRanges.push({ start: candidate.start, end: candidate.end });
+      }
+    } catch {}
+  }
+  let cleanedText = responseText;
+  if (toolCalls.length > 0) {
+    let result = "";
+    let lastIndex = 0;
+    for (const range of matchedRanges) {
+      result += responseText.slice(lastIndex, range.start);
+      lastIndex = range.end;
+    }
+    result += responseText.slice(lastIndex);
+    cleanedText = result.trim();
+  }
+  return { text: cleanedText, toolCalls };
+}
+
+// src/provider-llamacpp/common/LlamaCpp_ToolParser.ts
+function getModelTextCandidates(model) {
+  return [
+    model.model_id,
+    model.title,
+    model.description,
+    model.provider_config.model_url,
+    model.provider_config.model_path
+  ].filter((value) => typeof value === "string" && value.length > 0).map((value) => value.toLowerCase());
+}
+function toolChoiceForcesToolCall(toolChoice) {
+  return toolChoice === "required" || toolChoice !== undefined && toolChoice !== "auto" && toolChoice !== "none";
+}
+function forcedToolChoiceName(toolChoice) {
+  if (typeof toolChoice !== "string" || toolChoice === "auto" || toolChoice === "none" || toolChoice === "required") {
+    return;
+  }
+  return toolChoice;
+}
+function forcedToolSelection(input) {
+  const explicitToolName = forcedToolChoiceName(input.toolChoice);
+  if (explicitToolName !== undefined) {
+    return explicitToolName;
+  }
+  if (input.toolChoice === "required" && input.tools.length === 1) {
+    return input.tools[0]?.name;
+  }
+  return;
+}
+function resolveParsedToolName(name, input) {
+  if (input.tools.some((tool) => tool.name === name)) {
+    return name;
+  }
+  return forcedToolSelection(input) ?? name;
+}
+function detectFunctionGemmaModel(model) {
+  return getModelTextCandidates(model).some((value) => value.includes("functiongemma"));
+}
+function functionGemmaDeclarationSchema(schema) {
+  if (!schema) {
+    return "{type: OBJECT}";
+  }
+  const type = typeof schema.type === "string" ? schema.type.toUpperCase() : "OBJECT";
+  const description = typeof schema.description === "string" ? `description: ${schema.description} ,` : "";
+  if (type === "OBJECT") {
+    const properties = schema.properties && typeof schema.properties === "object" ? Object.entries(schema.properties).map(([key, value]) => {
+      const property = value ?? {};
+      const propertyType = typeof property.type === "string" ? property.type.toUpperCase() : "STRING";
+      const propertyDescription = typeof property.description === "string" ? `description: ${property.description} ,` : "";
+      return `${key}:{${propertyDescription}type: ${propertyType}}`;
+    }).join(",") : "";
+    const required = Array.isArray(schema.required) ? schema.required.join(",") : "";
+    return `{${description}parameters:{properties:{${properties}},required:[${required}],type: OBJECT}}`;
+  }
+  return `{${description}type: ${type}}`;
+}
+function buildFunctionGemmaDeclarations(tools) {
+  return tools.map((tool) => {
+    const description = tool.description?.trim() ?? "";
+    return `declaration:${tool.name}
+` + `{description: ${description} ,parameters:` + `${functionGemmaDeclarationSchema(tool.inputSchema).slice(1, -1)}}`;
+  }).join(`
+`);
+}
+function buildFunctionGemmaDeveloperPrompt(baseSystemPrompt, required) {
+  const lines = [
+    baseSystemPrompt,
+    "You are a model that can do function calling with the following functions",
+    required ? "You must call at least one function from the provided list." : undefined,
+    "If you call a function, output only the function call and nothing else.",
+    "If tool results are already available and no further function call is needed, answer the user normally."
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  return lines.join(`
+`);
+}
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return String(content ?? "");
+  }
+  return content.filter((block) => block && typeof block === "object" && block.type === "text").map((block) => String(block.text ?? "")).join("");
+}
+function serializeFunctionGemmaValue(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null || Array.isArray(value) || typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return JSON.stringify(String(value));
+}
+function serializeFunctionGemmaToolCall(name, input) {
+  const args = Object.entries(input).map(([key, value]) => `${key}:${serializeFunctionGemmaValue(value)}`).join(",");
+  return `call:${name}{${args}}`;
+}
+function buildFunctionGemmaConversationPrompt(input) {
+  if (!input.messages || input.messages.length === 0) {
+    return String(input.prompt);
+  }
+  const turns = [];
+  const toolNamesById = new Map;
+  for (const message of input.messages) {
+    if (message.role === "user") {
+      turns.push("user", extractMessageText(message.content));
+      continue;
+    }
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      const toolUses = message.content.filter((block) => block.type === "tool_use");
+      const serializedCalls = toolUses.map((block) => {
+        toolNamesById.set(block.id, block.name);
+        return serializeFunctionGemmaToolCall(block.name, block.input);
+      });
+      const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+      const serializedCallText = serializedCalls.join(`
+`).trim();
+      if (text && text !== serializedCallText && !serializedCalls.some((call) => text.includes(call))) {
+        turns.push("model", text);
+      }
+      if (serializedCalls.length > 0) {
+        turns.push("model", serializedCalls.join(`
+`));
+      }
+      continue;
+    }
+    if (message.role === "tool" && Array.isArray(message.content)) {
+      for (const block of message.content) {
+        const toolName = toolNamesById.get(block.tool_use_id) ?? "tool";
+        const resultText = extractMessageText(block.content);
+        turns.push("user", `The function ${toolName} already returned this result: ${resultText}
+` + `Do not call ${toolName} again just to repeat the same lookup.
+` + `If this result answers the user's request, reply with the final answer.
+` + `Only call another function if a different function is still needed to complete the request.`);
+      }
+    }
+  }
+  return turns.join(`
+`);
+}
+function buildFunctionGemmaRawPrompt(input, systemPrompt) {
+  const hasMessages = input.messages && input.messages.length > 0;
+  const userPrompt = buildFunctionGemmaConversationPrompt(input);
+  const parts = [
+    "developer",
+    buildFunctionGemmaDeveloperPrompt(systemPrompt, input.toolChoice === "required"),
+    buildFunctionGemmaDeclarations(input.tools)
+  ];
+  if (hasMessages) {
+    parts.push(userPrompt);
+  } else {
+    parts.push("user", userPrompt);
+  }
+  parts.push("model");
+  return parts.join(`
+`);
+}
+function buildRawCompletionPrompt(input, model, systemPrompt) {
+  if (detectFunctionGemmaModel(model) && input.toolChoice !== "none") {
+    return buildFunctionGemmaRawPrompt(input, systemPrompt);
+  }
+  return;
+}
+function supportsNativeFunctions(input, model) {
+  return input.toolChoice !== "none" && !detectFunctionGemmaModel(model);
+}
+function truncateAtTurnBoundary(text) {
+  const markers = [`
+user
+`, `
+developer
+`];
+  let truncateAt = text.length;
+  for (const marker of markers) {
+    const idx = text.indexOf(marker);
+    if (idx !== -1 && idx < truncateAt) {
+      truncateAt = idx;
+    }
+  }
+  return text.slice(0, truncateAt).trim();
+}
+function adaptParserResult(result, input) {
+  return result.tool_calls.map((call, index) => ({
+    id: call.id ?? `call_${index}`,
+    name: resolveParsedToolName(call.name, input),
+    input: call.arguments
+  }));
+}
+function extractToolCallsFromText(text, input, model) {
+  if (detectFunctionGemmaModel(model)) {
+    const functionGemmaResult = parseFunctionGemma(text);
+    if (functionGemmaResult && functionGemmaResult.tool_calls.length > 0) {
+      return adaptParserResult(functionGemmaResult, input);
+    }
+    const forcedToolName = forcedToolSelection(input);
+    const looseObject = forcedToolName ? parseFunctionGemmaLooseObject(text) : undefined;
+    if (forcedToolName && looseObject) {
+      return [{ id: "call_0", name: forcedToolName, input: looseObject }];
+    }
+  }
+  const liquidResult = parseLiquid(text);
+  if (liquidResult && liquidResult.tool_calls.length > 0) {
+    return adaptParserResult(liquidResult, input);
+  }
+  const hermesResult = parseHermes(text);
+  if (hermesResult && hermesResult.tool_calls.length > 0) {
+    return adaptParserResult(hermesResult, input);
+  }
+  const qwen35Result = parseQwen35Xml(text);
+  if (qwen35Result && qwen35Result.tool_calls.length > 0) {
+    return adaptParserResult(qwen35Result, input);
+  }
+  const llamaResult = parseLlama(text);
+  if (llamaResult && llamaResult.tool_calls.length > 0) {
+    return adaptParserResult(llamaResult, input);
+  }
+  return [];
+}
+
+// src/provider-llamacpp/common/LlamaCpp_ToolCalling.ts
+import { getLogger } from "@workglow/util/worker";
+function buildSystemPrompt(input) {
+  const base = input.systemPrompt;
+  if (input.toolChoice === "required") {
+    const instruction = "You must call at least one tool from the provided tool list when answering.";
+    return base ? `${base}
+
+${instruction}` : instruction;
+  }
+  return base || undefined;
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return String(content ?? "");
+  return content.filter((block) => block?.type === "text").map((block) => String(block.text ?? "")).join("");
+}
+function convertMessagesToChatHistory(messages, prompt, systemPrompt) {
+  const history = [];
+  if (systemPrompt) {
+    history.push({ type: "system", text: systemPrompt });
+  }
+  if (!messages || messages.length === 0) {
+    const promptText = typeof prompt === "string" ? prompt : String(prompt ?? "");
+    history.push({ type: "user", text: promptText });
+    return history;
+  }
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const text = extractTextFromContent(msg.content);
+      history.push({ type: "user", text });
+      continue;
+    }
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      const response = [];
+      for (const block of msg.content) {
+        if (block.type === "text" && block.text) {
+          response.push(block.text);
+        } else if (block.type === "tool_use") {
+          response.push({
+            type: "functionCall",
+            name: block.name,
+            description: undefined,
+            params: block.input ?? {},
+            result: undefined,
+            _toolUseId: block.id
+          });
+        }
+      }
+      history.push({ type: "model", response });
+      continue;
+    }
+    if (msg.role === "tool" && Array.isArray(msg.content)) {
+      let lastModel;
+      for (let i = history.length - 1;i >= 0; i--) {
+        if (history[i].type === "model") {
+          lastModel = history[i];
+          break;
+        }
+      }
+      if (!lastModel)
+        continue;
+      for (const block of msg.content) {
+        const toolUseId = block.tool_use_id;
+        if (!toolUseId)
+          continue;
+        const fnCall = lastModel.response.find((item) => typeof item === "object" && item !== null && item.type === "functionCall" && item._toolUseId === toolUseId && item.result === undefined);
+        if (fnCall) {
+          fnCall.result = typeof block.content === "string" ? block.content : JSON.stringify(block.content);
+        }
+      }
+      continue;
+    }
+  }
+  for (const item of history) {
+    if (item.type === "model" && Array.isArray(item.response)) {
+      for (const entry of item.response) {
+        if (typeof entry === "object" && entry !== null && "_toolUseId" in entry) {
+          delete entry._toolUseId;
+        }
+      }
+    }
+  }
+  return history;
+}
+function buildChatModelFunctions(tools) {
+  const functions = {};
+  for (const tool of tools) {
+    functions[tool.name] = {
+      ...tool.description && { description: tool.description },
+      ...tool.inputSchema && { params: tool.inputSchema }
+    };
+  }
+  return functions;
+}
+function llamaCppRawCompletionOptions(input, model) {
+  const opts = {
+    ...llamaCppSeedPromptSpread(model.provider_config)
+  };
+  if (input.maxTokens !== undefined) {
+    opts.maxTokens = input.maxTokens;
+  }
+  if (input.temperature !== undefined) {
+    opts.temperature = input.temperature;
+  } else if (toolChoiceForcesToolCall(input.toolChoice)) {
+    opts.temperature = 0.2;
+  }
+  return opts;
+}
+function llamaCppChatGenerateOptions(input, model) {
+  const opts = {
+    ...llamaCppSeedPromptSpread(model.provider_config)
+  };
+  if (input.maxTokens !== undefined) {
+    opts.maxTokens = input.maxTokens;
+  }
+  if (input.temperature !== undefined) {
+    opts.temperature = input.temperature;
+  } else if (toolChoiceForcesToolCall(input.toolChoice)) {
+    opts.temperature = 0.2;
+  }
+  return opts;
+}
+function extractNativeFunctionCalls(functionCalls) {
+  if (!functionCalls || functionCalls.length === 0)
+    return [];
+  return functionCalls.map((fc, index) => ({
+    id: `call_${index}`,
+    name: fc.functionName,
+    input: fc.params ?? {}
+  }));
+}
+var LlamaCpp_ToolCalling = async (input, model, update_progress, signal) => {
+  if (!model)
+    throw new Error("Model config is required for ToolCallingTask.");
+  await loadSdk();
+  update_progress(0, "Loading model");
+  const context = await getOrCreateTextContext(model);
+  update_progress(10, "Running tool calling");
+  const sequence = context.getSequence();
+  const { LlamaChat, LlamaCompletion } = getLlamaCppSdk();
+  const systemPrompt = buildSystemPrompt(input);
+  const rawPrompt = buildRawCompletionPrompt(input, model, systemPrompt);
+  getLogger().debug("LlamaCpp_ToolCalling", { rawPrompt, systemPrompt });
+  if (rawPrompt !== undefined) {
+    const completion = new LlamaCompletion({ contextSequence: sequence });
+    try {
+      const rawText = await completion.generateCompletion(rawPrompt, {
+        signal,
+        ...llamaCppRawCompletionOptions(input, model)
+      });
+      const text = truncateAtTurnBoundary(rawText);
+      getLogger().debug("LlamaCpp_ToolCalling LlamaCompletion", { rawText, text });
+      const toolCalls = filterValidToolCalls(extractToolCallsFromText(text, input, model), input.tools);
+      getLogger().debug("LlamaCpp_ToolCalling LlamaCompletion", { toolCalls });
+      update_progress(100, "Tool calling complete");
+      return { text, toolCalls };
+    } finally {
+      completion.dispose({ disposeSequence: false });
+      sequence.dispose();
+    }
+  }
+  const llamaChat = new LlamaChat({
+    contextSequence: sequence,
+    ...llamaCppChatSessionConstructorSpread(model)
+  });
+  const promptText = typeof input.prompt === "string" ? input.prompt : extractTextFromContent(input.prompt);
+  const chatHistory = convertMessagesToChatHistory(input.messages, promptText, systemPrompt);
+  const functions = supportsNativeFunctions(input, model) ? buildChatModelFunctions(input.tools) : undefined;
+  getLogger().debug("LlamaCpp_ToolCalling LlamaChat", { chatHistory, functions });
+  try {
+    const res = await llamaChat.generateResponse(chatHistory, {
+      signal,
+      ...llamaCppChatGenerateOptions(input, model),
+      ...functions && {
+        functions,
+        ...toolChoiceForcesToolCall(input.toolChoice) && { documentFunctionParams: true }
+      }
+    });
+    const text = res.response;
+    const toolCalls = extractNativeFunctionCalls(res.functionCalls);
+    if (toolCalls.length === 0 && input.tools.length > 0 && input.toolChoice !== "none") {
+      toolCalls.push(...extractToolCallsFromText(text, input, model));
+    }
+    update_progress(100, "Tool calling complete");
+    return { text, toolCalls: filterValidToolCalls(toolCalls, input.tools) };
+  } finally {
+    llamaChat.dispose({ disposeSequence: false });
+    sequence.dispose();
+  }
+};
+async function* streamTextChunks(startGeneration, signal, cleanup) {
+  const queue = [];
+  let isComplete = false;
+  let completionError;
+  let resolveWait = null;
+  let accumulatedText = "";
+  let result;
+  const notifyWaiter = () => {
+    resolveWait?.();
+    resolveWait = null;
+  };
+  const generationPromise = startGeneration((chunk) => {
+    queue.push(chunk);
+    notifyWaiter();
+  }).then((res) => {
+    result = res;
+    isComplete = true;
+    notifyWaiter();
+  }).catch((err) => {
+    completionError = err;
+    isComplete = true;
+    notifyWaiter();
+  });
+  try {
+    while (true) {
+      while (queue.length > 0) {
+        const chunk = queue.shift();
+        accumulatedText += chunk;
+        yield { type: "text-delta", port: "text", textDelta: chunk };
+      }
+      if (isComplete)
+        break;
+      await new Promise((r) => {
+        resolveWait = r;
+      });
+    }
+    while (queue.length > 0) {
+      const chunk = queue.shift();
+      accumulatedText += chunk;
+      yield { type: "text-delta", port: "text", textDelta: chunk };
+    }
+  } finally {
+    await generationPromise.catch(() => {});
+    cleanup();
+  }
+  if (completionError) {
+    throw completionError;
+  }
+  if (signal.aborted) {
+    throw signal.reason ?? new Error("The operation was aborted");
+  }
+  return { text: accumulatedText, result };
+}
+var LlamaCpp_ToolCalling_Stream = async function* (input, model, signal) {
+  if (!model)
+    throw new Error("Model config is required for ToolCallingTask.");
+  await loadSdk();
+  const context = await getOrCreateTextContext(model);
+  const sequence = context.getSequence();
+  const { LlamaChat, LlamaCompletion } = getLlamaCppSdk();
+  const systemPrompt = buildSystemPrompt(input);
+  const rawPrompt = buildRawCompletionPrompt(input, model, systemPrompt);
+  if (rawPrompt !== undefined) {
+    const completion = new LlamaCompletion({ contextSequence: sequence });
+    const { text: rawText } = yield* streamTextChunks((onTextChunk) => completion.generateCompletion(rawPrompt, {
+      signal,
+      ...llamaCppRawCompletionOptions(input, model),
+      onTextChunk
+    }), signal, () => {
+      completion.dispose({ disposeSequence: false });
+      sequence.dispose();
+    });
+    const text = truncateAtTurnBoundary(rawText);
+    const validToolCalls2 = filterValidToolCalls(extractToolCallsFromText(text, input, model), input.tools);
+    if (validToolCalls2.length > 0) {
+      yield { type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls2] };
+    }
+    yield {
+      type: "finish",
+      data: { text, toolCalls: validToolCalls2 }
+    };
+    return;
+  }
+  const llamaChat = new LlamaChat({
+    contextSequence: sequence,
+    ...llamaCppChatSessionConstructorSpread(model)
+  });
+  const promptText = typeof input.prompt === "string" ? input.prompt : extractTextFromContent(input.prompt);
+  const chatHistory = convertMessagesToChatHistory(input.messages, promptText, systemPrompt);
+  const functions = supportsNativeFunctions(input, model) ? buildChatModelFunctions(input.tools) : undefined;
+  const { text: accumulatedText, result: chatResponse } = yield* streamTextChunks((onTextChunk) => llamaChat.generateResponse(chatHistory, {
+    signal,
+    ...llamaCppChatGenerateOptions(input, model),
+    ...functions && {
+      functions,
+      ...toolChoiceForcesToolCall(input.toolChoice) && { documentFunctionParams: true }
+    },
+    onTextChunk
+  }), signal, () => {
+    llamaChat.dispose({ disposeSequence: false });
+    sequence.dispose();
+  });
+  const toolCalls = extractNativeFunctionCalls(chatResponse?.functionCalls);
+  if (toolCalls.length === 0 && input.tools.length > 0 && input.toolChoice !== "none") {
+    toolCalls.push(...extractToolCallsFromText(accumulatedText, input, model));
+  }
+  const validToolCalls = filterValidToolCalls(toolCalls, input.tools);
+  if (validToolCalls.length > 0) {
+    yield { type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] };
+  }
+  yield {
+    type: "finish",
+    data: { text: accumulatedText, toolCalls: validToolCalls }
+  };
+};
+
 // src/provider-llamacpp/common/LlamaCpp_Unload.ts
 var LlamaCpp_Unload = async (input, model, update_progress, _signal) => {
   if (!model)
@@ -682,6 +2067,7 @@ var LLAMACPP_TASKS = {
   TextEmbeddingTask: LlamaCpp_TextEmbedding,
   TextRewriterTask: LlamaCpp_TextRewriter,
   TextSummaryTask: LlamaCpp_TextSummary,
+  ToolCallingTask: LlamaCpp_ToolCalling,
   StructuredGenerationTask: LlamaCpp_StructuredGeneration,
   ModelSearchTask: LlamaCpp_ModelSearch
 };
@@ -689,6 +2075,7 @@ var LLAMACPP_STREAM_TASKS = {
   TextGenerationTask: LlamaCpp_TextGeneration_Stream,
   TextRewriterTask: LlamaCpp_TextRewriter_Stream,
   TextSummaryTask: LlamaCpp_TextSummary_Stream,
+  ToolCallingTask: LlamaCpp_ToolCalling_Stream,
   StructuredGenerationTask: LlamaCpp_StructuredGeneration_Stream
 };
 var LLAMACPP_REACTIVE_TASKS = {
@@ -696,9 +2083,7 @@ var LLAMACPP_REACTIVE_TASKS = {
 };
 
 // src/provider-llamacpp/LlamaCppQueuedProvider.ts
-import {
-  QueuedAiProvider
-} from "@workglow/ai";
+import { QueuedAiProvider } from "@workglow/ai";
 class LlamaCppQueuedProvider extends QueuedAiProvider {
   name = LOCAL_LLAMACPP;
   displayName = "Local llama.cpp";
@@ -713,6 +2098,7 @@ class LlamaCppQueuedProvider extends QueuedAiProvider {
     "TextEmbeddingTask",
     "TextRewriterTask",
     "TextSummaryTask",
+    "ToolCallingTask",
     "ModelSearchTask"
   ];
   constructor(tasks, streamTasks, reactiveTasks) {
@@ -725,12 +2111,10 @@ async function registerLlamaCppInline(options) {
   await new LlamaCppQueuedProvider(LLAMACPP_TASKS, LLAMACPP_STREAM_TASKS, LLAMACPP_REACTIVE_TASKS).register(options ?? {});
 }
 // src/provider-llamacpp/registerLlamaCppWorker.ts
-import { getLogger, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+import { getLogger as getLogger2, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
 
 // src/provider-llamacpp/LlamaCppProvider.ts
-import {
-  AiProvider
-} from "@workglow/ai/worker";
+import { AiProvider } from "@workglow/ai/worker";
 class LlamaCppProvider extends AiProvider {
   name = LOCAL_LLAMACPP;
   displayName = "Local llama.cpp";
@@ -745,6 +2129,7 @@ class LlamaCppProvider extends AiProvider {
     "TextEmbeddingTask",
     "TextRewriterTask",
     "TextSummaryTask",
+    "ToolCallingTask",
     "ModelSearchTask"
   ];
   constructor(tasks, streamTasks, reactiveTasks) {
@@ -757,7 +2142,7 @@ async function registerLlamaCppWorker() {
   const workerServer = globalServiceRegistry.get(WORKER_SERVER);
   new LlamaCppProvider(LLAMACPP_TASKS, LLAMACPP_STREAM_TASKS, LLAMACPP_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
   workerServer.sendReady();
-  getLogger().info("LlamaCpp worker job run functions registered");
+  getLogger2().info("LlamaCpp worker job run functions registered");
 }
 export {
   streamFromSession,
@@ -780,4 +2165,4 @@ export {
   disposeLlamaCppResources
 };
 
-//# debugId=EB49E8246FF54A0364756E2164756E21
+//# debugId=86AE88EC6A1801D664756E2164756E21