little-coder 1.8.3 → 1.8.4

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;
+}

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to little-coder are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and little-coder's public interface (CLI, providers, tools, skills) follows semver starting at `v0.0.1` post-rename.
 
+## [v1.8.4] — 2026-06-08
+
+### Added
+- **`output-parser` now recognizes LFM2 / Liquid "Pythonic" tool calls** ([#42](https://github.com/itayinbarr/little-coder/issues/42)). LiquidAI LFM2 models emit tool calls as a Python list wrapped in special tokens — `<|tool_call_start|>[Read(path='/a.c'), Bash(command='ls -la')]<|tool_call_end|>` — a format neither pi's native path nor the existing fenced/`<tool_call>`/bare-JSON parsers understood. New `parseLiquidToolCalls()` recovers them best-effort: single **and** double quotes, dict args (`{"k":"v"}`), list args (`['a','b']`), `True`/`False`/`None`, ints/floats, commas/parens **inside** string values, truncated tails (missing `)`/`]`/quote), the issue's exact leak shape (start token + `[` stripped, `]<|tool_call_end|><|im_end|>` trailing), and the real-world `<think>…</think>[calls]` shape — all with a precision guard so ordinary prose never trips it. Each recovered call is tagged `format: "liquid"`; the extension surfaces a single, accurate diagnostic for that format instead of the futile "use native tool calls" nudge (Pythonic *is* LFM2's native channel, so nudging would just loop). 20 new parser tests, including one built from verbatim LFM2.5-8B-A1B output.
+
+### Fixed / Documentation
+- **Diagnosed and documented the actual `Failed to parse input at pos N: …<|tool_call_end|>` failure** ([#42](https://github.com/itayinbarr/little-coder/issues/42)). The error is *server-side*: llama.cpp's `chat.cpp` tool-call parser chokes when the chat template doesn't match it — typically the GGUF's **embedded** template, which renders tools as a plain `List of tools: […]` blob without the `<|tool_list_start|>` / `<|tool_call_start|>` special tokens the parser expects. Verified end-to-end with `LiquidAI/LFM2.5-8B-A1B-Q4_K_M`: the embedded template reproduces the error and the tool never runs, while serving with `--jinja --chat-template-file LFM2-8B-A1B.jinja` (the matching template, with the special tokens) parses calls into native `tool_calls` and tools execute normally. New Troubleshooting entry with the exact fix.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. If you run an LFM2/Liquid model, serve llama.cpp with `--jinja` and the model's matching chat template (see Troubleshooting). The parser change only adds recovery + a clearer diagnostic for builds that leak the calls as text.
+
+---
+
 ## [v1.8.3] — 2026-06-08
 
 ### Fixed

package/README.md

@@ -294,6 +294,8 @@ This is where the scaffolding work now compounds: knowledge injection/selection,
 
 **Image attachment is accepted but the request returns 4xx** — your llama-server is running without a vision projector. Re-launch it with `--mmproj ~/models/mmproj-F16.gguf` (or another mmproj variant from the same GGUF repo). The `--list-models` `images` column reflects what the client *will attempt to send*, not what the server can answer; the projector is what gives the model eyes.
 
+**`Failed to parse input at pos N: SomeTool(arg='…')]<|tool_call_end|>` (LFM2 / Liquid models)** — the model is emitting its native *Pythonic* tool calls (`<|tool_call_start|>[Read(path='…')]<|tool_call_end|>`), but llama.cpp's tool-call parser is choking on them — usually because the **chat template doesn't match the parser**. The GGUF's *embedded* template often renders tools as a plain `List of tools: […]` blob without the `<|tool_list_start|>` / `<|tool_call_start|>` special tokens the parser expects. Fix: serve with `--jinja` and the model's **proper** chat template, e.g. `llama-server -m LFM2.5-8B-A1B-Q4_K_M.gguf --jinja --chat-template-file LFM2-8B-A1B.jinja` (templates ship under `llama.cpp/models/templates/`). With the matching template, llama.cpp parses the calls into native `tool_calls` and tools execute normally — verified end-to-end with LFM2.5-8B-A1B. If your build still leaks the calls as plain text, little-coder's `output-parser` recognizes the format and surfaces this same diagnostic instead of a cryptic error (issue [#42](https://github.com/itayinbarr/little-coder/issues/42)).
+
 **No API key env var warning** — pi expects *some* key even for local providers. Export `LLAMACPP_API_KEY=noop` (or `OLLAMA_API_KEY=noop`) before launching.
 
 **No pi "Update Available" banner** — that's intentional. little-coder defaults `PI_SKIP_VERSION_CHECK=1` so the bundled pi runtime doesn't nag about updating itself; little-coder pins pi to a known-good version per release. If you actually want the banner back, `export PI_SKIP_VERSION_CHECK=0` before launching.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.8.3",
+  "version": "1.8.4",
   "description": "A pi-based coding agent optimized for small local language models. Reproduces the whitepaper's scaffold-model-fit adaptations as pi extensions.",
   "homepage": "https://github.com/itayinbarr/little-coder",
   "repository": {