pi-tool-repair 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tool-repair",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Validate-then-repair extension for pi — fixes common LLM tool-call mistakes (null fields, stringified arrays, wrong field names, anchor bleed) before tools execute",
   "type": "module",
   "author": "Tom X Nguyen",

package/src/grammar-repair.ts

@@ -156,6 +156,21 @@ export function repairAssistantMessageGrammarLeaks(
     changed = true;
     for (const candidate of candidates) {
       if (candidate.stripOnly) continue;
+
+      // Safety: don't recover tool calls whose grammar parsed to an empty
+      // argument object. These are almost always malformed GLM/XML fragments
+      // (e.g. `<tool_call>write</tool_call>`) that would otherwise crash as a
+      // real tool invocation with missing required properties.
+      if (Object.keys(candidate.arguments).length === 0) {
+        if (config.debug) {
+          process.stderr.write(
+            `[pi-tool-repair] grammar-repair skipping ${candidate.grammar}:${candidate.name} ` +
+            "(empty arguments, likely malformed grammar)\n",
+          );
+        }
+        continue;
+      }
+
       recoveredCalls.push({
         name: candidate.name,
         arguments: candidate.arguments,

package/src/index.ts

@@ -141,7 +141,8 @@ const GRAMMAR_TOKEN_LEAKS = [
   { tag: "</arg_value>", at: "end" as const },
 ];
 
-export function stripGrammarTokenLeaksInPlace(obj: Record<string, unknown>): void {
+export function stripGrammarTokenLeaksInPlace(obj: Record<string, unknown>): boolean {
+  let changed = false;
   for (const key of Object.keys(obj)) {
     const value = obj[key];
     let newKey = key;
@@ -157,6 +158,7 @@ export function stripGrammarTokenLeaksInPlace(obj: Record<string, unknown>): voi
     if (newKey !== key) {
       obj[newKey] = value;
       delete obj[key];
+      changed = true;
     }
 
     if (typeof value === "string") {
@@ -168,7 +170,11 @@ export function stripGrammarTokenLeaksInPlace(obj: Record<string, unknown>): voi
           s = s.slice(0, -tag.length);
         }
       }
-      obj[newKey] = s.trim();
+      const trimmed = s.trim();
+      if (trimmed !== value) {
+        obj[newKey] = trimmed;
+        changed = true;
+      }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
         const item = value[i];
@@ -181,15 +187,22 @@ export function stripGrammarTokenLeaksInPlace(obj: Record<string, unknown>): voi
               s = s.slice(0, -tag.length);
             }
           }
-          value[i] = s.trim();
+          const trimmed = s.trim();
+          if (trimmed !== item) {
+            value[i] = trimmed;
+            changed = true;
+          }
         } else if (item && typeof item === "object") {
-          stripGrammarTokenLeaksInPlace(item as Record<string, unknown>);
+          const nestedChanged = stripGrammarTokenLeaksInPlace(item as Record<string, unknown>);
+          if (nestedChanged) changed = true;
         }
       }
     } else if (value && typeof value === "object") {
-      stripGrammarTokenLeaksInPlace(value as Record<string, unknown>);
+      const nestedChanged = stripGrammarTokenLeaksInPlace(value as Record<string, unknown>);
+      if (nestedChanged) changed = true;
     }
   }
+  return changed;
 }
 
 // ─── Phase 2: Repair Rules ────────────────────────────────────────────────────

package/tool-repair.ts

@@ -134,8 +134,31 @@ export default function (pi: ExtensionAPI) {
   pi.on("message_end", (event) => {
     if (event.message.role !== "assistant") return;
 
-    // Phase 1.5: Phantom toolUse normalization (always-on)
     const currentMessage = event.message as unknown as MinimalAssistantMessage;
+
+    // Phase 1.4: Strip leaked grammar tokens from existing pi toolCall blocks.
+    // These can leak from GLM-style grammars straight into the parsed argument
+    // keys (e.g. "<arg_key>command" instead of "command"). We have to repair
+    // them here, before pi preflights and validates the tool calls.
+    let toolCallArgsChanged = false;
+    if (Array.isArray(currentMessage.content)) {
+      for (const part of currentMessage.content) {
+        if (
+          part && typeof part === "object" && !Array.isArray(part) &&
+          (part as Record<string, unknown>).type === "toolCall"
+        ) {
+          const args = (part as Record<string, unknown>).arguments;
+          if (
+            args && typeof args === "object" && !Array.isArray(args) &&
+            stripGrammarTokenLeaksInPlace(args as Record<string, unknown>)
+          ) {
+            toolCallArgsChanged = true;
+          }
+        }
+      }
+    }
+
+    // Phase 1.5: Phantom toolUse normalization (always-on)
     const phantomResult = normalizePhantomToolUse(currentMessage);
 
     if (phantomResult.changed) {
@@ -174,7 +197,10 @@ export default function (pi: ExtensionAPI) {
     }
 
     // Phase 1: Grammar leak repair (opt-in)
-    if (!grammarRepairConfig.enabled) return;
+    if (!grammarRepairConfig.enabled) {
+      if (toolCallArgsChanged) return { message: currentMessage as any };
+      return;
+    }
 
     const knownTools = new Set(
       safeGetActiveTools(pi)
@@ -187,9 +213,9 @@ export default function (pi: ExtensionAPI) {
       knownTools,
     );
 
-    if (!result.changed) return;
+    if (!result.changed && !toolCallArgsChanged) return;
 
-    if (grammarRepairConfig.debug) {
+    if (grammarRepairConfig.debug && result.changed) {
       const calls = result.recoveredCalls.map((call) => `${call.grammar}:${call.name}`).join(",") || "none";
       process.stderr.write(
         `[pi-tool-repair] grammar-repair mode=${grammarRepairConfig.mode} ` +