Repair malformed tool call inputs (#578)

Co-authored-by: James Grugett <jahooma@gmail.com>

Author: brandonkachen

common/src/tools/params/__tests__/coerce-to-array.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, it } from 'bun:test'
 import z from 'zod/v4'
 
-import { coerceToArray } from '../utils'
+import { coerceToArray, normalizeReplacementAliases } from '../utils'
 
 describe('coerceToArray', () => {
   it('passes through arrays unchanged', () => {
     expect(coerceToArray(['a', 'b'])).toEqual(['a', 'b'])
-    expect(coerceToArray([{ old: 'x', new: 'y' }])).toEqual([{ old: 'x', new: 'y' }])
+    expect(coerceToArray([{ old: 'x', new: 'y' }])).toEqual([
+      { old: 'x', new: 'y' },
+    ])
     expect(coerceToArray([])).toEqual([])
   })
 
@@ -15,15 +17,20 @@ describe('coerceToArray', () => {
   })
 
   it('wraps a single object in an array', () => {
-    expect(coerceToArray({ old: 'x', new: 'y' })).toEqual([{ old: 'x', new: 'y' }])
+    expect(coerceToArray({ old: 'x', new: 'y' })).toEqual([
+      { old: 'x', new: 'y' },
+    ])
   })
 
   it('wraps a single number in an array', () => {
     expect(coerceToArray(42)).toEqual([42])
   })
 
   it('parses a stringified JSON array', () => {
-    expect(coerceToArray('["file1.ts", "file2.ts"]')).toEqual(['file1.ts', 'file2.ts'])
+    expect(coerceToArray('["file1.ts", "file2.ts"]')).toEqual([
+      'file1.ts',
+      'file2.ts',
+    ])
   })
 
   it('wraps a non-JSON string (does not parse as array)', () => {
@@ -116,3 +123,51 @@ describe('coerceToArray with Zod schemas', () => {
     expect(coercedSchema).toEqual(plainSchema)
   })
 })
+
+describe('normalizeReplacementAliases', () => {
+  it('maps old_str and new_str onto the documented replacement keys', () => {
+    expect(
+      normalizeReplacementAliases({
+        old_str: 'before',
+        new_str: 'after',
+        allowMultiple: true,
+      }),
+    ).toEqual({
+      old_str: 'before',
+      new_str: 'after',
+      old: 'before',
+      new: 'after',
+      allowMultiple: true,
+    })
+  })
+
+  it('maps old_string and new_string onto the documented replacement keys', () => {
+    expect(
+      normalizeReplacementAliases({
+        old_string: 'before',
+        new_string: 'after',
+      }),
+    ).toEqual({
+      old_string: 'before',
+      new_string: 'after',
+      old: 'before',
+      new: 'after',
+    })
+  })
+
+  it('does not overwrite documented replacement keys', () => {
+    expect(
+      normalizeReplacementAliases({
+        old: 'before',
+        new: 'after',
+        old_str: 'ignored',
+        new_str: 'ignored',
+      }),
+    ).toEqual({
+      old: 'before',
+      new: 'after',
+      old_str: 'ignored',
+      new_str: 'ignored',
+    })
+  })
+})

common/src/tools/params/tool/propose-str-replace.ts

@@ -1,6 +1,11 @@
 import z from 'zod/v4'
 
-import { $getNativeToolCallExampleString, coerceToArray, jsonToolResultSchema } from '../utils'
+import {
+  $getNativeToolCallExampleString,
+  coerceToArray,
+  jsonToolResultSchema,
+  normalizeReplacementAliases,
+} from '../utils'
 
 import type { $ToolParams } from '../../constants'
 
@@ -30,33 +35,38 @@ const inputSchema = z
         z
           .array(
             z
-              .object({
-                old: z
-                  .string()
-                  .min(1, 'Old cannot be empty')
-                  .describe(
-                    `The string to replace. This must be an *exact match* of the string you want to replace, including whitespace and punctuation.`,
-                  ),
-                new: z
-                  .string()
-                  .describe(
-                    `The string to replace the corresponding old string with. Can be empty to delete.`,
-                  ),
-                allowMultiple: z
-                  .boolean()
-                  .optional()
-                  .default(false)
-                  .describe(
-                    'Whether to allow multiple replacements of old string.',
-                  ),
-              })
+              .preprocess(
+                normalizeReplacementAliases,
+                z.object({
+                  old: z
+                    .string()
+                    .min(1, 'Old cannot be empty')
+                    .describe(
+                      `The string to replace. This must be an *exact match* of the string you want to replace, including whitespace and punctuation.`,
+                    ),
+                  new: z
+                    .string()
+                    .describe(
+                      `The string to replace the corresponding old string with. Can be empty to delete.`,
+                    ),
+                  allowMultiple: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe(
+                      'Whether to allow multiple replacements of old string.',
+                    ),
+                }),
+              )
               .describe('Pair of old and new strings.'),
           )
           .min(1, 'Replacements cannot be empty'),
       )
       .describe('Array of replacements to make.'),
   })
-  .describe(`Propose string replacements in a file without actually applying them.`)
+  .describe(
+    `Propose string replacements in a file without actually applying them.`,
+  )
 const description = `
 Propose edits to a file without actually applying them. Use this tool when you want to draft changes that will be reviewed before being applied.
 

common/src/tools/params/tool/str-replace.ts

@@ -1,6 +1,11 @@
 import z from 'zod/v4'
 
-import { $getNativeToolCallExampleString, coerceToArray, jsonToolResultSchema } from '../utils'
+import {
+  $getNativeToolCallExampleString,
+  coerceToArray,
+  jsonToolResultSchema,
+  normalizeReplacementAliases,
+} from '../utils'
 
 import type { $ToolParams } from '../../constants'
 
@@ -31,26 +36,29 @@ const inputSchema = z
         z
           .array(
             z
-              .object({
-                old: z
-                  .string()
-                  .min(1, 'Old cannot be empty')
-                  .describe(
-                    `The string to replace. This must be an *exact match* of the string you want to replace, including whitespace and punctuation.`,
-                  ),
-                new: z
-                  .string()
-                  .describe(
-                    `The string to replace the corresponding old string with. Can be empty to delete.`,
-                  ),
-                allowMultiple: z
-                  .boolean()
-                  .optional()
-                  .default(false)
-                  .describe(
-                    'Whether to allow multiple replacements of old string.',
-                  ),
-              })
+              .preprocess(
+                normalizeReplacementAliases,
+                z.object({
+                  old: z
+                    .string()
+                    .min(1, 'Old cannot be empty')
+                    .describe(
+                      `The string to replace. This must be an *exact match* of the string you want to replace, including whitespace and punctuation.`,
+                    ),
+                  new: z
+                    .string()
+                    .describe(
+                      `The string to replace the corresponding old string with. Can be empty to delete.`,
+                    ),
+                  allowMultiple: z
+                    .boolean()
+                    .optional()
+                    .default(false)
+                    .describe(
+                      'Whether to allow multiple replacements of old string.',
+                    ),
+                }),
+              )
               .describe('Pair of old and new strings.'),
           )
           .min(1, 'Replacements cannot be empty'),

common/src/tools/params/utils.ts

@@ -32,6 +32,31 @@ export function coerceToArray(val: unknown): unknown {
   return val
 }
 
+/**
+ * Handles common replacement-key aliases emitted by some models while keeping
+ * the documented schema stable.
+ */
+export function normalizeReplacementAliases(val: unknown): unknown {
+  if (val === null || typeof val !== 'object' || Array.isArray(val)) {
+    return val
+  }
+
+  const replacement = { ...(val as Record<string, unknown>) }
+  for (const [target, aliases] of [
+    ['old', ['old_str', 'old_string']],
+    ['new', ['new_str', 'new_string']],
+  ] as const) {
+    if (replacement[target] !== undefined) {
+      continue
+    }
+    const alias = aliases.find((key) => typeof replacement[key] === 'string')
+    if (alias) {
+      replacement[target] = replacement[alias]
+    }
+  }
+  return replacement
+}
+
 /** Only used for generating tool call strings before all tools are defined.
  *
  * @param toolName - The name of the tool to call