neoagent 2.5.2-beta.9 → 3.0.0

package/server/services/ai/toolResult.js

@@ -91,6 +91,35 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
       });
       break;
 
+    case 'read_files':
+      envelope = trimObject({
+        tool: toolName,
+        count: toolResult?.count || 0,
+        truncated: toolResult?.truncated || false,
+        results: (toolResult?.results || []).slice(0, 6).map((item) => trimObject({
+          path: item.path || item.requestedPath,
+          requestedPath: item.requestedPath,
+          rangeShown: item.rangeShown,
+          error: item.error,
+          content: lineExcerpt(item.content || '', 10, Math.floor(softLimit * 0.22))
+        }))
+      });
+      break;
+
+    case 'replace_file_range':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.success === false || toolResult?.error ? 'error' : 'ok',
+        path: toolResult?.path || toolArgs.path,
+        startLine: toolResult?.startLine || toolArgs.start_line,
+        endLine: toolResult?.endLine || toolArgs.end_line,
+        replacedLines: toolResult?.replacedLines,
+        insertedLines: toolResult?.insertedLines,
+        totalLines: toolResult?.totalLines,
+        error: toolResult?.error
+      });
+      break;
+
     case 'search_files':
       envelope = trimObject({
         tool: toolName,

package/server/services/ai/toolSelector.js

@@ -15,6 +15,22 @@ const ALWAYS_INCLUDE_BUILT_INS = [
   'send_message',
   'send_interim_update',
 ];
+const CORE_FILE_TOOLS = [
+  'read_file',
+  'read_files',
+  'list_directory',
+  'search_files',
+  'edit_file',
+  'replace_file_range',
+  'write_file',
+];
+
+function requiredToolNames(options = {}) {
+  const requiredNames = [...ALWAYS_INCLUDE_BUILT_INS];
+  if (options.widgetId) requiredNames.push('save_widget_snapshot');
+  if (options.includeCoreFileTools) requiredNames.push(...CORE_FILE_TOOLS);
+  return requiredNames;
+}
 
 function compactDescription(value, maxChars = 180) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
@@ -37,8 +53,7 @@ function buildToolCatalog(tools = []) {
 
 function ensureRequiredTools(selectedTools = [], builtInTools = [], options = {}) {
   const limit = Number(options.maxTools) || MAX_TOOLS;
-  const requiredNames = [...ALWAYS_INCLUDE_BUILT_INS];
-  if (options.widgetId) requiredNames.push('save_widget_snapshot');
+  const requiredNames = requiredToolNames(options);
   if (!requiredNames.length) return selectedTools;
 
   const selected = Array.isArray(selectedTools) ? [...selectedTools] : [];
@@ -83,6 +98,7 @@ function selectInitialTools(allTools = [], suggestedNames = [], options = {}) {
 
 function activateTools(currentTools = [], allTools = [], requestedNames = [], options = {}) {
   const knownByName = new Map(allTools.map((tool) => [tool?.name, tool]));
+  const requiredNames = requiredToolNames(options);
   let next = ensureRequiredTools(currentTools, allTools, options);
   const activated = [];
   const evicted = [];
@@ -102,7 +118,7 @@ function activateTools(currentTools = [], allTools = [], requestedNames = [], op
     if (next.some((item) => item?.name === name)) continue;
     if (next.length >= MAX_TOOLS) {
       const replaceIndex = next.findIndex((item) => (
-        !ALWAYS_INCLUDE_BUILT_INS.includes(item?.name)
+        !requiredNames.includes(item?.name)
         && !requested.includes(item?.name)
       ));
       if (replaceIndex === -1) {
@@ -136,6 +152,7 @@ function selectToolsForTask(task, builtInTools = [], mcpTools = [], _options = {
 }
 
 module.exports = {
+  CORE_FILE_TOOLS,
   MAX_TOOLS,
   activateTools,
   buildToolCatalog,

package/server/services/ai/tools.js

@@ -881,16 +881,57 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'read_file',
-            description: 'Read a file from the filesystem. Supports reading specific line ranges for large files.',
+            description: 'Read one workspace file. Supports line ranges for large files. Use workspace file tools for code inspection whenever the files are in the shared workspace.',
             parameters: {
                 type: 'object',
                 properties: {
-                    path: { type: 'string', description: 'Absolute or relative file path' },
+                    path: { type: 'string', description: 'Absolute or relative path inside the per-user workspace' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
                     start_line: { type: 'number', description: 'Starting line number (1-indexed, inclusive)' },
                     end_line: { type: 'number', description: 'Ending line number (1-indexed, inclusive)' },
+                    line_start: { type: 'number', description: 'Alias for start_line; accepted for compatibility with model tool calls' },
+                    line_count: { type: 'number', description: 'Number of lines to read starting at start_line/line_start' },
                     encoding: { type: 'string', description: 'File encoding (default utf-8)' }
                 },
-                required: ['path']
+                required: []
+            }
+        },
+        {
+            name: 'read_files',
+            description: 'Read multiple workspace files or line ranges in one call. Prefer this over repeated single-file reads or shell snippets when inspecting related files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    files: {
+                        type: 'array',
+                        description: 'Files to read. Each item may be a path string or an object with path/file_path plus optional start_line/end_line or line_start/line_count.',
+                        items: {
+                            oneOf: [
+                                { type: 'string', description: 'Path inside the per-user workspace' },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        path: { type: 'string', description: 'Absolute or relative path inside the per-user workspace' },
+                                        file_path: { type: 'string', description: 'Alias for path' },
+                                        start_line: { type: 'number', description: 'Starting line number (1-indexed, inclusive)' },
+                                        end_line: { type: 'number', description: 'Ending line number (1-indexed, inclusive)' },
+                                        line_start: { type: 'number', description: 'Alias for start_line' },
+                                        line_count: { type: 'number', description: 'Number of lines to read from start_line/line_start' },
+                                        encoding: { type: 'string', description: 'File encoding (default utf-8)' }
+                                    },
+                                    required: []
+                                }
+                            ]
+                        }
+                    },
+                    paths: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Convenience alias for reading whole files by path.'
+                    },
+                    encoding: { type: 'string', description: 'Default file encoding for items without encoding (default utf-8)' }
+                },
+                required: []
             }
         },
         {
@@ -900,10 +941,11 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     path: { type: 'string', description: 'File path' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
                     content: { type: 'string', description: 'Content to write' },
                     mode: { type: 'string', enum: ['write', 'append'], description: 'Write mode (default write)' }
                 },
-                required: ['path', 'content']
+                required: ['content']
             }
         },
         {
@@ -913,46 +955,68 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     path: { type: 'string', description: 'File path' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
                     edits: {
                         type: 'array',
                         items: {
                             type: 'object',
                             properties: {
                                 oldText: { type: 'string', description: 'The exact text to replace.' },
-                                newText: { type: 'string', description: 'The replacement text.' }
+                                newText: { type: 'string', description: 'The replacement text.' },
+                                old_text: { type: 'string', description: 'Alias for oldText' },
+                                new_text: { type: 'string', description: 'Alias for newText' }
                             },
-                            required: ['oldText', 'newText']
+                            required: []
                         },
                         description: 'List of text replacements to apply.'
                     }
                 },
-                required: ['path', 'edits']
+                required: ['edits']
+            }
+        },
+        {
+            name: 'replace_file_range',
+            description: 'Replace a 1-indexed inclusive line range in a workspace file. Use this when you know line numbers and exact-text edit_file would be brittle. Read the target range first, then replace only the intended lines.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path inside the per-user workspace' },
+                    file_path: { type: 'string', description: 'Alias for path; accepted for compatibility with model tool calls' },
+                    start_line: { type: 'number', description: 'Starting line number (1-indexed, inclusive)' },
+                    end_line: { type: 'number', description: 'Ending line number (1-indexed, inclusive)' },
+                    startLine: { type: 'number', description: 'Alias for start_line' },
+                    endLine: { type: 'number', description: 'Alias for end_line' },
+                    content: { type: 'string', description: 'Replacement content for the range. Empty string deletes the range.' }
+                },
+                required: ['content']
             }
         },
         {
             name: 'list_directory',
-            description: 'List files and directories with metadata (size, modified time).',
+            description: 'List workspace files and directories with metadata. Omit path to list the workspace root.',
             parameters: {
                 type: 'object',
                 properties: {
-                    path: { type: 'string', description: 'Directory path' },
+                    path: { type: 'string', description: 'Directory path inside the workspace (default ".")' },
                     recursive: { type: 'boolean', description: 'List recursively' },
                     depth: { type: 'number', description: 'Maximum recursion depth (default 1, max 5)' }
                 },
-                required: ['path']
+                required: []
             }
         },
         {
             name: 'search_files',
-            description: 'Search for text patterns across files in a directory (recursive).',
+            description: 'Search for text across workspace files recursively. Omit path to search the workspace root.',
             parameters: {
                 type: 'object',
                 properties: {
-                    path: { type: 'string', description: 'Directory to search in' },
+                    path: { type: 'string', description: 'Directory to search in (default ".")' },
                     query: { type: 'string', description: 'Text or regex pattern to search for' },
-                    include: { type: 'string', description: 'Glob pattern for files to include (e.g. "*.js")' }
+                    include: { type: 'string', description: 'Glob pattern for files to include (e.g. "*.js")' },
+                    maxDepth: { type: 'number', description: 'Maximum directory depth (default 5, max 10)' },
+                    maxFileSize: { type: 'number', description: 'Maximum file size in bytes to scan (default 1048576)' }
                 },
-                required: ['path', 'query']
+                required: ['query']
             }
         },
         {
@@ -1141,7 +1205,7 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'create_task',
-            description: 'Create a background task with a named trigger and self-contained prompt.',
+            description: 'Create a future, recurring, monitored, or background automation with a named trigger and self-contained prompt. Do not use for immediate short answers.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -1160,12 +1224,12 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'list_tasks',
-            description: 'List all tasks for this user and agent.',
+            description: 'List saved background/scheduled tasks for this user and agent. Do not use for ordinary immediate replies.',
             parameters: { type: 'object', properties: {} }
         },
         {
             name: 'delete_task',
-            description: 'Delete a task by its ID.',
+            description: 'Delete a saved background/scheduled task by its ID.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -1176,7 +1240,7 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'update_task',
-            description: 'Update an existing task, including its trigger, prompt, or enabled state.',
+            description: 'Update an existing saved background/scheduled task, including its trigger, prompt, or enabled state.',
             parameters: {
                 type: 'object',
                 properties: {
@@ -1500,6 +1564,33 @@ function getAvailableTools(app, options = {}) {
     return compacted;
 }
 
+function firstStringArg(args = {}, names = []) {
+    for (const name of names) {
+        const value = args?.[name];
+        if (typeof value === 'string' && value.trim()) return value;
+    }
+    return '';
+}
+
+function normalizeReadFileArgs(args = {}) {
+    const startLine = args.start_line ?? args.line_start ?? args.startLine ?? args.lineStart;
+    let endLine = args.end_line ?? args.line_end ?? args.endLine ?? args.lineEnd;
+    const lineCount = args.line_count ?? args.lineCount;
+    if (endLine == null && startLine != null && lineCount != null) {
+        const start = Number(startLine);
+        const count = Number(lineCount);
+        if (Number.isInteger(start) && Number.isInteger(count) && count > 0) {
+            endLine = start + count - 1;
+        }
+    }
+    return {
+        path: firstStringArg(args, ['path', 'file_path', 'filePath', 'filename']),
+        encoding: args.encoding || 'utf-8',
+        start_line: startLine,
+        end_line: endLine,
+    };
+}
+
 /**
  * Executes a tool by name.
  * @param {string} toolName - Name of the tool.
@@ -2297,12 +2388,58 @@ async function executeTool(toolName, args, context, engine) {
             try {
                 const workspace = wc();
                 if (!workspace) return { error: 'Workspace service is unavailable.' };
-                return workspace.readFile(userId, {
-                    path: args.path,
-                    encoding: args.encoding || 'utf-8',
-                    start_line: args.start_line,
-                    end_line: args.end_line,
+                const normalizedArgs = normalizeReadFileArgs(args);
+                if (!normalizedArgs.path) {
+                    return {
+                        error: 'read_file requires path or file_path. Keep source files in the workspace; for repository work clone or move the checkout into the workspace before using file tools.',
+                    };
+                }
+                return workspace.readFile(userId, normalizedArgs);
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'read_files': {
+            try {
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                const entries = Array.isArray(args.files)
+                    ? args.files
+                    : (Array.isArray(args.paths) ? args.paths : []);
+                if (!entries.length) {
+                    return { error: 'read_files requires a non-empty files or paths array.' };
+                }
+                const maxFiles = 8;
+                const results = entries.slice(0, maxFiles).map((entry, index) => {
+                    const fileArgs = typeof entry === 'string'
+                        ? { path: entry }
+                        : (entry && typeof entry === 'object' ? entry : {});
+                    const normalizedArgs = normalizeReadFileArgs({
+                        ...fileArgs,
+                        encoding: fileArgs.encoding || args.encoding || 'utf-8',
+                    });
+                    if (!normalizedArgs.path) {
+                        return {
+                            index,
+                            success: false,
+                            error: 'Each read_files item requires path or file_path.',
+                        };
+                    }
+                    const result = workspace.readFile(userId, normalizedArgs);
+                    return {
+                        index,
+                        requestedPath: normalizedArgs.path,
+                        success: !result?.error,
+                        ...result,
+                    };
                 });
+                return {
+                    success: results.every((result) => result.success !== false && !result.error),
+                    count: results.length,
+                    truncated: entries.length > maxFiles,
+                    results,
+                };
             } catch (err) {
                 return { error: err.message };
             }
@@ -2312,8 +2449,10 @@ async function executeTool(toolName, args, context, engine) {
             try {
                 const workspace = wc();
                 if (!workspace) return { error: 'Workspace service is unavailable.' };
+                const targetPath = args.path || args.file_path;
+                if (!targetPath) return { success: false, error: 'write_file requires path or file_path.' };
                 return workspace.writeFile(userId, {
-                    path: args.path,
+                    path: targetPath,
                     content: args.content,
                     mode: args.mode,
                 });
@@ -2326,9 +2465,38 @@ async function executeTool(toolName, args, context, engine) {
             try {
                 const workspace = wc();
                 if (!workspace) return { error: 'Workspace service is unavailable.' };
+                const targetPath = args.path || args.file_path;
+                if (!targetPath) return { success: false, error: 'edit_file requires path or file_path.' };
+                const edits = Array.isArray(args.edits)
+                    ? args.edits.map((edit) => ({
+                        ...edit,
+                        oldText: edit?.oldText ?? edit?.old_text,
+                        newText: edit?.newText ?? edit?.new_text,
+                    }))
+                    : [];
                 return workspace.editFile(userId, {
-                    path: args.path,
-                    edits: args.edits,
+                    path: targetPath,
+                    edits,
+                });
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'replace_file_range': {
+            try {
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                if (typeof workspace.replaceFileRange !== 'function') {
+                    return { error: 'Workspace service does not support replace_file_range.' };
+                }
+                const targetPath = args.path || args.file_path;
+                if (!targetPath) return { success: false, error: 'replace_file_range requires path or file_path.' };
+                return workspace.replaceFileRange(userId, {
+                    path: targetPath,
+                    start_line: args.start_line ?? args.startLine,
+                    end_line: args.end_line ?? args.endLine,
+                    content: args.content,
                 });
             } catch (err) {
                 return { error: err.message };
@@ -2357,6 +2525,8 @@ async function executeTool(toolName, args, context, engine) {
                     path: args.path,
                     query: args.query,
                     include: args.include,
+                    maxDepth: args.maxDepth ?? args.max_depth,
+                    maxFileSize: args.maxFileSize ?? args.max_file_size,
                 });
             } catch (err) {
                 return { error: err.message };

package/server/services/integrations/github/common.js

@@ -42,7 +42,7 @@ async function githubApiRequest(auth, options = {}) {
     'X-GitHub-Api-Version': '2022-11-28',
   };
 
-  if (body && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+  if (body) {
     headers['Content-Type'] = 'application/json';
   }
 
@@ -103,4 +103,4 @@ module.exports = {
   buildPaginationParams,
   githubApiRequest,
   parseOwnerRepo,
-};
+};