@workglow/ai-provider 0.1.1 → 0.2.0

package/dist/test.js

@@ -0,0 +1,913 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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 };
+}
+export {
+  tryParseJson,
+  stripModelArtifacts,
+  parseXLAM,
+  parseToolCallsFromText,
+  parseToolCalls,
+  parseQwen35Xml,
+  parsePhiFunctools,
+  parsePhi,
+  parseNexusRaven,
+  parseMistral,
+  parseLlama,
+  parseLiquid,
+  parseKeyValueArgs,
+  parseJsonToolCallArray,
+  parseJamba,
+  parseInternLM,
+  parseHermes,
+  parseGranite,
+  parseGorilla,
+  parseGemma,
+  parseFunctionary,
+  parseFunctionGemmaLooseObject,
+  parseFunctionGemmaArgumentValue,
+  parseFunctionGemma,
+  parseFireFunction,
+  parseDeepSeek,
+  parseCohere,
+  parseChatGLM,
+  makeToolCall,
+  hasToolCalls,
+  getGenerationPrefix,
+  getAvailableParsers,
+  coerceArgValue
+};
+
+//# debugId=846853B19CC40B4B64756E2164756E21