Function extractFromMessage

src/tools/tool_call_extractor.js:57–163

* @param {object} message OpenAI-style choice.message; has .content + maybe .tool_calls * @param {Array} toolSchemas Same shape passed to the model: [{ function: { name, ... } }, ...] * @returns {{ patched: boolean, addedCalls: number }} * * Mutates `message` in place when extraction su

(message, toolSchemas)

 * Mutates `message` in place when extraction succeeds.
 */
function extractFromMessage(message, toolSchemas) {
  if (!message) return { patched: false, addedCalls: 0 };
  // Already has structured tool_calls — leave it alone.
  if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
    return { patched: false, addedCalls: 0 };
  }
  // Some local providers (LM Studio with Liquid AI lfm2.x, llama.cpp with
  // Qwen3 reasoning) split the response: visible text goes into `content`
  // and chain-of-thought goes into `reasoning_content`. When the budget is
  // tight the model can emit its tool call in reasoning_content and leave
  // content empty. Fall back to scanning reasoning_content if content is empty.
  const primary = typeof message.content === 'string' ? message.content : '';
  const fallback = typeof message.reasoning_content === 'string' ? message.reasoning_content : '';
  const content = primary && primary.trim().length > 0 ? primary : fallback;
  if (!content) return { patched: false, addedCalls: 0 };
  const usingReasoningFallback = content === fallback && content !== primary;

  const known = new Set();
  if (Array.isArray(toolSchemas)) {
    for (const t of toolSchemas) {
      const n = t?.function?.name || t?.name;
      if (typeof n === 'string') known.add(n);
    }
  }

  const calls = [];
  const consumedRanges = []; // [start, end) of content we transferred into tool_calls

  // 0. Liquid AI tool_call markers — `<|tool_call_start|>[func(kw=val)]<|tool_call_end|>`.
  //    Strongest signal when present; processed first so the rest of the
  //    pipeline doesn't try to interpret the Python-syntax payload as JSON.
  try {
    const { parseLiquidToolCalls } = require('./liquid_tool_parser');
    const { calls: liquidCalls, ranges: liquidRanges } = parseLiquidToolCalls(content);
    for (const c of liquidCalls) {
      if (known.size > 0 && !known.has(c.name)) continue;
      calls.push(c);
    }
    if (liquidCalls.length > 0) {
      for (const r of liquidRanges) consumedRanges.push(r);
    }
  } catch {}

  // 1. Tagged tool calls — strongest JSON-shaped signal.
  for (const m of content.matchAll(TOOL_CALL_TAG_RE)) {
    const parsed = _safeParseAny(m[1]);
    for (const tc of _normalize(parsed, known)) calls.push(tc);
    if (parsed) consumedRanges.push([m.index, m.index + m[0].length]);
  }

  // 2. Fenced JSON blocks. Skipped if we already got tagged calls.
  if (calls.length === 0) {
    for (const m of content.matchAll(FENCED_RE)) {
      const parsed = _safeParseAny(m[1]);
      const normalized = _normalize(parsed, known);
      if (normalized.length > 0) {
        for (const tc of normalized) calls.push(tc);
        consumedRanges.push([m.index, m.index + m[0].length]);