@cohortapp/agent-sdk 2.3.0

package/lib/model-router/repair.mjs

@@ -0,0 +1,471 @@
+/**
+ * lib/model-router/repair.mjs — tool-call leakage repair for cheap models.
+ *
+ * Cheap / weaker models routed through the direct-api path (`llm-task.mjs`) and,
+ * occasionally, the session path do not always emit native `tool_use` blocks.
+ * They leak the tool call as *plain text* instead: a fenced ```json block, a
+ * bare JSON object, an OpenAI-style `tool_calls` array echoed into the content,
+ * an XML-ish `<function_call>…</function_call>` wrapper, or a `Action:` /
+ * `Tool: name\nArgs: {…}` ReAct transcript. This module promotes that leakage
+ * back into the structured `tool_use` block shape the rest of maestro expects,
+ * so a grade-B model's output can be treated uniformly with a grade-A model's.
+ *
+ * This is the OpenClaw "tool-call-repair" concept ported to maestro: pure,
+ * total (never throws), and exhaustively tested against representative
+ * cheap-model outputs. It does NOT execute anything — it only RESHAPES text
+ * into the canonical tool_use block(s) + the residual assistant prose.
+ *
+ * Canonical output block (Anthropic content-block shape):
+ *   { type: "tool_use", id, name, input }
+ * Residual prose (anything outside the promoted calls):
+ *   { type: "text", text }
+ *
+ * `repairToolCalls(textOrMessage, opts) -> {
+ *    repaired: boolean,            // true iff ≥1 tool call was promoted
+ *    content: Array<ContentBlock>, // text + tool_use blocks, in source order
+ *    toolCalls: Array<{id,name,input}>,
+ *    text: string,                 // the residual prose (calls stripped)
+ *    source: "native"|"fenced_json"|"bare_json"|"openai_tool_calls"|
+ *            "xml_function"|"react"|"none",
+ *  }`
+ *
+ * House style: ESM .mjs, Node built-ins only (zero deps), pure, never throws.
+ *
+ * @module lib/model-router/repair
+ */
+
+let _idCounter = 0;
+/** Deterministic-ish synthetic id for a promoted call (injectable rng/seq). */
+function synthId(opts, name) {
+  if (opts && typeof opts.idFor === "function") {
+    const v = opts.idFor(name);
+    if (typeof v === "string" && v) return v;
+  }
+  const seq = ++_idCounter;
+  return `repair_${(name || "tool").replace(/[^a-zA-Z0-9_-]/g, "")}_${seq}`;
+}
+
+/** Coerce an arbitrary input field into a plain object (parse a JSON string). */
+function coerceInput(raw) {
+  if (raw == null) return {};
+  if (typeof raw === "object" && !Array.isArray(raw)) return raw;
+  if (Array.isArray(raw)) return { _args: raw };
+  if (typeof raw === "string") {
+    const s = raw.trim();
+    if (!s) return {};
+    const parsed = tryParseJson(s);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    return { _raw: raw };
+  }
+  return { _value: raw };
+}
+
+/** JSON.parse that never throws; returns undefined on failure. */
+function tryParseJson(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Strip a single leading ```lang fence and the trailing ``` from a block, if
+ * present. Returns { lang, body } — body is the inner text (untrimmed at edges
+ * removed). When no fence, returns { lang: null, body: original }.
+ */
+function stripFence(text) {
+  const m = /^\s*```([a-zA-Z0-9_-]*)\s*\n([\s\S]*?)\n?\s*```\s*$/.exec(text);
+  if (!m) return { lang: null, body: text };
+  return { lang: (m[1] || "").toLowerCase() || null, body: m[2] };
+}
+
+/**
+ * Find ALL fenced code blocks in a blob, returning their spans + inner bodies.
+ * Used to lift fenced ```json tool calls out of surrounding prose.
+ */
+function findFences(text) {
+  const out = [];
+  const re = /```([a-zA-Z0-9_-]*)\s*\n([\s\S]*?)```/g;
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    out.push({
+      start: m.index,
+      end: m.index + m[0].length,
+      lang: (m[1] || "").toLowerCase() || null,
+      body: m[2],
+    });
+  }
+  return out;
+}
+
+/**
+ * Recognize a parsed JSON object as a tool call. Accepts the common shapes:
+ *   { name, input }                 (anthropic-ish)
+ *   { name, arguments }             (openai-ish, arguments may be a JSON string)
+ *   { tool, parameters|args|input } (assorted cheap-model conventions)
+ *   { function: { name, arguments } }  (openai function wrapper)
+ * Returns { name, input } or null.
+ */
+function asToolCall(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) return null;
+
+  // OpenAI function wrapper: { type:"function", function:{ name, arguments } }
+  if (obj.function && typeof obj.function === "object") {
+    const f = obj.function;
+    if (typeof f.name === "string" && f.name) {
+      return { name: f.name, input: coerceInput(f.arguments ?? f.parameters ?? f.input) };
+    }
+  }
+
+  const name =
+    (typeof obj.name === "string" && obj.name) ||
+    (typeof obj.tool === "string" && obj.tool) ||
+    (typeof obj.tool_name === "string" && obj.tool_name) ||
+    (typeof obj.function_name === "string" && obj.function_name) ||
+    null;
+  if (!name) return null;
+
+  const inputRaw =
+    obj.input !== undefined
+      ? obj.input
+      : obj.arguments !== undefined
+        ? obj.arguments
+        : obj.parameters !== undefined
+          ? obj.parameters
+          : obj.args !== undefined
+            ? obj.args
+            : {};
+  return { name, input: coerceInput(inputRaw) };
+}
+
+/**
+ * Promote an OpenAI-style `tool_calls` array (echoed into content) into our
+ * canonical calls. Each entry is `{ id?, type:"function", function:{name,arguments} }`.
+ */
+function fromOpenAiToolCalls(arr, opts) {
+  const calls = [];
+  for (const entry of arr) {
+    if (!entry || typeof entry !== "object") continue;
+    const tc = asToolCall(entry);
+    if (!tc) continue;
+    calls.push({
+      id: typeof entry.id === "string" && entry.id ? entry.id : synthId(opts, tc.name),
+      name: tc.name,
+      input: tc.input,
+    });
+  }
+  return calls;
+}
+
+// ---------------------------------------------------------------------------
+// XML-ish <function_call>…</function_call> / <tool_call>…</tool_call>
+// ---------------------------------------------------------------------------
+
+const XML_CALL_RE =
+  /<(function_call|tool_call|tool[_-]?use)\b[^>]*>([\s\S]*?)<\/\1>/gi;
+
+/**
+ * Extract XML-wrapped tool calls. The inner body is usually JSON (`{name,…}`)
+ * but may be `<name>…</name><arguments>…</arguments>` sub-tags. Returns the
+ * promoted calls + a stripper that removes the matched spans from the prose.
+ */
+function fromXmlCalls(text, opts) {
+  const calls = [];
+  const spans = [];
+  let m;
+  XML_CALL_RE.lastIndex = 0;
+  while ((m = XML_CALL_RE.exec(text)) !== null) {
+    const body = m[2] || "";
+    let call = null;
+    const parsed = tryParseJson(body.trim());
+    if (parsed) call = asToolCall(parsed);
+    if (!call) {
+      const nameM = /<(?:name|tool|function)>\s*([\s\S]*?)\s*<\/(?:name|tool|function)>/i.exec(body);
+      const argsM =
+        /<(?:arguments|args|parameters|input)>\s*([\s\S]*?)\s*<\/(?:arguments|args|parameters|input)>/i.exec(
+          body
+        );
+      if (nameM && nameM[1].trim()) {
+        call = { name: nameM[1].trim(), input: coerceInput(argsM ? argsM[1] : {}) };
+      }
+    }
+    if (call) {
+      calls.push({ id: synthId(opts, call.name), name: call.name, input: call.input });
+      spans.push({ start: m.index, end: m.index + m[0].length });
+    }
+  }
+  return { calls, spans };
+}
+
+// ---------------------------------------------------------------------------
+// ReAct / "Action:" transcript style
+//   Action: tool_name
+//   Action Input: { ... }
+// or
+//   Tool: tool_name
+//   Args: { ... }
+// ---------------------------------------------------------------------------
+
+const REACT_RE =
+  /(?:^|\n)[ \t]*(?:Action|Tool|Tool Call|Function)\s*:?[ \t]*([A-Za-z0-9_.\-]+)[ \t]*\n[ \t]*(?:Action Input|Args|Arguments|Parameters|Input)\s*:?[ \t]*(\{[\s\S]*?\}|\[[\s\S]*?\])/gi;
+
+function fromReact(text, opts) {
+  const calls = [];
+  const spans = [];
+  let m;
+  REACT_RE.lastIndex = 0;
+  while ((m = REACT_RE.exec(text)) !== null) {
+    const name = m[1].trim();
+    const argsText = m[2];
+    const parsed = tryParseJson(argsText);
+    const input = parsed != null ? coerceInput(parsed) : coerceInput(argsText);
+    calls.push({ id: synthId(opts, name), name, input });
+    // Span starts at the matched Action keyword (skip a leading newline if any).
+    const lead = m[0].startsWith("\n") ? 1 : 0;
+    spans.push({ start: m.index + lead, end: m.index + m[0].length });
+  }
+  return { calls, spans };
+}
+
+// ---------------------------------------------------------------------------
+// Span removal → residual prose
+// ---------------------------------------------------------------------------
+
+function removeSpans(text, spans) {
+  if (!spans.length) return text;
+  const sorted = [...spans].sort((a, b) => a.start - b.start);
+  let out = "";
+  let cursor = 0;
+  for (const s of sorted) {
+    if (s.start < cursor) continue; // overlapping — skip
+    out += text.slice(cursor, s.start);
+    cursor = s.end;
+  }
+  out += text.slice(cursor);
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// Native content normalization (already-structured input)
+// ---------------------------------------------------------------------------
+
+/**
+ * Normalize an already-structured message/content array. When the input is a
+ * provider message with `content: [...]`, we pass native tool_use blocks
+ * through unchanged and only repair any leaked text blocks within. When the
+ * input has top-level OpenAI `tool_calls`, promote them.
+ */
+function fromStructured(message, opts) {
+  // Top-level OpenAI tool_calls on a chat message.
+  if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
+    const calls = fromOpenAiToolCalls(message.tool_calls, opts);
+    if (calls.length) {
+      const text = typeof message.content === "string" ? message.content : "";
+      const content = [];
+      if (text.trim()) content.push({ type: "text", text });
+      for (const c of calls) content.push({ type: "tool_use", id: c.id, name: c.name, input: c.input });
+      return { repaired: true, content, toolCalls: calls, text, source: "openai_tool_calls" };
+    }
+  }
+
+  const blocks = Array.isArray(message.content) ? message.content : null;
+  if (!blocks) return null;
+
+  // Already has native tool_use blocks → repair text blocks only, keep order.
+  const outContent = [];
+  const toolCalls = [];
+  let repaired = false;
+  let sawNative = false;
+  const proseParts = [];
+  for (const b of blocks) {
+    if (b && b.type === "tool_use") {
+      sawNative = true;
+      outContent.push(b);
+      toolCalls.push({ id: b.id, name: b.name, input: b.input });
+      continue;
+    }
+    if (b && b.type === "text" && typeof b.text === "string") {
+      const inner = repairToolCalls(b.text, opts);
+      if (inner.repaired) {
+        repaired = true;
+        for (const blk of inner.content) {
+          outContent.push(blk);
+          if (blk.type === "tool_use") toolCalls.push({ id: blk.id, name: blk.name, input: blk.input });
+        }
+        if (inner.text.trim()) proseParts.push(inner.text);
+      } else {
+        outContent.push(b);
+        proseParts.push(b.text);
+      }
+      continue;
+    }
+    outContent.push(b);
+  }
+  if (!sawNative && !repaired) return null; // nothing structured to report
+  return {
+    repaired: repaired || sawNative,
+    content: outContent,
+    toolCalls,
+    text: proseParts.join("\n").trim(),
+    source: repaired ? "fenced_json" : "native",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+
+/**
+ * Promote plain-text / JSON / XML / ReAct tool-call leakage into native
+ * tool_use blocks. Accepts either a raw string (model text) or a message
+ * object (`{ content: string | block[], tool_calls? }`). Pure; never throws.
+ *
+ * @param {string|object} input
+ * @param {object} [opts]
+ *   @param {(name:string)=>string} [opts.idFor]  synthetic-id generator (tests)
+ * @returns {{repaired,content,toolCalls,text,source}}
+ */
+export function repairToolCalls(input, opts = {}) {
+  // Structured message first.
+  if (input && typeof input === "object") {
+    const structured = fromStructured(input, opts);
+    if (structured) return structured;
+    // A message object with only string content → repair that string.
+    if (typeof input.content === "string") return repairToolCalls(input.content, opts);
+    return { repaired: false, content: [], toolCalls: [], text: "", source: "none" };
+  }
+
+  if (typeof input !== "string") {
+    return { repaired: false, content: [], toolCalls: [], text: "", source: "none" };
+  }
+
+  const text = input;
+
+  // 1. Whole-string is a single fenced or bare JSON tool call / array.
+  const whole = stripFence(text);
+  if (whole.lang === "json" || whole.lang === null || whole.lang === "tool_code" || whole.lang === "javascript") {
+    const parsed = tryParseJson(whole.body.trim());
+    if (parsed !== undefined) {
+      // OpenAI top-level { tool_calls:[...] }
+      if (parsed && typeof parsed === "object" && Array.isArray(parsed.tool_calls)) {
+        const calls = fromOpenAiToolCalls(parsed.tool_calls, opts);
+        if (calls.length) {
+          return {
+            repaired: true,
+            content: calls.map((c) => ({ type: "tool_use", id: c.id, name: c.name, input: c.input })),
+            toolCalls: calls,
+            text: "",
+            source: "openai_tool_calls",
+          };
+        }
+      }
+      // Array of calls.
+      if (Array.isArray(parsed)) {
+        const calls = [];
+        for (const e of parsed) {
+          const tc = asToolCall(e);
+          if (tc) calls.push({ id: synthId(opts, tc.name), name: tc.name, input: tc.input });
+        }
+        if (calls.length) {
+          return {
+            repaired: true,
+            content: calls.map((c) => ({ type: "tool_use", id: c.id, name: c.name, input: c.input })),
+            toolCalls: calls,
+            text: "",
+            source: whole.lang ? "fenced_json" : "bare_json",
+          };
+        }
+      }
+      // Single call object.
+      const tc = asToolCall(parsed);
+      if (tc) {
+        const id = synthId(opts, tc.name);
+        return {
+          repaired: true,
+          content: [{ type: "tool_use", id, name: tc.name, input: tc.input }],
+          toolCalls: [{ id, name: tc.name, input: tc.input }],
+          text: "",
+          source: whole.lang ? "fenced_json" : "bare_json",
+        };
+      }
+    }
+  }
+
+  // 2. Mixed prose: lift fenced ```json tool-call blocks out of surrounding text.
+  const calls = [];
+  const spans = [];
+  let source = null;
+  for (const fence of findFences(text)) {
+    if (fence.lang && fence.lang !== "json" && fence.lang !== "tool_code") continue;
+    const parsed = tryParseJson(fence.body.trim());
+    if (parsed === undefined) continue;
+    let any = false;
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.tool_calls)) {
+      for (const c of fromOpenAiToolCalls(parsed.tool_calls, opts)) {
+        calls.push(c);
+        any = true;
+      }
+      if (any) source = source || "openai_tool_calls";
+    } else if (Array.isArray(parsed)) {
+      for (const e of parsed) {
+        const tc = asToolCall(e);
+        if (tc) {
+          calls.push({ id: synthId(opts, tc.name), name: tc.name, input: tc.input });
+          any = true;
+        }
+      }
+    } else {
+      const tc = asToolCall(parsed);
+      if (tc) {
+        calls.push({ id: synthId(opts, tc.name), name: tc.name, input: tc.input });
+        any = true;
+      }
+    }
+    if (any) {
+      spans.push({ start: fence.start, end: fence.end });
+      source = source || "fenced_json";
+    }
+  }
+
+  // 3. XML-wrapped calls.
+  const xml = fromXmlCalls(text, opts);
+  for (const c of xml.calls) calls.push(c);
+  for (const s of xml.spans) spans.push(s);
+  if (xml.calls.length) source = source || "xml_function";
+
+  // 4. ReAct "Action:/Args:" transcript — only if nothing structured matched
+  //    (avoid double-counting JSON already lifted from a fence).
+  if (!calls.length) {
+    const react = fromReact(text, opts);
+    for (const c of react.calls) calls.push(c);
+    for (const s of react.spans) spans.push(s);
+    if (react.calls.length) source = "react";
+  }
+
+  if (!calls.length) {
+    return { repaired: false, content: [{ type: "text", text }], toolCalls: [], text, source: "none" };
+  }
+
+  // Build ordered content: prose before/after each promoted span, calls inline.
+  const residual = removeSpans(text, spans).trim();
+  const content = [];
+  if (residual) content.push({ type: "text", text: residual });
+  for (const c of calls) content.push({ type: "tool_use", id: c.id, name: c.name, input: c.input });
+
+  return { repaired: true, content, toolCalls: calls, text: residual, source: source || "none" };
+}
+
+export const _internals = {
+  asToolCall,
+  coerceInput,
+  stripFence,
+  findFences,
+  fromOpenAiToolCalls,
+  fromXmlCalls,
+  fromReact,
+  removeSpans,
+  tryParseJson,
+};
+
+export default { repairToolCalls };

package/lib/model-router/repair.test.mjs

@@ -0,0 +1,180 @@
+/**
+ * lib/model-router/repair.test.mjs — tool-call-leakage repair golden cases.
+ *
+ * Representative cheap-model outputs that leak a tool call as text instead of a
+ * native tool_use block, asserting repairToolCalls promotes each into the
+ * canonical { type:"tool_use", id, name, input } shape with the residual prose
+ * preserved. Pure, hermetic, no fs/network. House style: node:test.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { repairToolCalls, _internals } from "./repair.mjs";
+
+// Deterministic ids so we can assert exact output.
+const idFor = (name) => `id_${name}`;
+
+test("fenced ```json single tool call → tool_use block", () => {
+  const text = '```json\n{ "name": "get_weather", "input": { "city": "Dubai" } }\n```';
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.source, "fenced_json");
+  assert.equal(r.toolCalls.length, 1);
+  assert.deepEqual(r.toolCalls[0], { id: "id_get_weather", name: "get_weather", input: { city: "Dubai" } });
+  assert.deepEqual(r.content, [
+    { type: "tool_use", id: "id_get_weather", name: "get_weather", input: { city: "Dubai" } },
+  ]);
+  assert.equal(r.text, "");
+});
+
+test("bare JSON object (no fence) with arguments-as-string → parsed input", () => {
+  const text = '{"name":"search","arguments":"{\\"q\\":\\"router\\"}"}';
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.source, "bare_json");
+  assert.deepEqual(r.toolCalls[0].input, { q: "router" });
+});
+
+test("OpenAI tool_calls array echoed into content → promoted with ids", () => {
+  const msg = {
+    content: "Let me look that up.",
+    tool_calls: [
+      { id: "call_abc", type: "function", function: { name: "lookup", arguments: '{"id":7}' } },
+    ],
+  };
+  const r = repairToolCalls(msg, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.source, "openai_tool_calls");
+  assert.equal(r.toolCalls[0].id, "call_abc"); // preserves provider id
+  assert.deepEqual(r.toolCalls[0].input, { id: 7 });
+  // Prose text precedes the tool_use block.
+  assert.equal(r.content[0].type, "text");
+  assert.equal(r.content[1].type, "tool_use");
+});
+
+test("top-level { tool_calls: [...] } JSON string → promoted", () => {
+  const text = JSON.stringify({
+    tool_calls: [{ function: { name: "send", arguments: { to: "x" } } }],
+  });
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.source, "openai_tool_calls");
+  assert.deepEqual(r.toolCalls[0].input, { to: "x" });
+});
+
+test("XML <function_call> wrapper with JSON body → tool_use", () => {
+  const text =
+    'Sure.\n<function_call>{"name": "create_ticket", "input": {"title": "bug"}}</function_call>\nDone.';
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.source, "xml_function");
+  assert.equal(r.toolCalls[0].name, "create_ticket");
+  assert.deepEqual(r.toolCalls[0].input, { title: "bug" });
+  // Residual prose keeps the surrounding sentences (calls stripped).
+  assert.match(r.text, /Sure\./);
+  assert.match(r.text, /Done\./);
+});
+
+test("XML <tool_call> with <name>/<arguments> sub-tags → tool_use", () => {
+  const text =
+    "<tool_call><name>list_files</name><arguments>{\"dir\":\"/tmp\"}</arguments></tool_call>";
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.toolCalls[0].name, "list_files");
+  assert.deepEqual(r.toolCalls[0].input, { dir: "/tmp" });
+});
+
+test("ReAct Action:/Action Input: transcript → tool_use", () => {
+  const text = "Thought: I should search.\nAction: web_search\nAction Input: {\"query\": \"maestro\"}";
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.source, "react");
+  assert.equal(r.toolCalls[0].name, "web_search");
+  assert.deepEqual(r.toolCalls[0].input, { query: "maestro" });
+  assert.match(r.text, /Thought: I should search\./);
+});
+
+test("ReAct Tool:/Args: alternate keywords → tool_use", () => {
+  const text = "Tool: fetch_url\nArgs: { \"url\": \"https://x\" }";
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.toolCalls[0].name, "fetch_url");
+  assert.deepEqual(r.toolCalls[0].input, { url: "https://x" });
+});
+
+test("array of tool calls in one fence → multiple tool_use blocks in order", () => {
+  const text = '```json\n[{"name":"a","input":{}},{"name":"b","input":{"k":1}}]\n```';
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.toolCalls.length, 2);
+  assert.equal(r.toolCalls[0].name, "a");
+  assert.equal(r.toolCalls[1].name, "b");
+});
+
+test("mixed prose with a fenced ```json call → prose preserved, call promoted", () => {
+  const text =
+    "Here is the call you asked for:\n```json\n{\"name\":\"ping\",\"input\":{}}\n```\nThat should do it.";
+  const r = repairToolCalls(text, { idFor });
+  assert.equal(r.repaired, true);
+  assert.equal(r.content[0].type, "text");
+  assert.match(r.content[0].text, /Here is the call/);
+  assert.match(r.content[0].text, /That should do it\./);
+  assert.equal(r.content[1].type, "tool_use");
+});
+
+test("plain prose with no tool call → not repaired, single text block", () => {
+  const text = "This is a normal answer with no tool call.";
+  const r = repairToolCalls(text);
+  assert.equal(r.repaired, false);
+  assert.equal(r.source, "none");
+  assert.deepEqual(r.content, [{ type: "text", text }]);
+  assert.equal(r.text, text);
+});
+
+test("a JSON object that is NOT a tool call (no name/tool) → not repaired", () => {
+  const text = '{"answer": 42, "confidence": 0.9}';
+  const r = repairToolCalls(text);
+  assert.equal(r.repaired, false);
+  assert.equal(r.toolCalls.length, 0);
+});
+
+test("native message content with tool_use blocks → passed through, repaired=true", () => {
+  const msg = {
+    content: [
+      { type: "text", text: "ok" },
+      { type: "tool_use", id: "t1", name: "do_thing", input: { a: 1 } },
+    ],
+  };
+  const r = repairToolCalls(msg);
+  assert.equal(r.repaired, true);
+  assert.equal(r.toolCalls.length, 1);
+  assert.equal(r.toolCalls[0].id, "t1");
+  // Native block preserved verbatim.
+  assert.deepEqual(
+    r.content.find((b) => b.type === "tool_use"),
+    { type: "tool_use", id: "t1", name: "do_thing", input: { a: 1 } }
+  );
+});
+
+test("never throws on garbage input", () => {
+  for (const g of [null, undefined, 42, {}, { content: 5 }, [], "```json\n{bad json\n```"]) {
+    const r = repairToolCalls(g);
+    assert.equal(typeof r.repaired, "boolean");
+    assert.ok(Array.isArray(r.content));
+    assert.ok(Array.isArray(r.toolCalls));
+  }
+});
+
+test("synthetic id is generated when no provider id present", () => {
+  const r = repairToolCalls('{"name":"x","input":{}}');
+  assert.equal(r.repaired, true);
+  assert.match(r.toolCalls[0].id, /^repair_x_\d+$/);
+});
+
+test("_internals.coerceInput parses JSON strings, wraps non-objects", () => {
+  assert.deepEqual(_internals.coerceInput('{"a":1}'), { a: 1 });
+  assert.deepEqual(_internals.coerceInput("not json"), { _raw: "not json" });
+  assert.deepEqual(_internals.coerceInput([1, 2]), { _args: [1, 2] });
+  assert.deepEqual(_internals.coerceInput(null), {});
+});