pi-tool-repair 0.1.12 → 0.2.0

package/README.md

@@ -145,6 +145,24 @@ Modes:
 | `recover` | Strip leaked markup and append recovered pi `toolCall` blocks. |
 | `strip`   | Strip leaked markup only; do not execute recovered calls.      |
 
+#### Per-model enablement
+
+If only some of your models leak grammar — common with local servers such as llama.cpp, vLLM, or Ollama — auto-enable recovery per model id with `leakModels`. Entries are case-insensitive regex fragments matched against the active model id:
+
+```json
+{
+  "grammarRepair": {
+    "leakModels": ["kimi", "qwen3", "gguf"]
+  }
+}
+```
+
+Recovery turns on whenever the session's model id matches a pattern. Global `enabled: true` takes precedence over `leakModels`, so models with reliable native tool calling stay untouched. Regex entries that fail to compile are ignored.
+
+#### What the model sees on the next request
+
+Every repair runs on pi's `message_end` hook, where the repaired message is replaced in place — the corrected call, not the model's original output, is what pi writes to the session file and resends on later requests. With `mode: "recover"`, leaked tool-call text is likewise converted into real `toolCall` blocks before persistence, so subsequent requests show the model a properly formed call plus its tool results: an in-context correction loop instead of a silent execute-time patch. Local models benefit the most since there is no prompt-cache penalty for the rewritten history; providers that cache by prefix may treat the first turn after a repair as a cache miss.
+
 Safety gates:
 
 - `requireKnownTool: true` only recovers calls whose name is in pi's active tool registry.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tool-repair",
-  "version": "0.1.12",
+  "version": "0.2.0",
   "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

@@ -24,6 +24,9 @@ export interface GrammarRepairConfig {
   mode: GrammarRepairMode;
   requireKnownTool: boolean;
   debug: boolean;
+  // Case-insensitive regex fragments that auto-enable grammar repair when the
+  // active model id matches one of them. Ignored while `enabled` is true.
+  leakModels?: string[];
 }
 
 export interface ExtensionFileConfig {
@@ -119,15 +122,52 @@ export function normalizeGrammarRepairConfig(raw: Partial<GrammarRepairConfig> =
     ? raw.grammars.filter((name): name is GrammarName => grammarSet.has(name as GrammarName))
     : ALL_GRAMMARS;
 
+  const leakModels = normalizeLeakModels(raw.leakModels);
+
   return {
     enabled: raw.enabled ?? DEFAULT_GRAMMAR_REPAIR_CONFIG.enabled,
     grammars: grammars.length > 0 ? grammars : ALL_GRAMMARS,
     mode: raw.mode === "strip" ? "strip" : "recover",
     requireKnownTool: raw.requireKnownTool ?? DEFAULT_GRAMMAR_REPAIR_CONFIG.requireKnownTool,
     debug: raw.debug ?? DEFAULT_GRAMMAR_REPAIR_CONFIG.debug,
+    ...(leakModels ? { leakModels } : {}),
   };
 }
 
+const compileLeakModelPattern = (pattern: string): RegExp | undefined => {
+  try {
+    return new RegExp(pattern, "i");
+  } catch {
+    return undefined;
+  }
+};
+
+function normalizeLeakModels(raw: unknown): string[] | undefined {
+  if (!Array.isArray(raw)) return undefined;
+  const valid = raw.filter(
+    (pattern): pattern is string =>
+      typeof pattern === "string" && compileLeakModelPattern(pattern) !== undefined,
+  );
+  return valid.length > 0 ? valid : undefined;
+}
+
+// Enables grammar repair for the current message when the active model id
+// matches a configured leakModels pattern. Global `enabled: true` always wins,
+// so models with native tool calling keep the recovery path off unless listed.
+export function resolveGrammarRepairForModel(
+  config: GrammarRepairConfig,
+  model: { id?: string } | null | undefined,
+): GrammarRepairConfig {
+  if (config.enabled) return config;
+  const patterns = config.leakModels;
+  if (!patterns || patterns.length === 0) return config;
+  const modelId = model?.id;
+  if (typeof modelId !== "string" || modelId.length === 0) return config;
+  return patterns.some((pattern) => compileLeakModelPattern(pattern)?.test(modelId))
+    ? { ...config, enabled: true }
+    : config;
+}
+
 export function repairAssistantMessageGrammarLeaks(
   message: MinimalAssistantMessage,
   config: GrammarRepairConfig,

package/tool-repair.ts

@@ -17,6 +17,7 @@ import {
   logRepair,
   loadGrammarRepairConfig,
   repairAssistantMessageGrammarLeaks,
+  resolveGrammarRepairForModel,
   repairAssistantToolCallInputs,
   normalizePhantomToolUse,
   type MinimalAssistantMessage,
@@ -117,25 +118,26 @@ export default function (pi: ExtensionAPI) {
       if (model && hasAnchorBleedBug(model) && stripAnchorBleedInPlace(args)) changed = true;
     }
 
-    if (grammarRepairConfig.enabled) {
+    const effectiveGrammarRepairConfig = resolveGrammarRepairForModel(grammarRepairConfig, model);
+    if (effectiveGrammarRepairConfig.enabled) {
       const knownTools = new Set(
         safeGetActiveTools(pi)
           .filter((name): name is string => typeof name === "string" && name.length > 0),
       );
       const grammarResult = repairAssistantMessageGrammarLeaks(
         message,
-        grammarRepairConfig,
+        effectiveGrammarRepairConfig,
         knownTools,
       );
       if (grammarResult.changed) {
         message = grammarResult.message;
         changed = true;
-        if (grammarRepairConfig.debug) {
+        if (effectiveGrammarRepairConfig.debug) {
           const calls = grammarResult.recoveredCalls
             .map((call) => `${call.grammar}:${call.name}`)
             .join(",") || "none";
           process.stderr.write(
-            `[pi-tool-repair] grammar-repair mode=${grammarRepairConfig.mode} ` +
+            `[pi-tool-repair] grammar-repair mode=${effectiveGrammarRepairConfig.mode} ` +
             `stripped=${grammarResult.strippedRanges} recovered=${calls}\n`,
           );
         }