pi-tool-repair 0.3.6 → 0.3.8

package/README.md

@@ -38,6 +38,7 @@ Run `bun run test:host` for the offline real-host load, native codemode/nested-c
 | Bare string as root input | `"/path/to/file"` | `{"path":"/path/to/file"}` |
 | `fabric_exec` code arrays | `{"code":["const x=1;","return x;"]}` | newline-joined `code` |
 | Schema anchor bleed (Kimi K2) | `"^pattern$"` in values | `"pattern"` |
+| Index-suffixed tool names | `bash_1_234456789`, `functions.bash:0` | `bash` |
 | Leaked tool grammar (opt-in) | `<｜DSML｜tool_calls>...` | pi `toolCall` block |
 | Phantom tool use | `stopReason:"toolUse"` with no call | retryable error |
 
@@ -88,6 +89,7 @@ before_provider_request
 model response → message_end
   ├─ strip leaked grammar tokens from native toolCall blocks
   ├─ recover complete leaked grammar calls when enabled
+  ├─ recover index-suffixed tool names that match exactly one active tool
   ├─ validate raw arguments against each active tool's live schema
   ├─ apply only known aliases and schema-directed repairs
   ├─ commit a candidate only when it re-validates
@@ -111,6 +113,7 @@ Pi 0.84 validates tool arguments before emitting `tool_call`. Repair therefore r
 | `coerceNumericString` | `"20"` → `20` when the live schema expects a number |
 | `convertTimeoutMilliseconds` | `timeoutMs` → `timeout` seconds for `bash` |
 | `joinStringArray` | all-string `fabric_exec.code` arrays → one newline-joined string |
+| `recoverMangledToolName` | `bash_1_234456789` / `functions.bash:0` → `bash` when the name is not an active tool, the suffix is only digits and separators, exactly one active tool fits, and the arguments validate against it |
 
 ### Why validate-then-repair
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tool-repair",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "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",
@@ -42,7 +42,7 @@
     "lint:dead": "knip --no-gitignore"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",
     "knip": "6.14.1",

package/src/grammar-repair.ts

@@ -170,24 +170,35 @@ export function resolveGrammarRepairForModel(
 }
 
 // Open models occasionally append index tokens to tool names (for example
-// `bash_1_234456789` for `bash`). Recover the original name only when the
-// trailing part is made up of separators and digits, and prefer the longest
-// known tool so `read_file_1_2` never collapses to `read`. Names that are
-// already known, or whose suffix contains real characters
-// (`read_multiple_files`), are returned untouched.
-const MANGLED_TOOL_SUFFIX = /^[_-\d]+$/;
-
-function recoverMangledToolName(name: string, knownTools: Set<string>): string {
+// `bash_1_234456789` for `bash`), or leak Kimi's call-id shape
+// `functions.{name}:{idx}` into the name. Recover the original name only when
+// the trailing part is made up of separators and digits and exactly one known
+// tool fits, so `read_file_1_2` never collapses to `read` and `s3_2_1` is not
+// guessed when both `s3` and `s3_2` exist. Names that are already known, or
+// whose suffix contains real characters (`read_multiple_files`), are returned
+// untouched.
+const MANGLED_TOOL_PREFIX = "functions.";
+const MANGLED_TOOL_SUFFIX = /^[-_:\d]+$/;
+
+export function recoverMangledToolName(name: string, knownTools: ReadonlySet<string>): string {
   if (knownTools.has(name)) return name;
 
-  let best: string | undefined;
-  for (const tool of knownTools) {
-    if (tool.length >= name.length || !name.startsWith(tool)) continue;
-    if (!MANGLED_TOOL_SUFFIX.test(name.slice(tool.length))) continue;
-    if (best === undefined || tool.length > best.length) best = tool;
+  const bases = name.startsWith(MANGLED_TOOL_PREFIX)
+    ? [name, name.slice(MANGLED_TOOL_PREFIX.length)]
+    : [name];
+  const matches = new Set<string>();
+  for (const base of bases) {
+    if (knownTools.has(base)) {
+      matches.add(base);
+      continue;
+    }
+    for (const tool of knownTools) {
+      if (tool.length >= base.length || !base.startsWith(tool)) continue;
+      if (MANGLED_TOOL_SUFFIX.test(base.slice(tool.length))) matches.add(tool);
+    }
   }
 
-  return best ?? name;
+  return matches.size === 1 ? [...matches][0]! : name;
 }
 
 export function repairAssistantMessageGrammarLeaks(

package/src/index.ts

@@ -7,7 +7,7 @@
 
 // ─── Configuration ────────────────────────────────────────────────────────────
 
-import type { MinimalAssistantMessage } from "./grammar-repair.js";
+import { recoverMangledToolName, type MinimalAssistantMessage } from "./grammar-repair.js";
 import { Value } from "typebox/value";
 
 const isObject = (value: unknown): value is Record<string, unknown> =>
@@ -915,6 +915,52 @@ export function repairInputAgainstLiveSchema(
       };
 }
 
+// A native call whose name is not an active tool fails with "tool not found".
+// When the name is an active tool plus an index suffix (`bash_1_234456789`,
+// `functions.bash:0`), rename it — but only if the arguments validate against
+// that tool's schema, directly or after the usual argument repairs. Otherwise
+// the call is left as-is so Pi reports the original error.
+function recoverMangledToolCallName(
+  name: string,
+  rawInput: unknown,
+  schemas: ReadonlyMap<string, import("typebox").TSchema>,
+  knownTools: ReadonlySet<string>,
+): LiveToolRepairOutcome | undefined {
+  const toolName = recoverMangledToolName(name, knownTools);
+  const schema = toolName === name ? undefined : schemas.get(toolName);
+  if (!schema) return undefined;
+
+  const hint = `Renamed tool "${name}" to "${toolName}"; the trailing index is not part of the tool name.`;
+  const outcome = repairInputAgainstLiveSchema(toolName, rawInput, schema);
+  const repaired = outcome.status === "recovered"
+    ? outcome.repaired
+    : outcome.status === "unchanged" && schemaCheck(schema, rawInput) === true
+      ? rawInput
+      : undefined;
+
+  if (repaired === undefined) {
+    return {
+      toolName: name,
+      status: "unrepairable",
+      input: rawInput,
+      rulesFired: ["recoverMangledToolName", ...outcome.rulesFired],
+      hints: [
+        `${hint} Not applied: the arguments do not validate against "${toolName}".`,
+        ...outcome.hints,
+      ],
+    };
+  }
+
+  return {
+    toolName,
+    status: "recovered",
+    input: rawInput,
+    repaired,
+    rulesFired: ["recoverMangledToolName", ...outcome.rulesFired],
+    hints: [hint, ...outcome.hints],
+  };
+}
+
 export function repairAssistantToolCallInputs(
   message: MinimalAssistantMessage,
   tools: readonly LiveToolSchema[],
@@ -924,12 +970,20 @@ export function repairAssistantToolCallInputs(
   }
 
   const schemas = new Map(tools.map((tool) => [tool.name, tool.parameters]));
+  const knownTools = new Set(schemas.keys());
   const repairs: LiveToolRepairOutcome[] = [];
   let changed = false;
   const content = message.content.map((part) => {
     if (!isObject(part) || part.type !== "toolCall" || typeof part.name !== "string") return part;
     const schema = schemas.get(part.name);
-    if (!schema) return part;
+    if (!schema) {
+      const renamed = recoverMangledToolCallName(part.name, part.arguments, schemas, knownTools);
+      if (!renamed) return part;
+      repairs.push(renamed);
+      if (renamed.status !== "recovered") return part;
+      changed = true;
+      return { ...part, name: renamed.toolName, arguments: renamed.repaired };
+    }
     const outcome = repairInputAgainstLiveSchema(part.name, part.arguments, schema);
     if (outcome.status !== "unchanged") repairs.push(outcome);
     if (outcome.status !== "recovered") return part;