little-coder 1.8.3 → 1.9.0

package/.pi/extensions/branding/branding.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { deriveSessionName } from "./index.ts";
+
+describe("deriveSessionName", () => {
+  it("uses at most the first 4 words, with an ellipsis when there are more", () => {
+    expect(deriveSessionName("add a dark mode toggle to settings")).toBe("add a dark mode…");
+  });
+
+  it("keeps prompts of 4 words or fewer whole (no ellipsis)", () => {
+    expect(deriveSessionName("add dark mode")).toBe("add dark mode");
+    expect(deriveSessionName("one two three four")).toBe("one two three four");
+  });
+
+  it("never slices a word mid-way", () => {
+    const name = deriveSessionName(
+      "implement comprehensive authentication authorization subsystem now please",
+    )!;
+    // every space-separated token is a complete word from the input
+    for (const w of name.replace(/…$/, "").split(" ")) {
+      expect("implement comprehensive authentication authorization subsystem now please").toContain(w);
+    }
+    expect(name.endsWith("…")).toBe(true);
+  });
+
+  it("takes only the first line", () => {
+    expect(deriveSessionName("fix the bug\nmore details here")).toBe("fix the bug");
+  });
+
+  it("collapses surrounding whitespace", () => {
+    expect(deriveSessionName("   refactor   the   parser   ")).toBe("refactor the parser");
+  });
+
+  it("ignores slash-commands and bash lines", () => {
+    expect(deriveSessionName("/resume")).toBeUndefined();
+    expect(deriveSessionName("!ls -la")).toBeUndefined();
+  });
+
+  it("returns undefined for empty input", () => {
+    expect(deriveSessionName("   ")).toBeUndefined();
+    expect(deriveSessionName("")).toBeUndefined();
+  });
+});

package/.pi/extensions/branding/index.ts

@@ -70,8 +70,28 @@ function buildHeader(theme: Theme): string[] {
   return ["", logo, tagline, "", hints, ""];
 }
 
-function setTitleForCwd(setTitle: (t: string) => void, cwd: string): void {
-  setTitle(`little-coder - ${basename(cwd)}`);
+// Derive a short, human session name from the first user prompt. Returns
+// undefined when there's nothing worth naming (empty, or a command/bash line).
+// Kept pure + exported so the slug rules are unit-testable.
+export function deriveSessionName(text: string): string | undefined {
+  const trimmed = text.trim();
+  // Slash-commands and `!`-bash aren't tasks — don't name the session after them.
+  if (!trimmed || trimmed.startsWith("/") || trimmed.startsWith("!")) return undefined;
+  // First line only, first 4 words — cut on word boundaries so it never slices
+  // a word mid-way. A "…" is appended only if there were more words.
+  const firstLine = trimmed.split(/\r?\n/, 1)[0];
+  const allWords = firstLine.split(/\s+/).filter(Boolean);
+  if (allWords.length === 0) return undefined;
+  const words = allWords.slice(0, 4);
+  return allWords.length > words.length ? `${words.join(" ")}…` : words.join(" ");
+}
+
+// Title shows the session's name once it has one, else the cwd basename — so a
+// `/resume`d or `/name`d session is identifiable in the terminal tab, and
+// switching sessions updates the tab (session_start re-asserts on resume).
+function setTitle(setter: (t: string) => void, cwd: string, sessionName?: string): void {
+  const label = sessionName && sessionName.length > 0 ? sessionName : basename(cwd);
+  setter(`little-coder · ${label}`);
 }
 
 export default function (pi: ExtensionAPI) {
@@ -82,6 +102,11 @@ export default function (pi: ExtensionAPI) {
   // points (interactive-mode.js:1179, 1346, 3971), so re-setting on every
   // turn keeps our "little-coder - <cwd>" winning for the duration of a
   // session.
+  const reassertTitle = (ctx: { hasUI: boolean; cwd: string; ui: { setTitle: (t: string) => void } }) => {
+    if (!ctx.hasUI) return;
+    setTitle(ctx.ui.setTitle.bind(ctx.ui), ctx.cwd, safeGetSessionName(pi));
+  };
+
   pi.on("session_start", async (_event, ctx) => {
     if (!ctx.hasUI) return;
 
@@ -92,16 +117,37 @@ export default function (pi: ExtensionAPI) {
       invalidate() {},
     }));
 
-    setTitleForCwd(ctx.ui.setTitle.bind(ctx.ui), ctx.cwd);
+    reassertTitle(ctx);
   });
 
-  pi.on("turn_start", async (_event, ctx) => {
-    if (!ctx.hasUI) return;
-    setTitleForCwd(ctx.ui.setTitle.bind(ctx.ui), ctx.cwd);
+  // Auto-name an as-yet-unnamed session after the user's first real prompt, so
+  // it's identifiable in `/resume` and the tab title without anyone running
+  // `/name`. Only genuine interactive typing names a session — never the
+  // benchmark RPC path or programmatic follow-ups (thinking-budget nudges,
+  // plan-mode synthesis). `/name` still overrides at any time.
+  pi.on("input", async (event, ctx) => {
+    if ((event as any).source !== "interactive") return;
+    if (safeGetSessionName(pi)) return; // already named (auto or via /name)
+    const name = deriveSessionName(String((event as any).text ?? ""));
+    if (!name) return;
+    try {
+      pi.setSessionName(name);
+    } catch {
+      // older SDK without setSessionName — title still falls back to cwd
+    }
+    reassertTitle(ctx);
   });
 
-  pi.on("turn_end", async (_event, ctx) => {
-    if (!ctx.hasUI) return;
-    setTitleForCwd(ctx.ui.setTitle.bind(ctx.ui), ctx.cwd);
-  });
+  // Pi calls updateTerminalTitle() at turn boundaries (interactive-mode.js),
+  // which would clobber ours back to "π - <cwd>"; re-assert at the same points.
+  pi.on("turn_start", async (_event, ctx) => reassertTitle(ctx));
+  pi.on("turn_end", async (_event, ctx) => reassertTitle(ctx));
+}
+
+function safeGetSessionName(pi: ExtensionAPI): string | undefined {
+  try {
+    return typeof pi.getSessionName === "function" ? pi.getSessionName() : undefined;
+  } catch {
+    return undefined;
+  }
 }

package/.pi/extensions/extra-tools/glob.ts

@@ -1,10 +1,10 @@
 import { glob as fsGlob } from "node:fs/promises";
 
-// Bounded file globbing. The naive `for await (…glob…) { if (len>=500) break }`
+// Bounded file globbing. The naive `for await (…glob…) { if (len>=100) break }`
 // only caps MATCHES — it does nothing about the WALK. Run from a huge root
 // (e.g. a home directory with macOS Library / caches / node_modules), fs.glob
 // recursively descends everything, and its internal traversal state grows until
-// the Node process OOMs (heap, not the model's context) — long before 500
+// the Node process OOMs (heap, not the model's context) — long before 100
 // matches are found if matches are sparse. fs.glob exposes no signal/abort and
 // no depth/scan cap, so we bound it through the one hook it does call for every
 // entry: `exclude`. We use it to (a) prune heavy/irrelevant directories so they
@@ -45,7 +45,7 @@ export interface GlobOutcome {
 }
 
 export const DEFAULT_MAX_SCAN = 200_000;
-export const DEFAULT_MAX_MATCHES = 500;
+export const DEFAULT_MAX_MATCHES = 100;
 
 export async function globFiles(pattern: string, opts: GlobOptions): Promise<GlobOutcome> {
   const maxScan = opts.maxScan ?? DEFAULT_MAX_SCAN;

package/.pi/extensions/extra-tools/index.ts

@@ -10,7 +10,7 @@ export default function (pi: ExtensionAPI) {
     name: "glob",
     label: "Glob",
     description:
-      "Find files matching a glob pattern. Returns a sorted list of matching paths (up to 500). " +
+      "Find files matching a glob pattern. Returns a sorted list of matching paths (up to 100). " +
       "Common dependency/build/cache dirs (node_modules, .git, dist, …) are skipped, and the walk " +
       "is bounded — for a focused search, pass a `path` rather than globbing a whole home directory.",
     parameters: Type.Object({

package/.pi/extensions/output-parser/index.ts

@@ -8,6 +8,16 @@ import { harnessIntervention } from "../_shared/intervention.ts";
 // the headline Qwen3.6-35B-A3B path, which uses native tool calling. When
 // extracted calls ARE detected, we log them via ctx.ui.notify and queue a
 // follow-up nudge for the next turn.
+//
+// One format is handled differently: LFM2/Liquid "Pythonic" tool calls
+// (`<|tool_call_start|>[Read(path='…')]<|tool_call_end|>`, issue #42). Pythonic
+// IS that model's native channel, so a "use native tool calls" nudge can't move
+// it to another format — it would just re-emit the same text every turn and
+// loop. little-coder also can't execute the calls itself (pi exposes no
+// extension API to run a tool + synthesize its result). So for that format we
+// surface a single, accurate diagnostic pointing at the real fix — serving
+// llama.cpp with `--jinja` and the model's chat template, which parses the
+// calls into native tool_calls upstream — instead of looping a futile nudge.
 
 function extractAssistantText(message: any): string {
   if (!message) return "";
@@ -26,6 +36,10 @@ function hasNativeToolCalls(message: any): boolean {
 }
 
 export default function (pi: ExtensionAPI) {
+  // The --jinja diagnostic is shown once per session — every LFM2 turn would
+  // otherwise repeat it, which is noise once the user knows.
+  let liquidNotified = false;
+
   pi.on("turn_end", async (event, ctx) => {
     const message = (event as any).message;
     if (!message) return;
@@ -37,21 +51,37 @@ export default function (pi: ExtensionAPI) {
     const calls = parseTextToolCalls(text);
     if (calls.length === 0) return;
 
-    const names = calls.map((c) => c.name).join(", ");
-    harnessIntervention(
-      ctx,
-      `the model wrote ${calls.length} tool call(s) as text [${names}] — nudging it back to native tool calls.`,
-    );
-
-    // Queue a follow-up that will be delivered after the agent finishes.
-    // This nudges the model to use native tool calling on its next turn
-    // rather than emitting fenced blocks in text.
-    pi.sendUserMessage(
-      "Your previous response embedded tool calls inside text (e.g. fenced ```tool blocks or <tool_call> tags). " +
-      "Please re-issue them as NATIVE tool calls. If the intended calls were: " +
-      calls.map((c) => `${c.name}(${JSON.stringify(c.input)})`).join("; ") +
-      " — please execute them now using your tool-call channel, not text.",
-      { deliverAs: "followUp" },
-    );
+    const liquidCalls = calls.filter((c) => c.format === "liquid");
+    const otherCalls = calls.filter((c) => c.format !== "liquid");
+
+    // LFM2/Liquid Pythonic format: inform once, don't nudge (see header note).
+    if (liquidCalls.length > 0 && !liquidNotified) {
+      liquidNotified = true;
+      const names = liquidCalls.map((c) => c.name).join(", ");
+      harnessIntervention(
+        ctx,
+        `the model emitted ${liquidCalls.length} Pythonic tool call(s) as text [${names}] (LFM2/Liquid format). ` +
+          `little-coder can't execute these directly — serve llama.cpp with \`--jinja\` and the model's MATCHING ` +
+          `chat template (not the GGUF's embedded one) so tool calls parse into native tool_calls. ` +
+          `See README troubleshooting / issue #42.`,
+      );
+    }
+
+    // Fenced / <tool_call> / bare-JSON formats: nudge the model back to native
+    // tool calling (it has a native channel; this format was a slip).
+    if (otherCalls.length > 0) {
+      const names = otherCalls.map((c) => c.name).join(", ");
+      harnessIntervention(
+        ctx,
+        `the model wrote ${otherCalls.length} tool call(s) as text [${names}] — nudging it back to native tool calls.`,
+      );
+      pi.sendUserMessage(
+        "Your previous response embedded tool calls inside text (e.g. fenced ```tool blocks, <tool_call> tags, or bare JSON). " +
+          "Please re-issue them as NATIVE tool calls. If the intended calls were: " +
+          otherCalls.map((c) => `${c.name}(${JSON.stringify(c.input)})`).join("; ") +
+          " — please execute them now using your tool-call channel, not text.",
+        { deliverAs: "followUp" },
+      );
+    }
   });
 }

package/.pi/extensions/output-parser/parser.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { repairJson, parseTextToolCalls, escapeNewlinesInJsonStrings } from "./parser.ts";
+import { repairJson, parseTextToolCalls, parseLiquidToolCalls, escapeNewlinesInJsonStrings } from "./parser.ts";
 
 describe("repairJson", () => {
   it("direct parse on valid JSON", () => {
@@ -87,4 +87,126 @@ describe("parseTextToolCalls", () => {
   it("empty on plain text", () => {
     expect(parseTextToolCalls("just regular text, no tools here")).toEqual([]);
   });
+
+  it("extracts an LFM2/Liquid Pythonic call via parseTextToolCalls and tags format", () => {
+    const text = "<|tool_call_start|>[Read(path='/a.c')]<|tool_call_end|>";
+    const calls = parseTextToolCalls(text);
+    expect(calls.length).toBe(1);
+    expect(calls[0].name).toBe("Read");
+    expect(calls[0].input).toEqual({ path: "/a.c" });
+    expect(calls[0].format).toBe("liquid");
+  });
+});
+
+describe("parseLiquidToolCalls (LFM2 / Liquid Pythonic format)", () => {
+  it("canonical single call wrapped in special tokens", () => {
+    const calls = parseLiquidToolCalls("<|tool_call_start|>[Read(path='/home/user/foo.c')]<|tool_call_end|>");
+    expect(calls).toEqual([{ id: "call_text_0", name: "Read", input: { path: "/home/user/foo.c" }, format: "liquid" }]);
+  });
+
+  it("recovers the exact issue #42 leak shape (start token + [ stripped, end + im_end trailing)", () => {
+    // From the issue: `Failed to parse input at pos 57: Read(path='/home/user/foo.c')]<|tool_call_end|><|im_end|>`
+    const text = "Read(path='/home/user/foo.c')]<|tool_call_end|><|im_end|>";
+    const calls = parseLiquidToolCalls(text);
+    expect(calls.length).toBe(1);
+    expect(calls[0].name).toBe("Read");
+    expect(calls[0].input).toEqual({ path: "/home/user/foo.c" });
+  });
+
+  it("multiple calls in one list", () => {
+    const text = "<|tool_call_start|>[Read(path='/a'), Bash(command='ls -la')]<|tool_call_end|>";
+    const calls = parseLiquidToolCalls(text);
+    expect(calls.map((c) => c.name)).toEqual(["Read", "Bash"]);
+    expect(calls[1].input).toEqual({ command: "ls -la" });
+  });
+
+  it("commas and parens INSIDE a string value don't split args/calls", () => {
+    const text = "<|tool_call_start|>[Bash(command='echo (hi), then ls')]<|tool_call_end|>";
+    const calls = parseLiquidToolCalls(text);
+    expect(calls.length).toBe(1);
+    expect(calls[0].input).toEqual({ command: "echo (hi), then ls" });
+  });
+
+  it("double-quoted string values (model variant)", () => {
+    const calls = parseLiquidToolCalls('<|tool_call_start|>[Read(path="/a.c")]<|tool_call_end|>');
+    expect(calls[0].input).toEqual({ path: "/a.c" });
+  });
+
+  it("Python scalar types: int, float, True/False, None", () => {
+    const text =
+      "<|tool_call_start|>[Conf(n=3, ratio=1.5, neg=-2, flag=True, off=False, none=None)]<|tool_call_end|>";
+    const calls = parseLiquidToolCalls(text);
+    expect(calls[0].input).toEqual({ n: 3, ratio: 1.5, neg: -2, flag: true, off: false, none: null });
+  });
+
+  it("list arg (Python repr, single quotes, internal commas)", () => {
+    const text = "<|tool_call_start|>[Grep(paths=['a.py', 'b.py'], pattern='x')]<|tool_call_end|>";
+    const calls = parseLiquidToolCalls(text);
+    expect(calls[0].input).toEqual({ paths: ["a.py", "b.py"], pattern: "x" });
+  });
+
+  it("dict arg rendered as JSON (tojson)", () => {
+    const text = '<|tool_call_start|>[Run(opts={"x": 1, "y": "z"})]<|tool_call_end|>';
+    const calls = parseLiquidToolCalls(text);
+    expect(calls[0].input).toEqual({ opts: { x: 1, y: "z" } });
+  });
+
+  it("no-arg call", () => {
+    const calls = parseLiquidToolCalls("<|tool_call_start|>[ListDir()]<|tool_call_end|>");
+    expect(calls).toEqual([{ id: "call_text_0", name: "ListDir", input: {}, format: "liquid" }]);
+  });
+
+  it("truncated tail: missing closing paren / bracket / quote", () => {
+    const text = "<|tool_call_start|>[Read(path='/home/user/foo.c";
+    const calls = parseLiquidToolCalls(text);
+    expect(calls.length).toBe(1);
+    expect(calls[0].name).toBe("Read");
+    expect(calls[0].input).toEqual({ path: "/home/user/foo.c" });
+  });
+
+  it("bare whole-message bracket list (no special tokens)", () => {
+    const calls = parseLiquidToolCalls("[Read(path='/a'), Read(path='/b')]");
+    expect(calls.map((c) => c.input.path)).toEqual(["/a", "/b"]);
+  });
+
+  it("recovers REAL LFM2.5-8B-A1B output: <think>…</think> then a bare, double-quoted call list", () => {
+    // Captured verbatim from llama.cpp serving LiquidAI/LFM2.5-8B-A1B-Q4_K_M:
+    // the model reasons in <think>…</think>, emits NO special tokens, and uses
+    // DOUBLE quotes — none of which the first cut of this parser handled.
+    const real =
+      '<think>\nOkay, the user wants two things. First read the file, then run the ls command.\n' +
+      'For Read the parameter is "path"; for Bash the command is "ls -la /tmp".\n</think>' +
+      '[Read(path="/home/user/foo.c"), Bash(command="ls -la /tmp")]';
+    const calls = parseLiquidToolCalls(real);
+    expect(calls.map((c) => c.name)).toEqual(["Read", "Bash"]);
+    expect(calls[0].input).toEqual({ path: "/home/user/foo.c" });
+    expect(calls[1].input).toEqual({ command: "ls -la /tmp" });
+  });
+
+  it("does not fire while the model is still inside an unclosed <think> block", () => {
+    expect(parseLiquidToolCalls("<think>\nI should call [Read(path='/a')] next...")).toEqual([]);
+  });
+
+  it("preserves spaces inside string values, trims around args", () => {
+    const calls = parseLiquidToolCalls("<|tool_call_start|>[Bash(  command = 'git status'  )]<|tool_call_end|>");
+    expect(calls[0].input).toEqual({ command: "git status" });
+  });
+
+  // ── precision: must NOT fire on ordinary prose ──────────────────────────────
+  it("ignores plain prose", () => {
+    expect(parseLiquidToolCalls("I'll read the file and report back.")).toEqual([]);
+  });
+
+  it("ignores a markdown/JSON array that isn't a call list", () => {
+    expect(parseLiquidToolCalls("[1, 2, 3]")).toEqual([]);
+    expect(parseLiquidToolCalls('["a", "b"]')).toEqual([]);
+  });
+
+  it("ignores a bracketed phrase in prose that isn't a clean call list", () => {
+    expect(parseLiquidToolCalls("[see the foo() helper](http://x) for details")).toEqual([]);
+  });
+
+  it("does not fire on a function-call-looking phrase mid-sentence (no tokens, not whole-message)", () => {
+    expect(parseLiquidToolCalls("then I called Read(path='/a') to inspect it")).toEqual([]);
+  });
 });

package/.pi/extensions/output-parser/parser.ts

@@ -75,11 +75,21 @@ export interface ExtractedCall {
   id: string;
   name: string;
   input: Record<string, unknown>;
+  /** Which text encoding the call was recovered from. Lets the extension treat
+   *  the LFM2/Liquid "Pythonic" format differently from the JSON-based ones:
+   *  nudging a model back to "native" tool calls is futile when Pythonic IS its
+   *  native channel, so that path informs once instead of looping. */
+  format?: "fenced" | "tag" | "bare" | "liquid";
 }
 
 export function parseTextToolCalls(text: string): ExtractedCall[] {
   const calls: ExtractedCall[] = [];
 
+  // Pattern 0: LFM2 / Liquid "Pythonic" tool calls. Checked first — the
+  // <|tool_call_*|> special tokens are unambiguous and the format never
+  // overlaps the JSON-based patterns below (issue #42).
+  calls.push(...parseLiquidToolCalls(text));
+
   // Pattern 1: ```tool ... ``` or ```json ... ```
   const fenceRe = /```(?:tool|json)\s*\n([\s\S]*?)\n```/g;
   let m: RegExpExecArray | null;
@@ -90,6 +100,7 @@ export function parseTextToolCalls(text: string): ExtractedCall[] {
         id: `call_text_${calls.length}`,
         name: data.name,
         input: (data.input ?? data.parameters ?? data.args ?? {}) as Record<string, unknown>,
+        format: "fenced",
       });
     }
   }
@@ -103,6 +114,7 @@ export function parseTextToolCalls(text: string): ExtractedCall[] {
         id: `call_text_${calls.length}`,
         name: data.name,
         input: (data.input ?? data.parameters ?? data.args ?? {}) as Record<string, unknown>,
+        format: "tag",
       });
     }
   }
@@ -117,6 +129,7 @@ export function parseTextToolCalls(text: string): ExtractedCall[] {
           id: `call_text_${calls.length}`,
           name: data.name,
           input: (data.input ?? data.parameters ?? {}) as Record<string, unknown>,
+          format: "bare",
         });
       }
     }
@@ -124,3 +137,192 @@ export function parseTextToolCalls(text: string): ExtractedCall[] {
 
   return calls;
 }
+
+// ── LFM2 / Liquid "Pythonic" tool-call format ───────────────────────────────
+// LiquidAI LFM2 models (issue #42) emit tool calls as a Python list of function
+// calls wrapped in special tokens, e.g.
+//   <|tool_call_start|>[Read(path='/a.c'), Grep(pattern='x', path='.')]<|tool_call_end|>
+// Argument values follow the model's chat-template `format_arg_value` macro:
+//   string -> single quotes 'val' (the template does NOT escape inner quotes)
+//   dict   -> JSON object {"k": "v"}
+//   else   -> Python str(): 123, 1.5, True, False, None, ['a', 'b']
+// Served WITHOUT llama.cpp's `--jinja`, these are never parsed into native
+// tool_calls and leak into assistant TEXT — often with the start token and its
+// `[` stripped and `]<|tool_call_end|><|im_end|>` trailing (the exact shape in
+// the issue's error). We recover them best-effort so the harness can react with
+// an accurate diagnostic instead of a cryptic parse failure.
+
+const LIQUID_START = "<|tool_call_start|>";
+const LIQUID_END = "<|tool_call_end|>";
+
+/** Split `s` on a single-char separator, ignoring separators inside quotes
+ *  (single or double, with `\` escaping) or inside (), [], {} of any depth. */
+function splitTopLevel(s: string, sep: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let quote: string | null = null;
+  let esc = false;
+  let cur = "";
+  for (const c of s) {
+    cur += c;
+    if (quote) {
+      if (esc) esc = false;
+      else if (c === "\\") esc = true;
+      else if (c === quote) quote = null;
+      continue;
+    }
+    if (c === "'" || c === '"') quote = c;
+    else if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth--;
+    else if (c === sep && depth === 0) {
+      parts.push(cur.slice(0, -1));
+      cur = "";
+    }
+  }
+  parts.push(cur);
+  return parts;
+}
+
+/** Index of the first top-level occurrence of `ch` (quote/bracket-aware), or -1. */
+function topLevelIndexOf(s: string, ch: string): number {
+  let depth = 0;
+  let quote: string | null = null;
+  let esc = false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (quote) {
+      if (esc) esc = false;
+      else if (c === "\\") esc = true;
+      else if (c === quote) quote = null;
+      continue;
+    }
+    if (c === "'" || c === '"') quote = c;
+    else if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth--;
+    else if (c === ch && depth === 0) return i;
+  }
+  return -1;
+}
+
+function unescapePy(s: string): string {
+  return s.replace(/\\(['"\\nrt])/g, (_, c) => (c === "n" ? "\n" : c === "t" ? "\t" : c === "r" ? "\r" : c));
+}
+
+/** Coerce one Python-literal argument value (as rendered by `format_arg_value`)
+ *  into a JS value. Best-effort and total — never throws; an unrecognized token
+ *  falls through as a bare string so no data is lost. Returns undefined only for
+ *  an empty slot (e.g. a trailing comma). */
+function parsePyValue(raw: string): unknown {
+  const s = raw.trim();
+  if (!s) return undefined;
+  const c0 = s[0];
+  // String — strip the outer matching quote. Slicing first/last (rather than
+  // unescaping a closing quote) tolerates the template's unescaped inner quotes
+  // for the common case where the value still begins and ends with the quote.
+  if (c0 === "'" || c0 === '"') {
+    const inner = s[s.length - 1] === c0 && s.length >= 2 ? s.slice(1, -1) : s.slice(1);
+    return unescapePy(inner);
+  }
+  if (c0 === "{") {
+    const obj = repairJson(s);
+    return "_raw" in obj && Object.keys(obj).length === 1 ? s : obj;
+  }
+  if (c0 === "[") return parsePyList(s);
+  if (s === "True" || s.toLowerCase() === "true") return true;
+  if (s === "False" || s.toLowerCase() === "false") return false;
+  if (s === "None" || s.toLowerCase() === "null" || s.toLowerCase() === "none") return null;
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s)) return Number(s);
+  return s; // bareword / unquoted — keep verbatim
+}
+
+function parsePyList(s: string): unknown[] {
+  const inner = s.trim().replace(/^\[/, "").replace(/\]$/, "");
+  if (!inner.trim()) return [];
+  return splitTopLevel(inner, ",")
+    .map(parsePyValue)
+    .filter((v) => v !== undefined);
+}
+
+/** Parse a `name(arg=val, ...)` Python call. Tolerates a truncated tail (a
+ *  missing closing paren). Returns null when there's no `name(` head. */
+function parsePyCall(raw: string): { name: string; input: Record<string, unknown> } | null {
+  const s = raw.trim();
+  const open = s.indexOf("(");
+  if (open < 0) return null;
+  const name = s.slice(0, open).trim();
+  if (!/^[A-Za-z_]\w*$/.test(name)) return null;
+  // Find the matching close paren (quote/bracket-aware); fall back to end on truncation.
+  let depth = 0;
+  let quote: string | null = null;
+  let esc = false;
+  let end = -1;
+  for (let i = open; i < s.length; i++) {
+    const c = s[i];
+    if (quote) {
+      if (esc) esc = false;
+      else if (c === "\\") esc = true;
+      else if (c === quote) quote = null;
+      continue;
+    }
+    if (c === "'" || c === '"') quote = c;
+    else if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+    }
+  }
+  const argsBlob = end >= 0 ? s.slice(open + 1, end) : s.slice(open + 1);
+  const input: Record<string, unknown> = {};
+  for (const part of splitTopLevel(argsBlob, ",")) {
+    const seg = part.trim();
+    if (!seg) continue;
+    const eq = topLevelIndexOf(seg, "=");
+    if (eq < 0) continue; // positional/garbage — LFM2 always emits kwargs; skip safely
+    const key = seg.slice(0, eq).trim();
+    if (!/^[A-Za-z_]\w*$/.test(key)) continue;
+    const val = parsePyValue(seg.slice(eq + 1));
+    if (val !== undefined) input[key] = val;
+  }
+  return { name, input };
+}
+
+/** Recover LFM2/Liquid Pythonic tool calls from assistant text. High-precision:
+ *  fires on the `<|tool_call_*|>` special tokens, or — without them — only when
+ *  the whole message is a `[...]` bracket list, since every element must still
+ *  parse as a `name(...)` call. */
+export function parseLiquidToolCalls(text: string): ExtractedCall[] {
+  const hasStart = text.includes(LIQUID_START);
+  const hasEnd = text.includes(LIQUID_END);
+  let region: string;
+  if (hasStart || hasEnd) {
+    let s = text;
+    if (hasStart) s = s.slice(s.indexOf(LIQUID_START) + LIQUID_START.length);
+    if (s.includes(LIQUID_END)) s = s.slice(0, s.indexOf(LIQUID_END));
+    region = s;
+  } else {
+    // No special tokens (some llama.cpp builds/templates emit the bare list).
+    // Reasoning LFM2 models put the call list AFTER a <think>…</think> block —
+    // e.g. `</think>[Read(path="/a"), Bash(command="ls")]` (verified against
+    // LFM2.5-8B-A1B). Strip a leading think block, then require the remainder to
+    // be exactly a `[…]` list so prose can't trip it.
+    const t = text.trim().replace(/^<think>[\s\S]*?<\/think>\s*/, "").trim();
+    if (!(t.startsWith("[") && t.endsWith("]"))) return [];
+    region = t;
+  }
+  // Drop any leftover special tokens, then one wrapping [ ... ] of the call list.
+  region = region.replace(/<\|tool_call_(?:start|end)\|>/g, "").replace(/<\|im_end\|>/g, "").trim();
+  if (region.startsWith("[")) region = region.slice(1);
+  if (region.endsWith("]")) region = region.slice(0, -1);
+  region = region.trim();
+  if (!region) return [];
+
+  const calls: ExtractedCall[] = [];
+  for (const part of splitTopLevel(region, ",")) {
+    const call = parsePyCall(part);
+    if (call) calls.push({ id: `call_text_${calls.length}`, name: call.name, input: call.input, format: "liquid" });
+  }
+  return calls;
+}