gnome-jarvis/vendor/agent-harness/lib/tool-parse.js

/**
 * Recover Qwen3.5 / Hermes tool calls that QVAC's stream framer misses.
 *
 * Compact Qwen3.5 models often emit <tool_call> inside <think>…</think>.
 * The SDK thinking framer swallows that XML, so the agent never runs a tool.
 * No Bare imports — unit-testable on Node.
 */

const FORMAT_REMINDER =
  'When you need a tool, close thinking first, then emit this XML (not JSON, not a spoken plan):\n' +
  '<tool_call>\n<function=TOOL_NAME>\n<parameter=ARG>value</parameter>\n</function>\n</tool_call>';

const ALIASES = {
  search: 'web_search',
  websearch: 'web_search',
  google: 'google_search',
  googlesearch: 'google_search',
  fetch: 'web_fetch',
  webfetch: 'web_fetch',
  fetchpage: 'fetch_page',
  open_url: 'fetch_page',
  openurl: 'fetch_page',
  shell: 'run_terminal_cmd',
  bash: 'run_terminal_cmd',
  terminal: 'run_terminal_cmd',
  cmd: 'run_terminal_cmd',
  read: 'read_file',
  cat: 'read_file',
  write: 'write_file',
  ls: 'list_dir',
  status: 'jarvis_status',
};

function knownNames(tools) {
  const names = new Set();
  for (const t of tools || []) {
    if (t && t.name) names.add(String(t.name));
    if (t && t.function && t.function.name) names.add(String(t.function.name));
  }
  return names;
}

function remapName(name, names) {
  const raw = String(name || '').trim();
  if (!raw) return raw;
  if (names.has(raw)) return raw;
  const folded = raw.toLowerCase().replace(/[\s-]+/g, '_');
  if (names.has(folded)) return folded;
  const alias = ALIASES[folded];
  if (alias && (names.size === 0 || names.has(alias))) return alias;
  return raw;
}

function parseJsonArgs(value) {
  if (value == null) return {};
  if (typeof value === 'object' && !Array.isArray(value)) return value;
  if (typeof value !== 'string') return { value };
  const trimmed = value.trim();
  if (!trimmed) return {};
  try {
    const parsed = JSON.parse(trimmed);
    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed;
    return { value: parsed };
  } catch (_) {
    return { value: trimmed };
  }
}

function parseQwenXmlInner(inner) {
  const calls = [];
  const fnRe = /<function\s*=\s*([^>\s]+)\s*>([\s\S]*?)<\/function>/gi;
  let fn;
  while ((fn = fnRe.exec(inner)) !== null) {
    const args = {};
    const paramRe = /<parameter\s*=\s*([^>\s]+)\s*>([\s\S]*?)<\/parameter>/gi;
    let pm;
    while ((pm = paramRe.exec(fn[2])) !== null) args[pm[1].trim()] = String(pm[2]).trim();
    if (!Object.keys(args).length) {
      const lineRe = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*[:=]\s*(.+?)\s*$/gm;
      let line;
      while ((line = lineRe.exec(fn[2])) !== null) args[line[1]] = line[2].trim();
    }
    calls.push({ name: fn[1].trim(), arguments: args });
  }
  if (calls.length) return calls;
  const openFn = /<function\s*=\s*([^>\s]+)\s*>([\s\S]*)$/i.exec(inner);
  if (openFn) {
    const args = {};
    const paramRe = /<parameter\s*=\s*([^>\s]+)\s*>([\s\S]*?)(?:<\/parameter>|$)/gi;
    let pm;
    while ((pm = paramRe.exec(openFn[2])) !== null) args[pm[1].trim()] = String(pm[2]).replace(/<\/parameter>\s*$/i, '').trim();
    return [{ name: openFn[1].trim(), arguments: args }];
  }
  return calls;
}

function parseHermesInner(inner) {
  const trimmed = String(inner || '').trim();
  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) return [];
  try {
    const parsed = JSON.parse(trimmed);
    const list = Array.isArray(parsed) ? parsed : [parsed];
    return list
      .map((obj) => {
        if (!obj || typeof obj !== 'object') return null;
        const name = obj.name || (obj.function && obj.function.name);
        if (!name) return null;
        const args = obj.arguments != null ? obj.arguments : obj.parameters != null ? obj.parameters : obj.args != null ? obj.args : (obj.function && obj.function.arguments);
        return { name: String(name), arguments: parseJsonArgs(args) };
      })
      .filter(Boolean);
  } catch (_) {
    return [];
  }
}

function extractFrames(text) {
  const src = String(text || '');
  const frames = [];
  const re = /<tool_call>([\s\S]*?)<\/tool_call>/gi;
  let m;
  while ((m = re.exec(src)) !== null) frames.push(m[1]);
  if (!frames.length) {
    const open = src.search(/<tool_call>/i);
    if (open >= 0) frames.push(src.slice(open + '<tool_call>'.length));
  }
  if (!frames.length && /<function\s*=/i.test(src)) frames.push(src);
  return frames;
}

function extractCalls(text, tools) {
  const names = knownNames(tools);
  const out = [];
  const seen = new Set();
  for (const frame of extractFrames(text)) {
    let parsed = parseQwenXmlInner(frame);
    if (!parsed.length) parsed = parseHermesInner(frame);
    for (const call of parsed) {
      const name = remapName(call.name, names);
      const args = call.arguments && typeof call.arguments === 'object' ? call.arguments : {};
      const key = name + ':' + JSON.stringify(args);
      if (seen.has(key)) continue;
      seen.add(key);
      out.push({ name, arguments: args });
    }
  }
  return out;
}

function stripToolMarkup(text) {
  return String(text || '')
    .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
    .replace(/<function\s*=[^>]*>[\s\S]*?<\/function>/gi, '')
    .replace(/<tool_call>[\s\S]*$/gi, '')
    .replace(/[ \t]+\n/g, '\n')
    .replace(/\n{3,}/g, '\n\n')
    .trim();
}

function recover({ text, thinking, tools, existing } = {}) {
  const spoken = stripToolMarkup(text);
  const have = Array.isArray(existing) && existing.length;
  const calls = have ? existing.slice() : extractCalls([thinking, text].filter(Boolean).join('\n'), tools);
  return { calls, text: spoken };
}

module.exports = {
  FORMAT_REMINDER,
  ALIASES,
  extractCalls,
  stripToolMarkup,
  recover,
  remapName,
};