@workglow/ai-provider 0.1.2 → 0.2.0

package/dist/provider-hf-transformers/runtime.js

@@ -612,6 +612,71 @@ function parseOnnxQuantizations(params) {
     return set !== undefined && set.size === allBaseNames.size;
   });
 }
+// src/provider-hf-transformers/common/HFT_ToolMarkup.ts
+function createToolCallMarkupFilter(emit) {
+  const OPEN_TAG = "<tool_call>";
+  const CLOSE_TAG = "</tool_call>";
+  let state = "text";
+  let pending = "";
+  function feed(token) {
+    if (state === "tag") {
+      pending += token;
+      const closeIdx = pending.indexOf(CLOSE_TAG);
+      if (closeIdx !== -1) {
+        const afterClose = pending.slice(closeIdx + CLOSE_TAG.length);
+        pending = "";
+        state = "text";
+        if (afterClose.length > 0) {
+          feed(afterClose);
+        }
+      }
+      return;
+    }
+    const combined = pending + token;
+    const openIdx = combined.indexOf(OPEN_TAG);
+    if (openIdx !== -1) {
+      const before = combined.slice(0, openIdx);
+      if (before.length > 0) {
+        emit(before);
+      }
+      pending = "";
+      state = "tag";
+      const afterOpen = combined.slice(openIdx + OPEN_TAG.length);
+      if (afterOpen.length > 0) {
+        feed(afterOpen);
+      }
+      return;
+    }
+    let prefixLen = 0;
+    for (let len = Math.min(combined.length, OPEN_TAG.length - 1);len >= 1; len--) {
+      if (combined.endsWith(OPEN_TAG.slice(0, len))) {
+        prefixLen = len;
+        break;
+      }
+    }
+    if (prefixLen > 0) {
+      const safe = combined.slice(0, combined.length - prefixLen);
+      if (safe.length > 0) {
+        emit(safe);
+      }
+      pending = combined.slice(combined.length - prefixLen);
+    } else {
+      if (combined.length > 0) {
+        emit(combined);
+      }
+      pending = "";
+    }
+  }
+  function flush() {
+    if (pending.length > 0 && state === "text") {
+      emit(pending);
+      pending = "";
+    }
+    pending = "";
+    state = "text";
+  }
+  return { feed, flush };
+}
 // src/provider-hf-transformers/common/HFT_InlineLifecycle.ts
 async function clearHftInlinePipelineCache() {
   const { clearPipelineCache: clearPipelineCache2 } = await Promise.resolve().then(() => (init_HFT_Pipeline(), exports_HFT_Pipeline));
@@ -1072,11 +1137,15 @@ ${schemaStr}
 
 ` + `Output ONLY the JSON object, no other text.`;
 }
+function stripThinkingAndSpecialTokens(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").replace(/<\|[a-z_]+\|>/g, "").trim();
+}
 function extractJsonFromText(text) {
+  const cleaned = stripThinkingAndSpecialTokens(text);
   try {
-    return JSON.parse(text);
+    return JSON.parse(cleaned);
   } catch {
-    const match = text.match(/\{[\s\S]*\}/);
+    const match = cleaned.match(/\{[\s\S]*\}/);
     if (match) {
       try {
         return JSON.parse(match[0]);
@@ -1123,13 +1192,41 @@ var HFT_StructuredGeneration_Stream = async function* (input, model, signal) {
   const queue = createStreamEventQueue();
   const streamer = createStreamingTextStreamer(generateText.tokenizer, queue, TextStreamer, signal);
   let fullText = "";
+  let cleanedText = "";
+  let inThinkBlock = false;
+  let jsonStart = -1;
   const originalPush = queue.push;
   queue.push = (event) => {
     if (event.type === "text-delta" && "textDelta" in event) {
-      fullText += event.textDelta;
-      const match = fullText.match(/\{[\s\S]*/);
-      if (match) {
-        const partial = parsePartialJson(match[0]);
+      const delta = event.textDelta;
+      fullText += delta;
+      let remaining = delta;
+      while (remaining.length > 0) {
+        if (inThinkBlock) {
+          const closeIdx = remaining.indexOf("</think>");
+          if (closeIdx !== -1) {
+            inThinkBlock = false;
+            remaining = remaining.slice(closeIdx + "</think>".length);
+          } else {
+            remaining = "";
+          }
+        } else {
+          const openIdx = remaining.indexOf("<think>");
+          if (openIdx !== -1) {
+            cleanedText += remaining.slice(0, openIdx).replace(/<\|[a-z_]+\|>/g, "");
+            inThinkBlock = true;
+            remaining = remaining.slice(openIdx + "<think>".length);
+          } else {
+            cleanedText += remaining.replace(/<\|[a-z_]+\|>/g, "");
+            remaining = "";
+          }
+        }
+      }
+      if (jsonStart === -1) {
+        jsonStart = cleanedText.indexOf("{");
+      }
+      if (jsonStart !== -1) {
+        const partial = parsePartialJson(cleanedText.slice(jsonStart));
         if (partial !== undefined) {
           originalPush({
             type: "object-delta",
@@ -1480,6 +1577,1139 @@ var HFT_TextTranslation_Stream = async function* (input, model, signal) {
   yield { type: "finish", data: { target_lang: input.target_lang } };
 };
 
+// src/provider-hf-transformers/common/HFT_ToolCalling.ts
+init_HFT_Pipeline();
+import {
+  buildToolDescription,
+  filterValidToolCalls,
+  toTextFlatMessages
+} 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-hf-transformers/common/HFT_ToolCalling.ts
+function getModelTextCandidates(model) {
+  return [model.model_id, model.title, model.description, model.provider_config.model_path].filter((value) => typeof value === "string" && value.length > 0).map((value) => value.toLowerCase());
+}
+function detectModelFamilyFromConfig(model) {
+  const candidates = getModelTextCandidates(model);
+  const families = getAvailableParsers();
+  for (const candidate of candidates) {
+    for (const family of families) {
+      if (candidate.includes(family)) {
+        return family;
+      }
+    }
+  }
+  return null;
+}
+function adaptParserResult(result) {
+  return {
+    text: stripModelArtifacts(result.content),
+    toolCalls: result.tool_calls.map((call, index) => ({
+      id: call.id ?? `call_${index}`,
+      name: call.name,
+      input: call.arguments
+    }))
+  };
+}
+function forcedToolSelection(input) {
+  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto" && input.toolChoice !== "none") {
+    if (input.toolChoice !== "required") {
+      return input.toolChoice;
+    }
+  }
+  if (input.toolChoice === "required" && input.tools.length === 1) {
+    return input.tools[0]?.name;
+  }
+  return;
+}
+function normalizeParsedToolCalls(input, toolCalls) {
+  const forcedToolName = forcedToolSelection(input);
+  return toolCalls.map((toolCall) => toolCall.name ? toolCall : {
+    ...toolCall,
+    name: forcedToolName ?? toolCall.name
+  });
+}
+function mapHFTTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+}
+function resolveHFTToolsAndMessages(input, messages) {
+  if (input.toolChoice === "none") {
+    return;
+  }
+  if (input.toolChoice === "required") {
+    const requiredInstruction = "You must call at least one tool from the provided tool list when answering.";
+    if (messages.length > 0 && messages[0].role === "system") {
+      messages[0] = { ...messages[0], content: `${messages[0].content}
+
+${requiredInstruction}` };
+    } else {
+      messages.unshift({ role: "system", content: requiredInstruction });
+    }
+    return mapHFTTools(input.tools);
+  }
+  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto") {
+    const selectedTools = input.tools?.filter((tool) => tool.name === input.toolChoice);
+    const toolsToMap = selectedTools && selectedTools.length > 0 ? selectedTools : input.tools;
+    return mapHFTTools(toolsToMap);
+  }
+  return mapHFTTools(input.tools);
+}
+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 parsePossibleToolResponse(content) {
+  const trimmed = content.trim();
+  if (!trimmed)
+    return "";
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {}
+  }
+  return content;
+}
+function buildHFTMessages(input) {
+  const messages = [];
+  if (input.systemPrompt) {
+    messages.push({ role: "system", content: input.systemPrompt });
+  }
+  if (input.toolChoice === "required") {
+    const instruction = "You must call at least one tool from the provided tool list when answering.";
+    if (messages.length > 0 && messages[0].role === "system") {
+      messages[0] = {
+        ...messages[0],
+        content: `${messages[0].content}
+
+${instruction}`
+      };
+    } else {
+      messages.unshift({ role: "system", content: instruction });
+    }
+  }
+  const sourceMessages = input.messages && input.messages.length > 0 ? input.messages : [{ role: "user", content: input.prompt }];
+  const toolNamesById = new Map;
+  for (const message of sourceMessages) {
+    if (message.role === "user") {
+      messages.push({ role: "user", content: extractMessageText(message.content) });
+      continue;
+    }
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+      const toolCalls = message.content.filter((block) => block.type === "tool_use").map((block) => {
+        toolNamesById.set(block.id, block.name);
+        return { function: { name: block.name, arguments: block.input } };
+      });
+      if (text || toolCalls.length > 0) {
+        const assistantMsg = { role: "assistant" };
+        if (text)
+          assistantMsg.content = text;
+        if (toolCalls.length > 0)
+          assistantMsg.tool_calls = toolCalls;
+        messages.push(assistantMsg);
+      }
+      continue;
+    }
+    if (message.role === "tool" && Array.isArray(message.content)) {
+      for (const block of message.content) {
+        const toolName = toolNamesById.get(block.tool_use_id);
+        if (!toolName)
+          continue;
+        messages.push({
+          role: "tool",
+          name: toolName,
+          content: parsePossibleToolResponse(extractMessageText(block.content))
+        });
+      }
+    }
+  }
+  return messages;
+}
+function selectHFTTools(input) {
+  if (input.toolChoice === "none")
+    return;
+  if (typeof input.toolChoice === "string" && input.toolChoice !== "auto" && input.toolChoice !== "required") {
+    const selected = input.tools.filter((t) => t.name === input.toolChoice);
+    return mapHFTTools(selected.length > 0 ? selected : input.tools);
+  }
+  return mapHFTTools(input.tools);
+}
+function hasToolMessages(input) {
+  return input.messages?.some((m) => m.role === "tool") ?? false;
+}
+function buildPromptAndPrefix(tokenizer, input, modelFamily) {
+  let basePrompt;
+  if (hasToolMessages(input)) {
+    const messages = buildHFTMessages(input);
+    const tools = selectHFTTools(input);
+    basePrompt = tokenizer.apply_chat_template(messages, {
+      tools,
+      tokenize: false,
+      add_generation_prompt: true
+    });
+  } else {
+    const messages = toTextFlatMessages(input);
+    const tools = resolveHFTToolsAndMessages(input, messages);
+    basePrompt = tokenizer.apply_chat_template(messages, {
+      tools,
+      tokenize: false,
+      add_generation_prompt: true
+    });
+  }
+  const responsePrefix = input.toolChoice === "none" || hasToolMessages(input) ? undefined : getGenerationPrefix(modelFamily, forcedToolSelection(input));
+  return {
+    prompt: responsePrefix ? `${basePrompt}${responsePrefix}` : basePrompt,
+    responsePrefix
+  };
+}
+var HFT_ToolCalling = async (input, model, onProgress, signal) => {
+  const generateText = await getPipeline(model, onProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const hfTokenizer = generateText.tokenizer;
+  const hfModel = generateText.model;
+  const streamer = createTextStreamer(hfTokenizer, onProgress, TextStreamer, signal);
+  const modelFamily = detectModelFamilyFromConfig(model);
+  const { prompt, responsePrefix } = buildPromptAndPrefix(hfTokenizer, input, modelFamily);
+  const inputs = hfTokenizer(prompt, { return_tensors: "pt" });
+  const output = await hfModel.generate({
+    ...inputs,
+    max_new_tokens: input.maxTokens ?? 1024,
+    streamer
+  });
+  const promptLen = inputs.input_ids.dims[1];
+  const seqLen = output.dims[1];
+  const newTokens = output.slice(0, [promptLen, seqLen], null);
+  const decoded = hfTokenizer.decode(newTokens, {
+    skip_special_tokens: false
+  });
+  const parseableText = responsePrefix ? `${responsePrefix}${decoded}` : decoded;
+  const { text, toolCalls } = adaptParserResult(parseToolCalls(parseableText, { parser: modelFamily }));
+  return {
+    text,
+    toolCalls: filterValidToolCalls(normalizeParsedToolCalls(input, toolCalls), input.tools)
+  };
+};
+var HFT_ToolCalling_Stream = async function* (input, model, signal) {
+  const noopProgress = () => {};
+  const generateText = await getPipeline(model, noopProgress, {}, signal);
+  const { TextStreamer } = await loadTransformersSDK();
+  const modelFamily = detectModelFamilyFromConfig(model);
+  const { prompt, responsePrefix } = buildPromptAndPrefix(generateText.tokenizer, input, modelFamily);
+  const innerQueue = createStreamEventQueue();
+  const outerQueue = createStreamEventQueue();
+  const streamer = createStreamingTextStreamer(generateText.tokenizer, innerQueue, TextStreamer, signal);
+  let fullText = "";
+  const filter = createToolCallMarkupFilter((text) => {
+    outerQueue.push({ type: "text-delta", port: "text", textDelta: text });
+  });
+  const originalPush = innerQueue.push;
+  innerQueue.push = (event) => {
+    if (event.type === "text-delta" && "textDelta" in event) {
+      fullText += event.textDelta;
+      filter.feed(event.textDelta);
+    } else {
+      outerQueue.push(event);
+    }
+    originalPush(event);
+  };
+  const originalDone = innerQueue.done;
+  innerQueue.done = () => {
+    filter.flush();
+    outerQueue.done();
+    originalDone();
+  };
+  const originalError = innerQueue.error;
+  innerQueue.error = (e) => {
+    filter.flush();
+    outerQueue.error(e);
+    originalError(e);
+  };
+  const pipelinePromise = generateText(prompt, {
+    max_new_tokens: input.maxTokens ?? 1024,
+    temperature: input.temperature ?? undefined,
+    return_full_text: false,
+    streamer
+  }).then(() => innerQueue.done(), (err) => innerQueue.error(err));
+  yield* outerQueue.iterable;
+  await pipelinePromise;
+  const parseableFullText = responsePrefix ? `${responsePrefix}${fullText}` : fullText;
+  const { text: cleanedText, toolCalls } = adaptParserResult(parseToolCalls(parseableFullText, { parser: modelFamily }));
+  const validToolCalls = filterValidToolCalls(normalizeParsedToolCalls(input, toolCalls), input.tools);
+  if (validToolCalls.length > 0) {
+    yield { type: "object-delta", port: "toolCalls", objectDelta: [...validToolCalls] };
+  }
+  yield {
+    type: "finish",
+    data: { text: cleanedText, toolCalls: validToolCalls }
+  };
+};
+
 // src/provider-hf-transformers/common/HFT_Unload.ts
 init_HFT_Pipeline();
 function hasBrowserCacheStorage() {
@@ -1555,6 +2785,7 @@ var HFT_TASKS = {
   ImageEmbeddingTask: HFT_ImageEmbedding,
   ImageClassificationTask: HFT_ImageClassification,
   ObjectDetectionTask: HFT_ObjectDetection,
+  ToolCallingTask: HFT_ToolCalling,
   StructuredGenerationTask: HFT_StructuredGeneration,
   ModelSearchTask: HFT_ModelSearch
 };
@@ -1564,6 +2795,7 @@ var HFT_STREAM_TASKS = {
   TextSummaryTask: HFT_TextSummary_Stream,
   TextQuestionAnswerTask: HFT_TextQuestionAnswer_Stream,
   TextTranslationTask: HFT_TextTranslation_Stream,
+  ToolCallingTask: HFT_ToolCalling_Stream,
   StructuredGenerationTask: HFT_StructuredGeneration_Stream
 };
 var HFT_REACTIVE_TASKS = {
@@ -1571,9 +2803,7 @@ var HFT_REACTIVE_TASKS = {
 };
 
 // src/provider-hf-transformers/HuggingFaceTransformersQueuedProvider.ts
-import {
-  QueuedAiProvider
-} from "@workglow/ai";
+import { QueuedAiProvider } from "@workglow/ai";
 var GPU_DEVICES = new Set(["webgpu", "gpu", "metal"]);
 var HFT_CPU_QUEUE_CONCURRENCY_PRODUCTION = 4;
 function hftIsAutomatedTestEnvironment() {
@@ -1623,6 +2853,7 @@ class HuggingFaceTransformersQueuedProvider extends QueuedAiProvider {
     "ImageEmbeddingTask",
     "ImageClassificationTask",
     "ObjectDetectionTask",
+    "ToolCallingTask",
     "ModelSearchTask"
   ];
   constructor(tasks, streamTasks, reactiveTasks) {
@@ -1658,9 +2889,7 @@ async function registerHuggingFaceTransformersInline(options) {
 import { getLogger as getLogger7, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
 
 // src/provider-hf-transformers/HuggingFaceTransformersProvider.ts
-import {
-  AiProvider
-} from "@workglow/ai/worker";
+import { AiProvider } from "@workglow/ai/worker";
 class HuggingFaceTransformersProvider extends AiProvider {
   name = HF_TRANSFORMERS_ONNX;
   displayName = "Hugging Face Transformers (ONNX)";
@@ -1687,6 +2916,7 @@ class HuggingFaceTransformersProvider extends AiProvider {
     "ImageEmbeddingTask",
     "ImageClassificationTask",
     "ObjectDetectionTask",
+    "ToolCallingTask",
     "ModelSearchTask"
   ];
   constructor(tasks, streamTasks, reactiveTasks) {
@@ -1719,6 +2949,7 @@ export {
   hasCachedPipeline,
   getPipelineCacheKey,
   getPipeline,
+  createToolCallMarkupFilter,
   clearPipelineCache,
   QuantizationDataType,
   PipelineUseCase,
@@ -1733,4 +2964,4 @@ export {
   HFT_NULL_PROCESSOR_PREFIX
 };
 
-//# debugId=569221876AC5558564756E2164756E21
+//# debugId=7D0C58F098156BAF64756E2164756E21