pi-condense 2.11.2 → 2.11.3

package/CHANGELOG.md

@@ -7,6 +7,12 @@ Published to npm as [`pi-condense`](https://www.npmjs.com/package/pi-condense) (
 Pushing a `vX.Y.Z` tag triggers `.github/workflows/release.yml`, which runs the tests and
 publishes via OIDC trusted publishing. See `.agents/skills/release/SKILL.md`.
 
+## [2.11.3] - 2026-10-04
+
+### Fixed
+
+- Error purge keeps a failed tool call's argument keys, types, and array lengths and shrinks only strings over 200 characters, so grammar-constrained tools such as `codemode` no longer fail every later request with `Grammar tool call "codemode" requires argument "code" to be a string` after a purge. (#19)
+
 ## [2.11.2] - 2026-09-29
 
 ### Fixed

package/PRUNING.md

@@ -1096,23 +1096,26 @@ Short refs (`tN`) always resolve 1:1 - one ref, one record - and are the primary
 
 Failed tool calls often embed large argument bodies in the assistant message — a `write` call with a 30 KB file body, an `edit` call with a multiline diff. The error result is small (e.g. `"Error: file not found"`), but the original `arguments` stay in the assistant turn indefinitely.
 
-Error purge replaces those arg bodies with compact stubs after the error has cooled down:
+Error purge shrinks the large string values inside those argument bodies after the error has cooled down. Every key, JSON type, and array length survives; only strings longer than 200 characters (`PURGE_STRING_MIN_CHARS` in `src/error-purge.ts`, not configurable) become a placeholder carrying the original length:
 
 ```
-{ "_purged": "<purged-errored-args size=\"N\"/>" }
+{ "path": "src/foo.ts", "content": "<purged-errored-args size=\"30000\"/>" }
 ```
 
+Providers validate replayed tool calls against the declared schema - pi-ai's grammar-constrained tools (`codemode`) require the input property to be a string - so the shape must stay intact. The 200-character floor keeps `path`, a short `command`, or a small `newText` readable; it is a constant because nobody has a reason to tune a readability guard.
+
 **What triggers a purge:**
 
 - The matching `ToolResultMessage` has `isError: true`.
 - The error occurred at least `purgeErrors.cooldownTurns` assistant turns ago (default 2). The cooldown gives the model 1–2 turns to retry before context is mutated.
-- The JSON-stringified argument body is at least `purgeErrors.minArgChars` characters long (default 500). Small args are not worth the substitution.
+- The JSON-stringified argument body is at least `purgeErrors.minArgChars` characters long (default 500). Small args are not worth the substitution. A body that qualifies but holds no string over 200 characters is returned unchanged.
 
 **What error purge does NOT touch:**
 
 - The `ToolResultMessage` content — the error message stays visible so the model can see what went wrong.
 - Non-errored `toolCall` argument bodies.
 - Argument bodies below `minArgChars`.
+- Keys, non-string values, array lengths, and strings of 200 characters or fewer inside a purged body.
 - Anything when `purgeErrors.enabled` is `false`.
 
 **Transform position:** Error purge runs in Phase 2, after stub-replace and before chain range prune.
@@ -1127,7 +1130,7 @@ Error purge replaces those arg bodies with compact stubs after the error has coo
 |---|---|---|
 | `purgeErrors.enabled` | `true` | Master toggle |
 | `purgeErrors.cooldownTurns` | `2` | Turns to wait after error before purging |
-| `purgeErrors.minArgChars` | `500` | Minimum argument body size to purge |
+| `purgeErrors.minArgChars` | `500` | Minimum JSON body size for a failed call to be scanned; only strings over 200 chars inside it are replaced |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-condense",
-  "version": "2.11.2",
+  "version": "2.11.3",
   "description": "Pi coding-agent extension that summarizes completed tool-call batches, replaces raw outputs with short stubs, compresses closed tool-call chains, and recovers any original on demand via context_tree_query.",
   "author": "Jacek Juraszek",
   "license": "MIT",

package/src/commands.ts

@@ -675,7 +675,7 @@ export function registerCommands(
               label: "Error purge",
               values: ["true", "false"],
               currentValue: String(config.purgeErrors.enabled),
-              description: `Replace failed toolCall argument bodies with compact stubs after a cooldown. Reclaims context from large write/edit args that will never succeed. Currently ${config.purgeErrors.enabled ? "ON" : "OFF"}.`,
+              description: `Shrink long strings inside failed toolCall arguments after a cooldown, keeping argument shape. Reclaims context from large write/edit args that will never succeed. Currently ${config.purgeErrors.enabled ? "ON" : "OFF"}.`,
             },
             {
               id: "purgeErrorsCooldown",

package/src/error-purge.test.ts

@@ -8,6 +8,9 @@ const defaultConfig: ErrorPurgeConfig = {
   minArgChars: 10,
 };
 
+const LONG = "x".repeat(300);
+const PLACEHOLDER_RE = /^<purged-errored-args size="\d+"\/>$/;
+
 function makeAssistant(toolCallId: string, argsObj: Record<string, any>, turnN?: number) {
   return {
     role: "assistant",
@@ -47,7 +50,7 @@ describe("purgeErroredArgs", () => {
   it("does not purge while still within cooldown", () => {
     // Error at turn 1, current = turn 2, age = 1 < cooldownTurns 2
     const messages = [
-      makeAssistant("tc1", { content: "a very long argument body here" }),
+      makeAssistant("tc1", { content: LONG }),
       makeToolResult("tc1", true),
       makeAssistant("tc2", { cmd: "ls" }),
       makeToolResult("tc2", false),
@@ -55,11 +58,11 @@ describe("purgeErroredArgs", () => {
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2 });
     expect(result).toBe(messages);
     const asstMsg = result[0] as any;
-    expect(asstMsg.content[0].arguments).toEqual({ content: "a very long argument body here" });
+    expect(asstMsg.content[0].arguments).toEqual({ content: LONG });
   });
 
   it("purges args after cooldown when args meet minArgChars", () => {
-    const largeArgs = { content: "a very long argument body here" };
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -71,9 +74,8 @@ describe("purgeErroredArgs", () => {
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 10 });
     expect(result).not.toBe(messages);
     const purgedAsst = result[0] as any;
-    const originalArgLen = JSON.stringify(largeArgs).length;
     expect(purgedAsst.content[0].arguments).toEqual({
-      _purged: `<purged-errored-args size="${originalArgLen}"/>`,
+      content: `<purged-errored-args size="${LONG.length}"/>`,
     });
     // toolResult stays unchanged
     expect((result[1] as any).content[0].text).toBe("Error: file not found");
@@ -81,7 +83,7 @@ describe("purgeErroredArgs", () => {
 
   it("does not purge when args are below minArgChars", () => {
     const messages = [
-      makeAssistant("tc1", { x: "hi" }), // JSON is only ~10 chars
+      makeAssistant("tc1", { x: LONG }),
       makeToolResult("tc1", true),
       makeAssistant("tc2", { cmd: "ls" }),
       makeToolResult("tc2", false),
@@ -94,7 +96,7 @@ describe("purgeErroredArgs", () => {
 
   it("does not purge when isError is false", () => {
     const messages = [
-      makeAssistant("tc1", { content: "a very long argument body here" }),
+      makeAssistant("tc1", { content: LONG }),
       makeToolResult("tc1", false), // NOT an error
       makeAssistant("tc2", { cmd: "ls" }),
       makeToolResult("tc2", false),
@@ -106,7 +108,7 @@ describe("purgeErroredArgs", () => {
   });
 
   it("only purges errored toolCalls in a multi-toolCall assistant message", () => {
-    const largeArgs = { content: "a very long argument body here that is big" };
+    const largeArgs = { content: LONG };
     const okArgs = { cmd: "ls" };
     const messages = [
       // One assistant with two toolCalls: tc-err is errored, tc-ok is not
@@ -129,16 +131,15 @@ describe("purgeErroredArgs", () => {
     expect(result).not.toBe(messages);
     const asst = result[0] as any;
     // errored one is purged
-    const originalArgLen = JSON.stringify(largeArgs).length;
     expect(asst.content[0].arguments).toEqual({
-      _purged: `<purged-errored-args size="${originalArgLen}"/>`,
+      content: `<purged-errored-args size="${LONG.length}"/>`,
     });
     // non-errored one is untouched
     expect(asst.content[1].arguments).toEqual(okArgs);
   });
 
   it("does not mutate the input messages array or any message object", () => {
-    const largeArgs = { content: "a very long argument body here" };
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -156,8 +157,8 @@ describe("purgeErroredArgs", () => {
   });
 
   it("exactly-at-cooldown boundary: age === cooldownTurns is purged", () => {
-    // Error at turn 1, 2 more assistant turns → age = 2 = cooldownTurns (should purge)
-    const largeArgs = { content: "argument body that is long enough to purge" };
+    // Error at turn 1, 2 more assistant turns -> age = 2 = cooldownTurns (should purge)
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -168,12 +169,12 @@ describe("purgeErroredArgs", () => {
     ];
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 5 });
     expect(result).not.toBe(messages);
-    expect((result[0] as any).content[0].arguments._purged).toBeDefined();
+    expect((result[0] as any).content[0].arguments.content).toMatch(PLACEHOLDER_RE);
   });
 
   it("one-below-cooldown boundary: age === cooldownTurns - 1 is NOT purged", () => {
-    // Error at turn 1, 1 more assistant turn → age = 1 < cooldownTurns 2
-    const largeArgs = { content: "argument body that is long enough to purge" };
+    // Error at turn 1, 1 more assistant turn -> age = 1 < cooldownTurns 2
+    const largeArgs = { content: LONG };
     const messages = [
       makeAssistant("tc1", largeArgs),
       makeToolResult("tc1", true),
@@ -183,4 +184,90 @@ describe("purgeErroredArgs", () => {
     const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars: 5 });
     expect(result).toBe(messages);
   });
+
+  function purgedAfterCooldown(args: Record<string, any>, name: string, minArgChars: number) {
+    const messages = [
+      { ...makeAssistant("tc1", args), content: [{ type: "toolCall", id: "tc1", name, arguments: args }] },
+      { ...makeToolResult("tc1", true), toolName: name },
+      makeAssistant("tc2", { cmd: "ls" }),
+      makeToolResult("tc2", false),
+      makeAssistant("tc3", { cmd: "pwd" }),
+      makeToolResult("tc3", false),
+    ];
+    const result = purgeErroredArgs(messages, { ...defaultConfig, cooldownTurns: 2, minArgChars });
+    return { messages, result, args: (result[0] as any).content[0].arguments };
+  }
+
+  it("keeps a grammar tool's input property a string (codemode, #19)", () => {
+    const { messages, result, args } = purgedAfterCooldown({ code: "x".repeat(1000) }, "codemode", 500);
+    expect(result).not.toBe(messages);
+    expect(typeof args.code).toBe("string");
+    expect(Object.keys(args)).toEqual(["code"]);
+    expect(args.code).toBe('<purged-errored-args size="1000"/>');
+    expect(JSON.stringify(args).length).toBeLessThan(500);
+  });
+
+  it("write-shaped call keeps path verbatim and shrinks content", () => {
+    const { args } = purgedAfterCooldown({ path: "src/foo.ts", content: "x".repeat(30000) }, "write", 500);
+    expect(args.path).toBe("src/foo.ts");
+    expect(args.content).toBe('<purged-errored-args size="30000"/>');
+    expect(JSON.stringify(args).length).toBeLessThan(100);
+  });
+
+  it("edit-shaped call keeps the edits array length and shrinks only long values", () => {
+    const original = {
+      path: "src/foo.ts",
+      edits: [
+        { oldText: "a".repeat(15000), newText: "x" },
+        { oldText: "y", newText: "b".repeat(15000) },
+      ],
+    };
+    const { args } = purgedAfterCooldown(original, "edit", 500);
+    expect(args.path).toBe("src/foo.ts");
+    expect(Array.isArray(args.edits)).toBe(true);
+    expect(args.edits).toHaveLength(2);
+    expect(args.edits[0]).toEqual({ oldText: '<purged-errored-args size="15000"/>', newText: "x" });
+    expect(args.edits[1]).toEqual({ oldText: "y", newText: '<purged-errored-args size="15000"/>' });
+    expect(JSON.stringify(args).length).toBeLessThan(500);
+  });
+
+  it("non-string scalars and short strings pass through by type", () => {
+    const { args } = purgedAfterCooldown({ line: 42, force: true, z: null, s: "short", big: "x".repeat(201) }, "bash", 10);
+    expect(args.line).toBe(42);
+    expect(args.force).toBe(true);
+    expect(args.z).toBeNull();
+    expect(args.s).toBe("short");
+    expect(args.big).toBe('<purged-errored-args size="201"/>');
+  });
+
+  it("a string of exactly 200 chars stays verbatim", () => {
+    const { messages, result } = purgedAfterCooldown({ s: "x".repeat(200) }, "bash", 10);
+    expect(result).toBe(messages);
+  });
+
+  it("eligible body made only of short strings is returned by identity", () => {
+    const original: Record<string, string> = {};
+    for (let i = 0; i < 600; i++) original[`k${i}`] = "v";
+    const { messages, result } = purgedAfterCooldown(original, "bash", 500);
+    expect(result).toBe(messages);
+  });
+
+  it("a second pass over purged output returns the same reference", () => {
+    const { result } = purgedAfterCooldown({ path: "src/foo.ts", content: "x".repeat(1000) }, "write", 10);
+    expect(purgeErroredArgs(result, { ...defaultConfig, cooldownTurns: 2, minArgChars: 10 })).toBe(result);
+  });
+
+  it("preserves own JSON keys even when a key is __proto__", () => {
+    const original = JSON.parse(`{"__proto__":"${LONG}","content":"${LONG}"}`);
+    const { args } = purgedAfterCooldown(original, "write", 10);
+    expect(Object.keys(args)).toEqual(Object.keys(original));
+    expect(args.__proto__).toBe('<purged-errored-args size="300"/>');
+  });
+
+  it("never mutates the original nested arguments", () => {
+    const original = { path: "src/foo.ts", edits: [{ oldText: "a".repeat(300), newText: "x" }] };
+    const snapshot = structuredClone(original);
+    purgedAfterCooldown(original, "edit", 10);
+    expect(original).toEqual(snapshot);
+  });
 });

package/src/error-purge.transport.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "bun:test";
+import { getGrammarToolInput } from "@earendil-works/pi-ai/api/constrained-sampling";
+import { stream } from "@earendil-works/pi-ai/api/openai-completions";
+import type { Model, Tool } from "@earendil-works/pi-ai";
+import { purgeErroredArgs } from "./error-purge.js";
+
+// Chat Completions and Responses share getGrammarToolInput; one transport covers the throw.
+const model: Model<"openai-completions"> = {
+  id: "grammar-test",
+  name: "grammar-test",
+  api: "openai-completions",
+  provider: "openai",
+  baseUrl: "http://127.0.0.1:9",
+  reasoning: false,
+  input: ["text"],
+  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+  contextWindow: 128000,
+  maxTokens: 4096,
+  compat: { supportsOpenAIGrammarTools: true },
+};
+
+const codemode: Tool = {
+  name: "codemode",
+  description: "run code",
+  parameters: {
+    type: "object",
+    properties: { code: { type: "string" } },
+    required: ["code"],
+  } as any,
+  constrainedSampling: { type: "grammar", variants: { openai_lark: 'start: /[\\s\\S]*/' } },
+};
+
+const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+const meta = { api: "openai-completions", provider: "openai", model: "grammar-test", usage };
+
+function history(codeArgs: Record<string, unknown>) {
+  return [
+    { role: "user", content: "run it", timestamp: 1 },
+    { role: "assistant", content: [{ type: "toolCall", id: "tc1", name: "codemode", arguments: codeArgs }], ...meta, stopReason: "toolUse", timestamp: 2 },
+    { role: "toolResult", toolCallId: "tc1", toolName: "codemode", content: [{ type: "text", text: "Error: boom" }], isError: true, timestamp: 3 },
+    { role: "assistant", content: [{ type: "text", text: "retrying" }], ...meta, stopReason: "stop", timestamp: 4 },
+    { role: "user", content: "again", timestamp: 5 },
+    { role: "assistant", content: [{ type: "text", text: "ok" }], ...meta, stopReason: "stop", timestamp: 6 },
+    { role: "user", content: "go", timestamp: 7 },
+  ] as any[];
+}
+
+async function request(messages: any[]) {
+  let calls = 0;
+  const fetchStub = (async () => {
+    calls++;
+    throw new Error("connection refused by stub");
+  }) as unknown as typeof fetch;
+  const result = await stream(model, { messages, tools: [codemode] }, { apiKey: "test", fetch: fetchStub, maxRetries: 0 }).result();
+  return { result, calls };
+}
+
+describe("error purge x pi-ai grammar tools (#19)", () => {
+  const config = { enabled: true, cooldownTurns: 2, minArgChars: 500 };
+
+  it("purged codemode args pass getGrammarToolInput (reporter repro)", () => {
+    const purged = purgeErroredArgs(history({ code: "x".repeat(1000) }), config);
+    const args = purged[1].content[0].arguments;
+    expect(typeof args.code).toBe("string");
+    expect(Object.keys(args)).toEqual(["code"]);
+    expect(JSON.stringify(args).length).toBeLessThan(500);
+    expect(() => getGrammarToolInput("codemode", args, "code")).not.toThrow();
+  });
+
+  it("request building succeeds on purged history; failure is the connection, not the grammar", async () => {
+    const purged = purgeErroredArgs(history({ code: "x".repeat(1000) }), config);
+    expect(purged[1].content[0].arguments.code).toMatch(/^<purged-errored-args size=/);
+    const { result, calls } = await request(purged);
+    expect(result.stopReason).toBe("error");
+    // The OpenAI SDK wraps fetch rejections in APIConnectionError and drops the cause message.
+    expect(result.errorMessage).toMatch(/Connection error/);
+    expect(result.errorMessage).not.toMatch(/Grammar tool call/);
+    expect(calls).toBe(1);
+  });
+
+  it("negative control: the old { _purged } shape throws the grammar error before any request", async () => {
+    const legacy = history({ code: "x".repeat(1000) });
+    legacy[1].content[0].arguments = { _purged: '<purged-errored-args size="1012"/>' };
+    const { result, calls } = await request(legacy);
+    expect(result.stopReason).toBe("error");
+    expect(result.errorMessage).toMatch(/Grammar tool call "codemode" requires argument "code" to be a string/);
+    expect(calls).toBe(0);
+  });
+});

package/src/error-purge.ts

@@ -1,8 +1,42 @@
 import type { ErrorPurgeConfig } from "./types.js";
 
+// Keep short paths and commands readable while reclaiming large failed-call bodies.
+const PURGE_STRING_MIN_CHARS = 200;
+
+function shrinkStrings(value: unknown): [unknown, boolean] {
+  if (typeof value === "string") {
+    if (value.length > PURGE_STRING_MIN_CHARS) return [`<purged-errored-args size="${value.length}"/>`, true];
+    return [value, false];
+  }
+  if (Array.isArray(value)) {
+    let out: unknown[] | undefined;
+    for (let i = 0; i < value.length; i++) {
+      const [next, changed] = shrinkStrings(value[i]);
+      if (!changed) continue;
+      out ??= value.slice();
+      out[i] = next;
+    }
+    return out ? [out, true] : [value, false];
+  }
+  if (value !== null && typeof value === "object") {
+    const object = value as Record<string, unknown>;
+    let out: Record<string, unknown> | undefined;
+    for (const key of Object.keys(object)) {
+      const [next, changed] = shrinkStrings(object[key]);
+      if (!changed) continue;
+      // Spread creates own data properties, including JSON's possible __proto__ key.
+      out ??= { ...object };
+      out[key] = next;
+    }
+    return out ? [out, true] : [value, false];
+  }
+  return [value, false];
+}
+
 /**
- * Replaces the `arguments` body of failed toolCall blocks with a compact stub
- * once the error is old enough to be beyond the cooldown window.
+ * Shrinks long strings in failed toolCall arguments after the cooldown window.
+ * Keys and JSON types must survive because pi-ai validates grammar-tool input
+ * properties when replaying calls.
  *
  * Why only the arguments, not the whole toolCall or its toolResult:
  *   - The toolResult content (e.g. "Error: file not found") is small and carries
@@ -58,8 +92,11 @@ export function purgeErroredArgs(messages: any[], config: ErrorPurgeConfig): any
       const argBody = JSON.stringify(block.arguments);
       if (argBody.length < config.minArgChars) return block;
 
+      const [shrunk, changed] = shrinkStrings(block.arguments);
+      if (!changed) return block;
+
       contentModified = true;
-      return { ...block, arguments: { _purged: `<purged-errored-args size="${argBody.length}"/>` } };
+      return { ...block, arguments: shrunk };
     });
 
     if (!contentModified) return msg;

package/src/pruner.test.ts

@@ -278,7 +278,7 @@ describe("pruneMessages", () => {
 
   it("purges errored toolCall args through errorPurge wiring", () => {
     const indexer = makeMockIndexer();
-    const largeArgs = { content: "x".repeat(200) };
+    const largeArgs = { path: "src/foo.ts", content: "x".repeat(300) };
     const messages: any[] = [
       {
         role: "assistant",
@@ -344,7 +344,8 @@ describe("pruneMessages", () => {
     expect(pruned).toBe(true);
     const errAsst = out.find((m: any) => m.role === "assistant" && m.timestamp === 100) as any;
     expect(errAsst).toBeDefined();
-    expect(errAsst.content[0].arguments._purged).toMatch(/^<purged-errored-args size=/);
+    expect(errAsst.content[0].arguments.path).toBe("src/foo.ts");
+    expect(errAsst.content[0].arguments.content).toMatch(/^<purged-errored-args size=/);
   });
 
   it("spill stub tolerates absent spillBytes/resultPreview", () => {
@@ -1009,7 +1010,7 @@ describe("G4/C3: orphan-sweep zero-fire proof across pruner fixtures", () => {
     }],
     ["purges errored toolCall args through errorPurge wiring", () => {
       const indexer = makeMockIndexer();
-      const largeArgs = { content: "x".repeat(200) };
+      const largeArgs = { path: "src/foo.ts", content: "x".repeat(300) };
       const messages: any[] = [
         { role: "assistant", content: [{ type: "toolCall", id: "tc-err", name: "write", arguments: largeArgs }], timestamp: 100, usage: {}, stopReason: "tool_use" },
         { role: "toolResult", toolCallId: "tc-err", toolName: "write", content: [{ type: "text", text: "Error: permission denied" }], isError: true, timestamp: 110 },

package/src/pruner.ts

@@ -155,7 +155,7 @@ export function pruneMessages(
     }
   }
 
-  // Phase 2: error purge — replace failed toolCall arg bodies after cooldown
+  // Phase 2: error purge - shrink long strings in failed toolCall args after cooldown
   if (errorPurge?.enabled) {
     const afterPurge = purgeErroredArgs(current, errorPurge);
     if (afterPurge !== current) {