@workglow/ai 0.2.30 → 0.2.32

package/dist/provider-utils.js

@@ -0,0 +1,1247 @@
+// src/provider-utils/registerProvider.ts
+import { getLogger, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+async function registerProviderWorker(createAndRegister, providerName) {
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  createAndRegister(workerServer);
+  workerServer.sendReady();
+  getLogger().info(`${providerName} worker job run functions registered`);
+}
+async function registerProviderInline(provider, providerName, options) {
+  await provider.register(options ?? {});
+  getLogger().debug(`${providerName} inline job run functions registered`);
+}
+async function registerProviderWithWorker(provider, providerName, options) {
+  await provider.register(options);
+  getLogger().debug(`${providerName} worker main thread job run functions registered`);
+}
+// src/provider-utils/modelSearchQuery.ts
+function normalizedModelSearchQuery(query) {
+  const t = query?.trim();
+  return t ? t.toLowerCase() : undefined;
+}
+function filterLabeledModelsByQuery(models, query) {
+  const q = normalizedModelSearchQuery(query);
+  if (!q)
+    return [...models];
+  return models.filter((m) => m.value.toLowerCase().includes(q) || m.label.toLowerCase().includes(q) || m.description?.toLowerCase().includes(q));
+}
+function filterModelSearchResultsByQuery(results, query) {
+  const q = normalizedModelSearchQuery(query);
+  if (!q)
+    return results;
+  return results.filter((m) => m.id.toLowerCase().includes(q) || m.label.toLowerCase().includes(q) || m.description.toLowerCase().includes(q));
+}
+// src/provider-utils/ToolCallParsers.ts
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+function stripModelArtifacts(text) {
+  return text.replace(/<think>(?:[^<]|<(?!\/think>))*<\/think>/g, "").replace(/<\|[a-z_]+\|>/g, "").trim();
+}
+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 makeToolCall(name, args, id = null) {
+  return { name, arguments: args, id };
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    getLogger2().debug("ToolCallParsers tryParseJson failed", {
+      error: e.message,
+      textPrefix: text.slice(0, 120)
+    });
+    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 toolChoiceForcesToolCall(toolChoice) {
+  return toolChoice === "required" || toolChoice !== undefined && toolChoice !== "auto" && toolChoice !== "none";
+}
+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 resolveParsedToolName(name, input) {
+  if (input.tools.some((tool) => tool.name === name)) {
+    return name;
+  }
+  return forcedToolSelection(input) ?? name;
+}
+function adaptParserResult(result, input) {
+  return {
+    text: stripModelArtifacts(result.content),
+    toolCalls: result.tool_calls.map((call, index) => ({
+      id: call.id ?? `call_${index}`,
+      name: input ? resolveParsedToolName(call.name, input) : call.name,
+      input: call.arguments
+    }))
+  };
+}
+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 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],
+  gemma: [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,
+  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" };
+  }
+  const log = getLogger2();
+  let parsersToTry;
+  let source;
+  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;
+    source = `explicit parser "${key}"`;
+  } else {
+    const family = detectModelFamily(tokenizer ?? model ?? null);
+    if (family) {
+      parsersToTry = MODEL_PARSERS[family];
+      source = `model family "${family}"`;
+    } else {
+      parsersToTry = DEFAULT_PARSER_CHAIN;
+      source = "default chain (unknown model)";
+    }
+  }
+  log.debug("ToolCallParsers parseToolCalls", { source, parserCount: parsersToTry.length });
+  for (const parserFn of parsersToTry) {
+    const result = parserFn(text);
+    if (result) {
+      log.debug("ToolCallParsers parseToolCalls matched", {
+        parser: result.parser,
+        toolCallCount: result.tool_calls.length
+      });
+      return result;
+    }
+  }
+  log.debug("ToolCallParsers parseToolCalls no parser matched", {
+    source,
+    textPrefix: text.slice(0, 120)
+  });
+  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) {
+    default:
+      return;
+  }
+}
+function parseToolCallsFromText(responseText) {
+  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-utils/PipelineTaskMapping.ts
+var TASK_TO_PIPELINES = {
+  TextEmbeddingTask: ["feature-extraction"],
+  TextGenerationTask: ["text-generation"],
+  TextSummaryTask: ["sentence-similarity", "summarization"],
+  TextTranslationTask: ["translation"],
+  TextClassificationTask: ["text-classification", "zero-shot-classification"],
+  TextQuestionAnswerTask: ["question-answering"],
+  TextFillMaskTask: ["fill-mask"],
+  TextLanguageDetectionTask: ["text-classification"],
+  TextNamedEntityRecognitionTask: ["token-classification"],
+  TokenClassificationTask: ["token-classification"],
+  ImageClassificationTask: ["image-classification", "zero-shot-image-classification"],
+  ImageEmbeddingTask: ["image-feature-extraction"],
+  ImageSegmentationTask: ["image-segmentation"],
+  ImageToImageTask: ["image-to-image"],
+  ImageToTextTask: ["image-to-text"],
+  ObjectDetectionTask: ["object-detection", "zero-shot-object-detection"],
+  DepthEstimationTask: ["depth-estimation"],
+  AudioClassificationTask: ["audio-classification"],
+  SpeechRecognitionTask: ["automatic-speech-recognition"]
+};
+function taskTypeToPipeline(taskType) {
+  return TASK_TO_PIPELINES[taskType]?.[0];
+}
+function taskTypeToPipelines(taskType) {
+  return TASK_TO_PIPELINES[taskType] ?? [];
+}
+function pipelineToTaskTypes(pipeline) {
+  return Object.entries(TASK_TO_PIPELINES).filter(([, pipelines]) => pipelines.includes(pipeline)).map(([task]) => task);
+}
+
+// src/provider-utils/HfModelSearch.ts
+var HF_API_BASE = "https://huggingface.co/api";
+function formatDownloads(n) {
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}k`;
+  return String(n);
+}
+function mapHfProviderConfig(entry, provider) {
+  switch (provider) {
+    case "HF_TRANSFORMERS_ONNX":
+      return {
+        model_path: entry.id,
+        ...entry.pipeline_tag ? { pipeline: entry.pipeline_tag } : {}
+      };
+    case "LOCAL_LLAMACPP":
+      return { model_path: entry.id };
+    default:
+      return { model_name: entry.id };
+  }
+}
+function mapHfModelResult(entry, provider) {
+  const badges = [entry.pipeline_tag, entry.library_name].filter(Boolean).join(" | ");
+  return {
+    id: entry.id,
+    label: `${entry.id}${badges ? `  ${badges}` : ""}`,
+    description: `${formatDownloads(entry.downloads)} downloads`,
+    record: {
+      model_id: entry.id,
+      provider,
+      title: entry.id.split("/").pop() ?? entry.id,
+      description: [entry.pipeline_tag, `${formatDownloads(entry.downloads)} downloads`].filter(Boolean).join(" — "),
+      tasks: entry.pipeline_tag ? pipelineToTaskTypes(entry.pipeline_tag) : [],
+      provider_config: mapHfProviderConfig(entry, provider),
+      metadata: {}
+    },
+    raw: entry
+  };
+}
+async function searchHfModels(query, extraParams, expandFields, signal, credentialKey) {
+  const params = new URLSearchParams({
+    search: query,
+    limit: "500",
+    sort: "downloads",
+    direction: "-1",
+    ...extraParams
+  });
+  params.append("expand[]", "pipeline_tag");
+  if (expandFields) {
+    for (const field of expandFields) {
+      params.append("expand[]", field);
+    }
+  }
+  const res = await fetch(`${HF_API_BASE}/models?${params}`, {
+    signal,
+    headers: credentialKey ? { Authorization: `Bearer ${credentialKey}` } : undefined
+  });
+  if (!res.ok)
+    throw new Error(`HuggingFace API returned ${res.status}`);
+  return res.json();
+}
+// src/provider-utils/imageOutputHelpers.ts
+import {
+  encodeRawPixels,
+  imageValueFromBitmap,
+  imageValueFromBuffer,
+  probeImageDimensions
+} from "@workglow/util/media";
+var HAS_BUFFER = typeof Buffer !== "undefined";
+var HAS_CREATE_IMAGE_BITMAP = typeof createImageBitmap === "function" && typeof fetch === "function";
+var PREFER_BROWSER = HAS_CREATE_IMAGE_BITMAP;
+function detectFormatFromMime(mime) {
+  if (/jpe?g/i.test(mime))
+    return "jpeg";
+  return "png";
+}
+async function pngBytesToImageValue(bytes, format = "png") {
+  const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const { width, height } = await probeImageDimensions(buffer);
+  return imageValueFromBuffer(buffer, format, width, height);
+}
+async function dataUriToImageValue(dataUri) {
+  const match = /^data:([^;,]+);base64,(.+)$/.exec(dataUri);
+  if (!match) {
+    const preview = dataUri.length > 32 ? `${dataUri.slice(0, 32)}...` : dataUri;
+    throw new Error(`dataUriToImageValue: invalid data URI "${preview}"`);
+  }
+  const mime = match[1];
+  const base64 = match[2];
+  if (PREFER_BROWSER) {
+    const blob = await (await fetch(dataUri)).blob();
+    const bitmap = await createImageBitmap(blob);
+    return imageValueFromBitmap(bitmap, bitmap.width, bitmap.height);
+  }
+  if (HAS_BUFFER) {
+    const buffer = Buffer.from(base64, "base64");
+    return pngBytesToImageValue(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength), detectFormatFromMime(mime));
+  }
+  throw new Error("dataUriToImageValue: no Buffer or createImageBitmap available in this runtime");
+}
+async function blobToImageValue(blob) {
+  if (PREFER_BROWSER) {
+    const bitmap = await createImageBitmap(blob);
+    return imageValueFromBitmap(bitmap, bitmap.width, bitmap.height);
+  }
+  if (HAS_BUFFER) {
+    const arrayBuffer = await blob.arrayBuffer();
+    const bytes = new Uint8Array(arrayBuffer);
+    return pngBytesToImageValue(bytes, detectFormatFromMime(blob.type || "image/png"));
+  }
+  throw new Error("blobToImageValue: no Buffer or createImageBitmap available in this runtime");
+}
+async function imageValueToPngBytes(image) {
+  if (typeof image === "string") {
+    const match = /^data:[^;,]+;base64,(.+)$/.exec(image);
+    if (!match) {
+      const preview = image.length > 32 ? `${image.slice(0, 32)}...` : image;
+      throw new Error(`imageValueToPngBytes: invalid data URI "${preview}"`);
+    }
+    if (typeof Buffer !== "undefined") {
+      const buf = Buffer.from(match[1], "base64");
+      return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    const bin = atob(match[1]);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0;i < bin.length; i++)
+      bytes[i] = bin.charCodeAt(i);
+    return bytes;
+  }
+  if (image && typeof image === "object") {
+    const node = image;
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(node.buffer) && typeof node.format === "string") {
+      if (node.format === "png" || node.format === "jpeg") {
+        return new Uint8Array(node.buffer.buffer, node.buffer.byteOffset, node.buffer.byteLength);
+      }
+      if (node.format === "raw-rgba" && typeof node.width === "number" && typeof node.height === "number") {
+        const out = await encodeRawPixels({ data: node.buffer, width: node.width, height: node.height, channels: 4 }, { format: "png" });
+        return new Uint8Array(out.buffer, out.byteOffset, out.byteLength);
+      }
+    }
+    const browser = image;
+    if (typeof ImageBitmap !== "undefined" && browser.bitmap instanceof ImageBitmap && typeof browser.width === "number" && typeof browser.height === "number") {
+      return await encodeBitmapToPngBytes(browser.bitmap, browser.width, browser.height);
+    }
+  }
+  throw new Error("imageValueToPngBytes: unsupported image input shape");
+}
+async function imageValueToBlob(image) {
+  const bytes = await imageValueToPngBytes(image);
+  return new Blob([bytes], { type: "image/png" });
+}
+async function encodeBitmapToPngBytes(bitmap, width, height) {
+  if (typeof OffscreenCanvas !== "undefined") {
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx)
+      throw new Error("encodeBitmapToPngBytes: 2d context unavailable");
+    ctx.drawImage(bitmap, 0, 0);
+    const blob = await canvas.convertToBlob({ type: "image/png" });
+    const arrayBuffer = await blob.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  }
+  throw new Error("encodeBitmapToPngBytes: OffscreenCanvas not available in this runtime");
+}
+// src/provider-utils/BaseCloudProvider.ts
+function createCloudProviderClass(Base, meta) {
+  class CloudProvider extends Base {
+    name = meta.name;
+    displayName = meta.displayName;
+    isLocal = meta.isLocal ?? false;
+    supportsBrowser = meta.supportsBrowser ?? true;
+    taskTypes = meta.taskTypes;
+  }
+  return CloudProvider;
+}
+// src/provider-utils/CloudProviderClient.ts
+function resolveApiKey(args) {
+  const fromConfig = args.config?.credential_key || args.config?.api_key;
+  if (fromConfig)
+    return fromConfig;
+  const envVars = typeof args.envVar === "string" ? [args.envVar] : args.envVar;
+  if (typeof process !== "undefined") {
+    for (const name of envVars) {
+      const v = process.env?.[name];
+      if (v)
+        return v;
+    }
+  }
+  const envList = envVars.join(" / ");
+  throw new Error(`Missing ${args.providerLabel} API key: set provider_config.credential_key or the ${envList} environment variable.`);
+}
+async function loadProviderSdk(packageName, friendlyName) {
+  try {
+    return await import(packageName);
+  } catch {
+    const label = friendlyName ?? packageName;
+    throw new Error(`${packageName} is required for ${label} tasks. Install it with: bun add ${packageName}`);
+  }
+}
+function isBrowserLike() {
+  return typeof globalThis.document !== "undefined" || "WorkerGlobalScope" in globalThis;
+}
+// src/task/ToolCallingUtils.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+function buildToolDescription(tool) {
+  let desc = tool.description;
+  if (tool.outputSchema && typeof tool.outputSchema === "object") {
+    desc += `
+
+Returns: ${JSON.stringify(tool.outputSchema)}`;
+  }
+  return desc;
+}
+
+// src/provider-utils/OpenAIShapedChat.ts
+import { parsePartialJson } from "@workglow/util/worker";
+function buildOpenAITools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: buildToolDescription(t),
+      parameters: t.inputSchema
+    }
+  }));
+}
+function mapOpenAIToolChoice(toolChoice, allowNamedFunction) {
+  if (!toolChoice || toolChoice === "auto")
+    return "auto";
+  if (toolChoice === "none")
+    return "none";
+  if (toolChoice === "required")
+    return "required";
+  if (allowNamedFunction)
+    return { type: "function", function: { name: toolChoice } };
+  return "auto";
+}
+function parseToolArgs(raw) {
+  if (!raw)
+    return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const partial = parsePartialJson(raw);
+    return partial && typeof partial === "object" ? partial : {};
+  }
+}
+function parseOpenAIToolCallMessage(toolCallsRaw) {
+  const result = [];
+  if (!toolCallsRaw)
+    return result;
+  let idx = 0;
+  for (const tc of toolCallsRaw) {
+    if (!tc || !tc.function) {
+      idx++;
+      continue;
+    }
+    const id = tc.id ?? `call_${idx}`;
+    const name = tc.function.name;
+    const rawArgs = tc.function.arguments;
+    const input = typeof rawArgs === "string" ? parseToolArgs(rawArgs) : rawArgs && typeof rawArgs === "object" ? rawArgs : {};
+    result.push({ id, name, input });
+    idx++;
+  }
+  return result;
+}
+async function* accumulateOpenAIStream(stream) {
+  const toolCallAccumulator = new Map;
+  for await (const chunk of stream) {
+    const choice = chunk?.choices?.[0];
+    if (!choice)
+      continue;
+    const contentDelta = choice.delta?.content ?? "";
+    if (contentDelta) {
+      yield { type: "text-delta", port: "text", textDelta: contentDelta };
+    }
+    const tcDeltas = choice.delta?.tool_calls;
+    if (!Array.isArray(tcDeltas))
+      continue;
+    for (const tcDelta of tcDeltas) {
+      const idx = tcDelta.index ?? 0;
+      let acc = toolCallAccumulator.get(idx);
+      if (!acc) {
+        acc = { id: tcDelta.id ?? "", name: tcDelta.function?.name ?? "", arguments: "" };
+        toolCallAccumulator.set(idx, acc);
+      }
+      if (tcDelta.id)
+        acc.id = tcDelta.id;
+      if (tcDelta.function?.name)
+        acc.name = tcDelta.function.name;
+      if (tcDelta.function?.arguments)
+        acc.arguments += tcDelta.function.arguments;
+      const stableId = acc.id || `call_${idx}`;
+      yield {
+        type: "object-delta",
+        port: "toolCalls",
+        objectDelta: [{ id: stableId, name: acc.name, input: parseToolArgs(acc.arguments) }]
+      };
+    }
+  }
+  yield {
+    type: "finish",
+    data: { text: "", toolCalls: [] }
+  };
+}
+export {
+  tryParseJson,
+  toolChoiceForcesToolCall,
+  taskTypeToPipelines,
+  taskTypeToPipeline,
+  stripModelArtifacts,
+  searchHfModels,
+  resolveParsedToolName,
+  resolveApiKey,
+  registerProviderWorker,
+  registerProviderWithWorker,
+  registerProviderInline,
+  pngBytesToImageValue,
+  pipelineToTaskTypes,
+  parseXLAM,
+  parseToolCallsFromText,
+  parseToolCalls,
+  parseQwen35Xml,
+  parsePhiFunctools,
+  parsePhi,
+  parseOpenAIToolCallMessage,
+  parseNexusRaven,
+  parseMistral,
+  parseLlama,
+  parseLiquid,
+  parseKeyValueArgs,
+  parseJsonToolCallArray,
+  parseJamba,
+  parseInternLM,
+  parseHermes,
+  parseGranite,
+  parseGorilla,
+  parseGemma,
+  parseFunctionary,
+  parseFireFunction,
+  parseDeepSeek,
+  parseCohere,
+  parseChatGLM,
+  normalizedModelSearchQuery,
+  mapOpenAIToolChoice,
+  mapHfProviderConfig,
+  mapHfModelResult,
+  makeToolCall,
+  loadProviderSdk,
+  isBrowserLike,
+  imageValueToPngBytes,
+  imageValueToBlob,
+  hasToolCalls,
+  getGenerationPrefix,
+  getAvailableParsers,
+  formatDownloads,
+  forcedToolSelection,
+  filterModelSearchResultsByQuery,
+  filterLabeledModelsByQuery,
+  extractMessageText,
+  dataUriToImageValue,
+  createCloudProviderClass,
+  coerceArgValue,
+  buildOpenAITools,
+  blobToImageValue,
+  adaptParserResult,
+  accumulateOpenAIStream
+};
+
+//# debugId=4EDF5B6BCACE26D464756E2164756E21