fix: repair invalid string escapes in tool-call arguments

Author: elkaix

.changeset/tool-args-escape-repair.md

@@ -0,0 +1,5 @@
+---
+"@pythoughts/pythinker-code": patch
+---
+
+Repair invalid escape sequences in model-written tool arguments instead of failing the tool call.

packages/agent-core/src/loop/tool-call.ts

@@ -300,10 +300,61 @@ export function parseToolCallArguments(
   try {
     return { success: true, data: JSON.parse(raw) as unknown };
   } catch (error) {
+    const repaired = repairInvalidStringEscapes(raw);
+    if (repaired !== null) {
+      try {
+        return { success: true, data: JSON.parse(repaired) as unknown };
+      } catch {
+        // Report the original parse error below.
+      }
+    }
     return { success: false, error: errorMessage(error) };
   }
 }
 
+/**
+ * Models sometimes emit markdown-style escapes (\* \_ \[) inside JSON string
+ * values; strict JSON.parse rejects them while streaming previews tolerate
+ * them, so the call dies only at preflight. Rewrite ONLY invalid escapes to a
+ * literal backslash + character, leaving valid escapes and structure alone.
+ * Returns null when nothing was repaired.
+ */
+function repairInvalidStringEscapes(raw: string): string | null {
+  let result = '';
+  let inString = false;
+  let repaired = false;
+
+  for (let index = 0; index < raw.length; index += 1) {
+    const character = raw[index];
+    if (character === '"') {
+      inString = !inString;
+      result += character;
+      continue;
+    }
+    if (!inString || character !== '\\') {
+      result += character;
+      continue;
+    }
+
+    const next = raw[index + 1];
+    if (next !== undefined && '"\\/bfnrt'.includes(next)) {
+      result += character + next;
+      index += 1;
+      continue;
+    }
+    if (next === 'u' && /^[0-9a-fA-F]{4}$/.test(raw.slice(index + 2, index + 6))) {
+      result += raw.slice(index, index + 6);
+      index += 5;
+      continue;
+    }
+
+    result += '\\\\';
+    repaired = true;
+  }
+
+  return repaired ? result : null;
+}
+
 function validateExecutableToolArgs(tool: ExecutableTool, args: unknown): string | null {
   let validator = validators.get(tool);
   if (validator === undefined) {

packages/agent-core/test/loop/tool-call.e2e.test.ts

@@ -12,6 +12,7 @@ import type { ContentPart } from '@pythoughts/kosong';
 import { describe, expect, it } from 'vitest';
 
 import { createLoopEventDispatcher, runTurn as runTurnImpl, ToolAccesses } from '../../src/loop';
+import { parseToolCallArguments } from '../../src/loop/tool-call';
 import type { Logger } from '../../src/logging';
 import type {
   ExecutableTool,
@@ -118,6 +119,42 @@ function makeTestLogger(): {
   return { log, entries };
 }
 
+describe('parseToolCallArguments', () => {
+  it('repairs markdown-style escapes inside string values', () => {
+    const result = parseToolCallArguments('{"a":"bold \\*text\\* and \\_x"}');
+
+    expect(result).toEqual({ success: true, data: { a: 'bold \\*text\\* and \\_x' } });
+  });
+
+  it('leaves valid escapes unchanged', () => {
+    const raw = '{"a":"line\\nquote\\" uA slash\\\\/"}';
+
+    expect(parseToolCallArguments(raw)).toEqual({ success: true, data: JSON.parse(raw) });
+  });
+
+  it('repairs a bad unicode escape inside a string value', () => {
+    const result = parseToolCallArguments('{"a":"\\u12ZZ"}');
+
+    expect(result).toEqual({ success: true, data: { a: '\\u12ZZ' } });
+  });
+
+  it('returns the original parse error for structurally broken input', () => {
+    const raw = '{"a":"truncated';
+    let originalError = '';
+    try {
+      JSON.parse(raw);
+    } catch (error) {
+      originalError = error instanceof Error ? error.message : String(error);
+    }
+
+    expect(parseToolCallArguments(raw)).toEqual({ success: false, error: originalError });
+  });
+
+  it('does not repair a backslash outside a string', () => {
+    expect(parseToolCallArguments('{\\*"a":1}').success).toBe(false);
+  });
+});
+
 describe('runTurn — tool-call behaviour', () => {
   it('strips enabled intent before hooks, validation, execution, and persistence', async () => {
     const hookArgs: unknown[] = [];