@probelabs/probe 0.6.0-rc258 → 0.6.0-rc260

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc258",
+  "version": "0.6.0-rc260",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/ProbeAgent.js

@@ -59,6 +59,7 @@ import {
   attemptCompletionToolDefinition,
   editToolDefinition,
   createToolDefinition,
+  multiEditToolDefinition,
   googleSearchToolDefinition,
   urlContextToolDefinition,
   attemptCompletionSchema,
@@ -964,6 +965,9 @@ export class ProbeAgent {
       if (wrappedTools.createToolInstance && isToolAllowed('create')) {
         this.toolImplementations.create = wrappedTools.createToolInstance;
       }
+      if (wrappedTools.multiEditToolInstance && isToolAllowed('multi_edit')) {
+        this.toolImplementations.multi_edit = wrappedTools.multiEditToolInstance;
+      }
     }
 
     // Store wrapped tools for ACP system
@@ -2565,6 +2569,9 @@ ${extractGuidance}
     if (this.allowEdit && isToolAllowed('create')) {
       toolDefinitions += `${createToolDefinition}\n`;
     }
+    if (this.allowEdit && isToolAllowed('multi_edit')) {
+      toolDefinitions += `${multiEditToolDefinition}\n`;
+    }
     // Bash tool (require both enableBash flag AND allowedTools permission)
     if (this.enableBash && isToolAllowed('bash')) {
       toolDefinitions += `${bashToolDefinition}\n`;
@@ -2670,6 +2677,9 @@ The configuration is loaded from src/config.js lines 15-25 which contains the da
     if (this.allowEdit && isToolAllowed('create')) {
       availableToolsList += '- create: Create new files with specified content.\n';
     }
+    if (this.allowEdit && isToolAllowed('multi_edit')) {
+      availableToolsList += '- multi_edit: Apply multiple file edits in one call using a JSON array of operations.\n';
+    }
     if (this.enableDelegate && isToolAllowed('delegate')) {
       availableToolsList += '- delegate: Delegate big distinct tasks to specialized probe subagents.\n';
     }
@@ -3430,6 +3440,9 @@ Follow these instructions carefully:
           if (this.allowEdit && this.allowedTools.isEnabled('create')) {
             validTools.push('create');
           }
+          if (this.allowEdit && this.allowedTools.isEnabled('multi_edit')) {
+            validTools.push('multi_edit');
+          }
           // Bash tool (require both enableBash flag AND allowedTools permission)
           if (this.enableBash && this.allowedTools.isEnabled('bash')) {
             validTools.push('bash');

package/src/agent/bashCommandUtils.js

@@ -127,6 +127,8 @@ export function parseSimpleCommand(command) {
     /&&/,           // Logical AND
     /\|\|/,         // Logical OR
     /(?<!\\);/,     // Command separator (but not escaped \;)
+    /\n/,           // Newline command separator (multi-line commands)
+    /\r/,           // Carriage return (CRLF line endings)
     /&$/,           // Background execution
     /\$\(/,         // Command substitution $()
     /`/,            // Command substitution ``
@@ -260,6 +262,7 @@ export function isComplexPattern(pattern) {
     /&&/,           // Logical AND
     /\|\|/,         // Logical OR
     /;/,            // Command separator
+    /\n/,           // Newline command separator
     /&$/,           // Background execution
     /\$\(/,         // Command substitution $()
     /`/,            // Command substitution ``

package/src/agent/bashPermissions.js

@@ -402,6 +402,29 @@ export class BashPermissionChecker {
           i++;
           continue;
         }
+        // Check for newline (command separator in multi-line scripts)
+        // Also handle \r\n (CRLF) line endings
+        if (char === '\n' || (char === '\r' && nextChar === '\n')) {
+          if (current.trim()) {
+            components.push(current.trim());
+          }
+          current = '';
+          if (char === '\r') {
+            i += 2; // Skip \r\n
+          } else {
+            i++;
+          }
+          continue;
+        }
+        if (char === '\r') {
+          // Bare \r without \n
+          if (current.trim()) {
+            components.push(current.trim());
+          }
+          current = '';
+          i++;
+          continue;
+        }
       }
 
       current += char;

package/src/agent/probeTool.js

@@ -256,6 +256,15 @@ export function createWrappedTools(baseTools) {
     );
   }
 
+  // Wrap multi_edit tool
+  if (baseTools.multiEditTool) {
+    wrappedTools.multiEditToolInstance = wrapToolWithEmitter(
+      baseTools.multiEditTool,
+      'multi_edit',
+      baseTools.multiEditTool.execute
+    );
+  }
+
   return wrappedTools;
 }
 

package/src/agent/schemaUtils.js

@@ -266,6 +266,36 @@ function normalizeJsonQuotes(str) {
   return result;
 }
 
+/**
+ * Check if a code block is embedded within a structured markdown document.
+ * Used to avoid extracting embedded JSON examples from markdown text.
+ * Issue #456: attempt_completion results containing markdown with JSON code block
+ * documentation examples were having the examples extracted as structured output.
+ *
+ * Normal AI behavior: AI wraps JSON answer in a code block with brief explanation text.
+ * Issue #456: AI returns a markdown document that contains JSON code blocks as examples.
+ *
+ * We distinguish these by checking if the surrounding text contains markdown structural
+ * elements (headings) which indicate a document rather than a brief explanation.
+ *
+ * @param {string} text - The full trimmed text
+ * @param {RegExpMatchArray} match - The regex match for the code block
+ * @returns {boolean} - true if the code block is embedded in a markdown document
+ */
+function isCodeBlockEmbeddedInDocument(text, match) {
+  const beforeBlock = text.substring(0, match.index).trim();
+  const afterBlock = text.substring(match.index + match[0].length).trim();
+
+  // Check if surrounding text contains markdown headings (lines starting with #)
+  // This is a strong signal that the content is a structured document, not just explanation text
+  const hasMarkdownHeadings = /^#{1,6}\s/m.test(beforeBlock) || /^#{1,6}\s/m.test(afterBlock);
+  if (hasMarkdownHeadings) {
+    return true;
+  }
+
+  return false;
+}
+
 /**
  * Clean AI response by extracting JSON content when response contains JSON
  * Only processes responses that contain JSON structures { or [
@@ -311,15 +341,20 @@ export function cleanSchemaResponse(response) {
   }
 
   // First, look for JSON after code block markers - similar to mermaid extraction
+  // Only extract from code blocks when they are the primary content (not embedded examples in markdown).
+  // Issue #456: When attempt_completion result contains markdown with embedded JSON code blocks
+  // as documentation examples, extracting those blocks produces wrong structured output.
+  // We check that there's no significant text content outside the code block.
+
   // Try with json language specifier
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
-  if (jsonBlockMatch) {
+  if (jsonBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, jsonBlockMatch)) {
     return normalizeJsonQuotes(jsonBlockMatch[1].trim());
   }
 
   // Try any code block with JSON content
   const anyBlockMatch = trimmed.match(/```\s*\n([{\[][\s\S]*?[}\]])\s*```/);
-  if (anyBlockMatch) {
+  if (anyBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, anyBlockMatch)) {
     return normalizeJsonQuotes(anyBlockMatch[1].trim());
   }
 
@@ -331,7 +366,7 @@ export function cleanSchemaResponse(response) {
 
   for (const pattern of codeBlockPatterns) {
     const match = trimmed.match(pattern);
-    if (match) {
+    if (match && !isCodeBlockEmbeddedInDocument(trimmed, match)) {
       return normalizeJsonQuotes(match[1].trim());
     }
   }
@@ -345,10 +380,11 @@ export function cleanSchemaResponse(response) {
   }
 
   // Look for code block start followed immediately by JSON
+  // Only extract if the code block is not embedded in a structured markdown document
   const codeBlockStartPattern = /```(?:json)?\s*\n?\s*([{\[])/;
   const codeBlockMatch = trimmed.match(codeBlockStartPattern);
 
-  if (codeBlockMatch) {
+  if (codeBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, codeBlockMatch)) {
     const startIndex = codeBlockMatch.index + codeBlockMatch[0].length - 1; // Position of the bracket
 
     // Find the matching closing bracket

package/src/agent/tools.js

@@ -10,6 +10,7 @@ import {
   bashTool,
   editTool,
   createTool,
+  multiEditTool,
   DEFAULT_SYSTEM_MESSAGE,
   attemptCompletionSchema,
   attemptCompletionToolDefinition,
@@ -23,6 +24,7 @@ import {
   bashSchema,
   editSchema,
   createSchema,
+  multiEditSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
@@ -33,6 +35,7 @@ import {
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,
+  multiEditToolDefinition,
   googleSearchToolDefinition,
   urlContextToolDefinition,
   parseXmlToolCall
@@ -87,6 +90,9 @@ export function createTools(configOptions) {
   if (configOptions.allowEdit && isToolAllowed('create')) {
     tools.createTool = createTool(configOptions);
   }
+  if (configOptions.allowEdit && isToolAllowed('multi_edit')) {
+    tools.multiEditTool = multiEditTool(configOptions);
+  }
   return tools;
 }
 
@@ -114,6 +120,7 @@ export {
   bashSchema,
   editSchema,
   createSchema,
+  multiEditSchema,
   attemptCompletionSchema,
   searchToolDefinition,
   queryToolDefinition,
@@ -125,6 +132,7 @@ export {
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,
+  multiEditToolDefinition,
   attemptCompletionToolDefinition,
   googleSearchToolDefinition,
   urlContextToolDefinition,

package/src/index.js

@@ -44,13 +44,15 @@ import {
 import {
 	editSchema,
 	createSchema,
+	multiEditSchema,
 	editToolDefinition,
-	createToolDefinition
+	createToolDefinition,
+	multiEditToolDefinition
 } from './tools/edit.js';
 import { searchTool, queryTool, extractTool, delegateTool, analyzeAllTool } from './tools/vercel.js';
 import { createExecutePlanTool, getExecutePlanToolDefinition, createCleanupExecutePlanTool, getCleanupExecutePlanToolDefinition } from './tools/executePlan.js';
 import { bashTool } from './tools/bash.js';
-import { editTool, createTool } from './tools/edit.js';
+import { editTool, createTool, multiEditTool } from './tools/edit.js';
 import { FileTracker } from './tools/fileTracker.js';
 import { ProbeAgent } from './agent/ProbeAgent.js';
 import { SimpleTelemetry, SimpleAppTracer, initializeSimpleTelemetryFromOptions } from './agent/simpleTelemetry.js';
@@ -99,6 +101,7 @@ export {
 	bashTool,
 	editTool,
 	createTool,
+	multiEditTool,
 	FileTracker,
 	// Export tool instances
 	listFilesToolInstance,
@@ -115,6 +118,7 @@ export {
 	bashSchema,
 	editSchema,
 	createSchema,
+	multiEditSchema,
 	// Export tool definitions
 	searchToolDefinition,
 	queryToolDefinition,
@@ -127,6 +131,7 @@ export {
 	bashToolDefinition,
 	editToolDefinition,
 	createToolDefinition,
+	multiEditToolDefinition,
 	googleSearchToolDefinition,
 	urlContextToolDefinition,
 	// Export parser function

package/src/tools/common.js

@@ -5,7 +5,7 @@
 
 import { z } from 'zod';
 import { resolve, isAbsolute } from 'path';
-import { editSchema, createSchema } from './edit.js';
+import { editSchema, createSchema, multiEditSchema } from './edit.js';
 import { taskSchema } from '../agent/tasks/taskTool.js';
 
 // Common schemas for tool parameters (used for internal execution after XML parsing)
@@ -492,7 +492,8 @@ function getValidParamsForTool(toolName) {
 		task: taskSchema,
 		attempt_completion: attemptCompletionSchema,
 		edit: editSchema,
-		create: createSchema
+		create: createSchema,
+		multi_edit: multiEditSchema
 	};
 
 	const schema = schemaMap[toolName];
@@ -538,6 +539,15 @@ export function unescapeXmlEntities(str) {
 		.replace(/&/g, '&');
 }
 
+// Parameters that contain arbitrary code/file content — use lastIndexOf for closing tag
+// to handle cases where the content itself contains the closing tag string.
+const RAW_CONTENT_PARAMS = new Set(['content', 'new_string', 'old_string']);
+
+// Tools whose content can include their own closing tag string (e.g., file content
+// containing </create> or </edit>). Use lastIndexOf for outer tag boundary, same
+// strategy already used for attempt_completion.
+const LAST_INDEX_TOOLS = new Set(['attempt_completion', 'create', 'edit']);
+
 // Simple XML parser helper - safer string-based approach
 export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 	// Find the tool that appears EARLIEST in the string
@@ -564,13 +574,13 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 	const closeTag = `</${toolName}>`;
 	const openIndex = earliestOpenIndex;
 
-	// For attempt_completion, use lastIndexOf to find the LAST occurrence of closing tag
-	// This prevents issues where the content contains the closing tag string (e.g., in regex patterns)
-	// For other tools, use indexOf from the opening tag position
+	// For tools that contain arbitrary content (file content, code), use lastIndexOf
+	// to find the LAST occurrence of the closing tag. This prevents issues where the
+	// content itself contains the closing tag string (e.g., file content with </create>).
+	// For other tools, use indexOf from the opening tag position.
 	let closeIndex;
-	if (toolName === 'attempt_completion') {
+	if (LAST_INDEX_TOOLS.has(toolName)) {
 		// Find the last occurrence of the closing tag in the entire string
-		// This assumes attempt_completion doesn't have nested tags of the same name
 		closeIndex = xmlString.lastIndexOf(closeTag);
 		// Make sure the closing tag is after the opening tag
 		if (closeIndex !== -1 && closeIndex <= openIndex + openTag.length) {
@@ -610,7 +620,19 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 			continue; // Parameter not found
 		}
 
-		let paramCloseIndex = innerContent.indexOf(paramCloseTag, paramOpenIndex + paramOpenTag.length);
+		// For raw content params (file content, code), use lastIndexOf to find the
+		// LAST closing tag — the content itself may contain the closing tag string.
+		// For other params (file_path, overwrite, etc.), use indexOf (first match).
+		let paramCloseIndex;
+		if (RAW_CONTENT_PARAMS.has(paramName)) {
+			paramCloseIndex = innerContent.lastIndexOf(paramCloseTag);
+			// Ensure it's after the opening tag
+			if (paramCloseIndex !== -1 && paramCloseIndex <= paramOpenIndex + paramOpenTag.length) {
+				paramCloseIndex = -1;
+			}
+		} else {
+			paramCloseIndex = innerContent.indexOf(paramCloseTag, paramOpenIndex + paramOpenTag.length);
+		}
 
 		// Handle unclosed parameter tags - use content until next tag or end of content
 		if (paramCloseIndex === -1) {
@@ -626,23 +648,34 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 			paramCloseIndex = nextTagIndex;
 		}
 
-		let paramValue = unescapeXmlEntities(innerContent.substring(
+		const rawValue = innerContent.substring(
 			paramOpenIndex + paramOpenTag.length,
 			paramCloseIndex
-		).trim());
-
-		// Basic type inference (can be improved)
-		if (paramValue.toLowerCase() === 'true') {
-			paramValue = true;
-		} else if (paramValue.toLowerCase() === 'false') {
-			paramValue = false;
-		} else if (!isNaN(paramValue) && paramValue.trim() !== '') {
-			// Check if it's potentially a number (handle integers and floats)
-			const num = Number(paramValue);
-			if (Number.isFinite(num)) { // Use Number.isFinite to avoid Infinity/NaN
-				paramValue = num;
+		);
+
+		// For raw content params, preserve whitespace (only strip XML formatting newlines).
+		// For other params, trim all whitespace.
+		let paramValue;
+		if (RAW_CONTENT_PARAMS.has(paramName)) {
+			paramValue = unescapeXmlEntities(rawValue.replace(/^\n/, '').replace(/\n$/, ''));
+		} else {
+			paramValue = unescapeXmlEntities(rawValue.trim());
+		}
+
+		// Type coercion for non-content params only (content/new_string/old_string must stay strings)
+		if (!RAW_CONTENT_PARAMS.has(paramName)) {
+			if (paramValue.toLowerCase() === 'true') {
+				paramValue = true;
+			} else if (paramValue.toLowerCase() === 'false') {
+				paramValue = false;
+			} else if (!isNaN(paramValue) && paramValue.trim() !== '') {
+				// Check if it's potentially a number (handle integers and floats)
+				const num = Number(paramValue);
+				if (Number.isFinite(num)) { // Use Number.isFinite to avoid Infinity/NaN
+					paramValue = num;
+				}
+				// Keep as string if not a valid finite number
 			}
-			// Keep as string if not a valid finite number
 		}
 
 		params[paramName] = paramValue;
@@ -707,7 +740,7 @@ export function detectUnrecognizedToolCall(xmlString, validTools) {
 	const knownToolNames = [
 		'search', 'query', 'extract', 'listFiles', 'searchFiles',
 		'listSkills', 'useSkill', 'readImage', 'edit',
-		'create', 'delegate', 'bash', 'task', 'attempt_completion',
+		'create', 'multi_edit', 'delegate', 'bash', 'task', 'attempt_completion',
 		'attempt_complete', 'read_file', 'write_file', 'run_command',
 		'grep', 'find', 'cat', 'list_directory'
 	];

package/src/tools/edit.js

@@ -363,7 +363,7 @@ Parameters:
       required: ['file_path', 'new_string']
     },
 
-    execute: async ({ file_path, old_string, new_string, replace_all = false, symbol, position, start_line, end_line }) => {
+    execute: async ({ file_path, old_string, new_string, replace_all = false, symbol, position, start_line, end_line, workingDirectory }) => {
       try {
         // Validate input parameters
         if (!file_path || typeof file_path !== 'string' || file_path.trim() === '') {
@@ -373,8 +373,9 @@ Parameters:
           return `Error editing file: Invalid new_string - must be a string. Provide the replacement content as a string value (empty string "" is valid for deletions).`;
         }
 
-        // Resolve the file path
-        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(cwd || process.cwd(), file_path);
+        // Resolve the file path (workingDirectory from runtime takes priority over cwd from tool creation)
+        const effectiveCwd = workingDirectory || cwd || process.cwd();
+        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(effectiveCwd, file_path);
 
         if (debug) {
           console.error(`[Edit] Attempting to edit file: ${resolvedPath}`);
@@ -530,7 +531,7 @@ Important:
       required: ['file_path', 'content']
     },
 
-    execute: async ({ file_path, content, overwrite = false }) => {
+    execute: async ({ file_path, content, overwrite = false, workingDirectory }) => {
       try {
         // Validate input parameters
         if (!file_path || typeof file_path !== 'string' || file_path.trim() === '') {
@@ -540,8 +541,9 @@ Important:
           return `Error creating file: Invalid content - must be a string. Provide the file content as a string value (empty string "" is valid for an empty file).`;
         }
 
-        // Resolve the file path
-        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(cwd || process.cwd(), file_path);
+        // Resolve the file path (workingDirectory from runtime takes priority over cwd from tool creation)
+        const effectiveCwd = workingDirectory || cwd || process.cwd();
+        const resolvedPath = isAbsolute(file_path) ? file_path : resolve(effectiveCwd, file_path);
 
         if (debug) {
           console.error(`[Create] Attempting to create file: ${resolvedPath}`);
@@ -587,6 +589,86 @@ Important:
   });
 };
 
+/**
+ * Multi-edit tool — apply multiple edit operations in a single call.
+ * Reuses the edit tool internally; edits are applied sequentially.
+ *
+ * @param {Object} [options] - Same configuration as editTool
+ * @returns {Object} Configured multi_edit tool
+ */
+export const multiEditTool = (options = {}) => {
+  const editInstance = editTool(options);
+
+  return tool({
+    name: 'multi_edit',
+    description: 'Apply multiple file edits in a single tool call. Accepts a JSON array of edit operations.',
+
+    inputSchema: {
+      type: 'object',
+      properties: {
+        edits: {
+          type: 'string',
+          description: 'JSON array of edit operations. Each object supports: file_path, old_string, new_string, replace_all, symbol, position, start_line, end_line.'
+        }
+      },
+      required: ['edits']
+    },
+
+    execute: async ({ edits: rawEdits }) => {
+      let edits;
+      if (typeof rawEdits === 'string') {
+        try {
+          edits = JSON.parse(rawEdits);
+        } catch (e) {
+          return `Error: Invalid JSON in edits parameter - ${e.message}. Provide a raw JSON array between <edits> tags.`;
+        }
+      } else if (Array.isArray(rawEdits)) {
+        edits = rawEdits;
+      } else {
+        return 'Error: edits must be a JSON array of edit operations.';
+      }
+
+      if (!Array.isArray(edits) || edits.length === 0) {
+        return 'Error: edits must be a non-empty JSON array.';
+      }
+      if (edits.length > 50) {
+        return `Error: Too many edits (${edits.length}). Maximum 50 per batch.`;
+      }
+
+      const results = [];
+      let successCount = 0;
+      let failCount = 0;
+
+      for (let i = 0; i < edits.length; i++) {
+        const editOp = edits[i];
+        if (!editOp || typeof editOp !== 'object' || Array.isArray(editOp)) {
+          results.push(`[${i + 1}] FAIL: Invalid edit operation - must be an object`);
+          failCount++;
+          continue;
+        }
+        try {
+          const result = await editInstance.execute(editOp);
+          const isError = typeof result === 'string' && result.startsWith('Error');
+          if (isError) {
+            results.push(`[${i + 1}] FAIL: ${result}`);
+            failCount++;
+          } else {
+            results.push(`[${i + 1}] OK: ${result}`);
+            successCount++;
+          }
+        } catch (error) {
+          results.push(`[${i + 1}] FAIL: ${error.message}`);
+          failCount++;
+        }
+      }
+
+      const summary = `Multi-edit: ${successCount}/${edits.length} succeeded` +
+        (failCount > 0 ? `, ${failCount} failed` : '');
+      return summary + '\n\n' + results.join('\n');
+    }
+  });
+};
+
 // Export schemas for tool definitions
 export const editSchema = {
   type: 'object',
@@ -647,9 +729,21 @@ export const createSchema = {
   required: ['file_path', 'content']
 };
 
+export const multiEditSchema = {
+  type: 'object',
+  properties: {
+    edits: {
+      type: 'string',
+      description: 'JSON array of edit operations'
+    }
+  },
+  required: ['edits']
+};
+
 // Tool descriptions for XML definitions
 export const editDescription = 'Edit files using text replacement, AST-aware symbol operations, or line-targeted editing. Supports fuzzy matching for text edits and optional hash-based integrity verification for line edits.';
 export const createDescription = 'Create new files with specified content. Will create parent directories if needed.';
+export const multiEditDescription = 'Apply multiple file edits in a single tool call. Accepts a JSON array of edit operations, each supporting the same modes as the edit tool.';
 
 // XML tool definitions
 export const editToolDefinition = `
@@ -808,3 +902,42 @@ Examples:
 This is a new project.</content>
 <overwrite>true</overwrite>
 </create>`;
+
+export const multiEditToolDefinition = `
+## multi_edit
+Description: ${multiEditDescription}
+
+Apply multiple edits in one call. Each operation in the array uses the same parameters as the edit tool:
+- file_path, old_string, new_string (text mode)
+- file_path, symbol, new_string (symbol replace)
+- file_path, symbol, new_string, position (symbol insert)
+- file_path, start_line, new_string (line-targeted)
+
+Edits are applied sequentially. Failures do not stop remaining edits. Maximum 50 edits per call.
+
+Parameters:
+- edits: (required) JSON array of edit objects. Place raw JSON between tags.
+
+When to use multi_edit vs edit:
+- Use edit for a single change to one file
+- Use multi_edit when making 2+ related changes across files (e.g., rename a function and update all call sites)
+- Use multi_edit for coordinated multi-file refactoring where order matters
+
+Examples:
+
+Multiple text replacements across files:
+<multi_edit>
+<edits>[
+  {"file_path": "src/main.js", "old_string": "return false;", "new_string": "return true;"},
+  {"file_path": "src/config.js", "old_string": "debug: false", "new_string": "debug: true"}
+]</edits>
+</multi_edit>
+
+Mixed edit modes in one batch:
+<multi_edit>
+<edits>[
+  {"file_path": "src/utils.js", "symbol": "oldHelper", "new_string": "function newHelper() { return 42; }"},
+  {"file_path": "src/main.js", "old_string": "oldHelper()", "new_string": "newHelper()", "replace_all": true},
+  {"file_path": "src/index.js", "start_line": "10", "end_line": "12", "new_string": "export { newHelper };"}
+]</edits>
+</multi_edit>`;

package/src/tools/index.js

@@ -6,7 +6,7 @@
 // Export Vercel AI SDK tool generators
 export { searchTool, queryTool, extractTool, delegateTool } from './vercel.js';
 export { bashTool } from './bash.js';
-export { editTool, createTool } from './edit.js';
+export { editTool, createTool, multiEditTool } from './edit.js';
 
 // Export LangChain tools
 export { createSearchTool, createQueryTool, createExtractTool } from './langchain.js';
@@ -39,10 +39,13 @@ export {
 export {
 	editSchema,
 	createSchema,
+	multiEditSchema,
 	editDescription,
 	createDescription,
+	multiEditDescription,
 	editToolDefinition,
-	createToolDefinition
+	createToolDefinition,
+	multiEditToolDefinition
 } from './edit.js';
 
 // Export system message