neoagent 2.3.1-beta.11 → 2.3.1-beta.111

package/server/services/ai/toolResult.js

@@ -112,6 +112,26 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
       });
       break;
 
+    case 'social_video_extract':
+      envelope = trimObject({
+        tool: toolName,
+        platform: toolResult?.platform,
+        sourceUrl: toolResult?.sourceUrl,
+        resolvedUrl: toolResult?.resolvedUrl,
+        title: clampText(toolResult?.title || '', Math.floor(softLimit * 0.25)),
+        description: clampText(toolResult?.description || '', Math.floor(softLimit * 0.25)),
+        transcriptSource: toolResult?.transcriptSource,
+        transcriptPreview: lineExcerpt(toolResult?.transcript || '', 6, Math.floor(softLimit * 0.35)),
+        frameImage: trimObject({
+          url: toolResult?.frameImage?.url,
+          source: toolResult?.frameImage?.source,
+        }),
+        setupReady: toolResult?.setup?.ready,
+        warningCount: Array.isArray(toolResult?.warnings) ? toolResult.warnings.length : 0,
+        errorCount: Array.isArray(toolResult?.errors) ? toolResult.errors.length : 0,
+      });
+      break;
+
     case 'android_dump_ui':
     case 'android_observe':
       envelope = trimObject({

package/server/services/ai/toolRunner.js

@@ -13,6 +13,15 @@ function shellEscape(value) {
   return `'${text.replace(/'/g, `'\\''`)}'`;
 }
 
+// Shell metacharacters that must not appear in a skill command template.
+const SHELL_METACHAR_RE = /[;&|`$\n\r(){}\\<>]/;
+
+function isValidCommandTemplate(template) {
+  // Strip all {placeholder} tokens, then reject any remaining shell metacharacters.
+  const bare = String(template).replace(/\{[^{}]*\}/g, '');
+  return !SHELL_METACHAR_RE.test(bare);
+}
+
 function clampText(value, maxChars) {
   const text = String(value || '').trim().replace(/\s+/g, ' ');
   if (!text) return '';
@@ -20,10 +29,19 @@ function clampText(value, maxChars) {
   return `${text.slice(0, Math.max(0, maxChars - 1)).trimEnd()}...`;
 }
 
+function isValidUserId(userId) {
+  if (typeof userId === 'number') {
+    return Number.isInteger(userId) && userId > 0;
+  }
+  if (typeof userId === 'string') {
+    return userId.trim() !== '';
+  }
+  return false;
+}
+
 class SkillRunner {
   constructor(options = {}) {
     this.skills = new Map();
-    this.executor = options.executor || null;
     this.runtimeManager = options.runtimeManager || null;
   }
 
@@ -170,16 +188,38 @@ class SkillRunner {
     }
 
     if (skill.metadata.command) {
-      const { CLIExecutor } = require('../cli/executor');
+      if (!isValidCommandTemplate(skill.metadata.command)) {
+        return { error: `Skill '${toolName}' has an invalid command template` };
+      }
       let command = skill.metadata.command;
       for (const [key, value] of Object.entries(args)) {
         command = command.replaceAll(`{${key}}`, shellEscape(value));
       }
-      if (this.runtimeManager && context.userId != null) {
-        return await this.runtimeManager.executeCommand(context.userId, command, { cwd: skill.dir });
+      if (!isValidUserId(context.userId)) {
+        return {
+          error: 'Missing or invalid userId',
+        };
+      }
+      if (!this.runtimeManager) {
+        return {
+          error: 'VM runtime is required',
+        };
+      }
+      try {
+        return await this.runtimeManager.executeCommand(context.userId, command);
+      } catch (err) {
+        const commandName = skill?.name || toolName || 'unknown';
+        console.error('[SkillRunner] Skill command execution failed:', {
+          userId: context.userId,
+          commandName,
+          command: String(command).slice(0, 200),
+          error: err?.message || String(err),
+        });
+        return {
+          error: 'Skill command execution failed',
+          details: err?.message || String(err),
+        };
       }
-      const executor = this.executor || new CLIExecutor();
-      return await executor.execute(command, { cwd: skill.dir });
     }
 
     return {

package/server/services/ai/toolSelector.js

@@ -13,6 +13,42 @@
  */
 
 const MCP_ALWAYS_INCLUDE_THRESHOLD = 20;
+const MAX_TOOLS = 128; // Strict provider limit (e.g. Github Copilot / OpenAI)
+
+function ensureRequiredTools(selectedTools = [], builtInTools = [], options = {}) {
+  const requiredNames = [];
+  if (options.widgetId) requiredNames.push('save_widget_snapshot');
+  if (!requiredNames.length) return selectedTools;
+
+  const selected = Array.isArray(selectedTools) ? [...selectedTools] : [];
+
+  for (const toolName of requiredNames) {
+    if (selected.some((tool) => tool?.name === toolName)) continue;
+    const required = builtInTools.find((tool) => tool?.name === toolName);
+    if (!required) continue;
+
+    if (selected.length < MAX_TOOLS) {
+      selected.push(required);
+      continue;
+    }
+
+    // Keep within provider tool cap: replace the last non-required tool.
+    let replaced = false;
+    for (let index = selected.length - 1; index >= 0; index -= 1) {
+      const currentName = selected[index]?.name;
+      if (!requiredNames.includes(currentName)) {
+        selected[index] = required;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced && selected.length > 0) {
+      selected[selected.length - 1] = required;
+    }
+  }
+
+  return selected;
+}
 
 function selectMcpTools(task, mcpTools = []) {
   if (!mcpTools.length) return [];
@@ -33,7 +69,24 @@ function selectMcpTools(task, mcpTools = []) {
 }
 
 function selectToolsForTask(task, builtInTools = [], mcpTools = [], _options = {}) {
-  return [...builtInTools, ...selectMcpTools(task, mcpTools)];
+  const selectedMcp = selectMcpTools(task, mcpTools);
+  const options = _options || {};
+  let selected;
+  
+  if (builtInTools.length + selectedMcp.length <= MAX_TOOLS) {
+    selected = [...builtInTools, ...selectedMcp];
+    return ensureRequiredTools(selected, builtInTools, options);
+  }
+
+  // If we exceed the limit, prioritize base tools and take as many MCP tools as fit
+  const remainingSpace = MAX_TOOLS - builtInTools.length;
+  if (remainingSpace > 0) {
+    selected = [...builtInTools, ...selectedMcp.slice(0, remainingSpace)];
+    return ensureRequiredTools(selected, builtInTools, options);
+  }
+  
+  selected = builtInTools.slice(0, MAX_TOOLS);
+  return ensureRequiredTools(selected, builtInTools, options);
 }
 
 module.exports = { selectToolsForTask, selectMcpTools };

package/server/services/ai/tools.js

@@ -9,6 +9,10 @@ const {
     normalizeOutgoingMessageForPlatform,
 } = require('../messaging/formatting_guides');
 const { INTERIM_KINDS, normalizeInterimKind } = require('./interim');
+const {
+    executeIntegratedTool,
+    getIntegratedToolDefinitions,
+} = require('./integrated_tools');
 
 function compactText(text, maxChars = 120) {
     const str = String(text || '').replace(/\s+/g, ' ').trim();
@@ -192,6 +196,54 @@ function isProactiveTrigger(triggerSource) {
     return triggerSource === 'schedule' || triggerSource === 'tasks';
 }
 
+function normalizeSendMessagePurpose(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    if (normalized === 'final_result' || normalized === 'blocker' || normalized === 'no_response') {
+        return normalized;
+    }
+    return '';
+}
+
+function validateProactiveSendMessageArgs({ purpose, normalizedMessage }) {
+    const normalizedPurpose = normalizeSendMessagePurpose(purpose);
+    if (!normalizedPurpose) {
+        return {
+            ok: false,
+            error: 'Background send_message requires purpose=final_result, blocker, or no_response.',
+            reason: 'Background send_message requires purpose=final_result, blocker, or no_response.',
+        };
+    }
+
+    if (normalizedPurpose === 'no_response') {
+        if (normalizedMessage !== '[NO RESPONSE]') {
+            return {
+                ok: false,
+                error: 'purpose=no_response requires content "[NO RESPONSE]".',
+                reason: 'purpose=no_response requires content "[NO RESPONSE]".',
+            };
+        }
+        return {
+            ok: false,
+            skipped: true,
+            suppressed: true,
+            reason: 'no_response',
+        };
+    }
+
+    if (normalizedMessage === '[NO RESPONSE]') {
+        return {
+            ok: false,
+            error: `purpose=${normalizedPurpose} cannot use content "[NO RESPONSE]".`,
+            reason: `purpose=${normalizedPurpose} cannot use content "[NO RESPONSE]".`,
+        };
+    }
+
+    return {
+        ok: true,
+        purpose: normalizedPurpose,
+    };
+}
+
 function getRunState(engine, runId) {
     if (!engine || !runId) return null;
     return engine.activeRuns.get(runId) || null;
@@ -742,14 +794,15 @@ function getAvailableTools(app, options = {}) {
         },
         {
             name: 'send_message',
-            description: `Send a message on a connected messaging platform. Supports WhatsApp (text/media), Telnyx Voice (phone calls — TTS), Discord, Telegram, Slack, Google Chat, Microsoft Teams, Matrix, Signal, iMessage/BlueBubbles, IRC, Feishu, LINE, Mattermost, Nextcloud Talk, Nostr, Synology Chat, Tlon, Twitch, Zalo, WeChat, WebChat, and configurable webhook bridges. ${buildSendMessageFormattingReference()} For WhatsApp: use media_path to attach files. Use content "[NO RESPONSE]" only when the user explicitly asked for silence or no reply.`,
+            description: `Send a message on a connected messaging platform. Supports WhatsApp (text/media), Telnyx Voice (phone calls — TTS), Discord, Telegram, Slack, Google Chat, Microsoft Teams, Matrix, Signal, iMessage/BlueBubbles, IRC, Feishu, LINE, Mattermost, Nextcloud Talk, Nostr, Synology Chat, Tlon, Twitch, Zalo, WeChat, WebChat, and configurable webhook bridges. ${buildSendMessageFormattingReference()} For WhatsApp: use media_path to attach files. Use content "[NO RESPONSE]" only when the user explicitly asked for silence or no reply. For background task or schedule runs, set purpose to final_result, blocker, or no_response.`,
             parameters: {
                 type: 'object',
                 properties: {
                     platform: { type: 'string', description: 'Platform name, for example whatsapp, telnyx, discord, telegram, slack, google_chat, teams, matrix, signal, imessage, bluebubbles, irc, line, mattermost, or webchat' },
                     to: { type: 'string', description: 'Recipient/chat ID for the connected platform, such as a WhatsApp chat ID, Telnyx call_control_id, Slack channel ID, Matrix room ID, Discord channel snowflake / "dm_<userId>", Telegram "dm_<userId>" / raw group chat ID, IRC channel, or webhook target' },
                     content: { type: 'string', description: 'Message text. Write one compact natural chat reply; the runtime adapts final formatting for the destination platform.' },
-                    media_path: { type: 'string', description: 'WhatsApp only: absolute path to a local file to attach. Leave empty for text-only or Telnyx.' }
+                    media_path: { type: 'string', description: 'WhatsApp only: absolute path to a local file to attach. Leave empty for text-only or Telnyx.' },
+                    purpose: { type: 'string', enum: ['final_result', 'blocker', 'no_response'], description: 'For background task or schedule runs, required intent for this outbound message. Use final_result for a concrete useful outcome, blocker for a real issue the user should know about, or no_response to intentionally send nothing.' }
                 },
                 required: ['platform', 'to', 'content']
             }
@@ -1118,6 +1171,7 @@ function getAvailableTools(app, options = {}) {
                 required: ['prompt']
             }
         },
+        ...getIntegratedToolDefinitions(),
         {
             name: 'generate_table',
             description: 'Format data into a markdown table. The resulting markdown will be returned to you. You MUST include it in your next message to the user so they can see it.',
@@ -1213,9 +1267,46 @@ function getAvailableTools(app, options = {}) {
                 },
                 required: ['query']
             }
+        },
+        {
+            name: 'social_video_extract',
+            description: 'Extract title, description, transcript, and one representative frame image from a public social video URL (YouTube, TikTok, Instagram, or X) without social API keys.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'Public social video URL.' },
+                    include_frame: { type: 'boolean', description: 'Whether to return one representative frame image artifact (default true).' },
+                    force_stt: { type: 'boolean', description: 'Force speech-to-text fallback even if captions are present.' }
+                },
+                required: ['url']
+            }
         }
     ];
 
+    // task_complete — always available. Lets the AI explicitly signal that
+    // the task is fully done and provide the final response. This replaces
+    // the opaque directAnswerEligible heuristic as the primary loop-exit
+    // mechanism and gives the AI real agency over when it's finished.
+    tools.push({
+        name: 'task_complete',
+        description: 'Signal that the task is fully complete and provide the final response. Call this exactly once when all steps are done and you have a complete answer ready. Do NOT call it if you still have work to do.',
+        parameters: {
+            type: 'object',
+            properties: {
+                message: {
+                    type: 'string',
+                    description: 'Your complete final response to the user. Write it as if it were your reply — do not summarize or reference prior steps.'
+                },
+                confidence: {
+                    type: 'string',
+                    enum: ['high', 'medium', 'low'],
+                    description: 'How confident are you the task is fully and correctly complete? Use "low" if you had to make assumptions.'
+                }
+            },
+            required: ['message']
+        }
+    });
+
     const allowInterimUpdates = (
         (options.triggerSource === 'web' || options.triggerSource === 'messaging' || options.triggerSource === 'voice_live')
         && options.triggerType !== 'subagent'
@@ -1315,23 +1406,16 @@ async function executeTool(toolName, args, context, engine) {
         if (manager && typeof manager.getBrowserProviderForUser === 'function') {
             return manager.getBrowserProviderForUser(userId);
         }
-        const scoped = app?.locals?.getBrowserControllerForUser;
-        if (typeof scoped === 'function') {
-            return scoped(userId);
-        }
-        return app?.locals?.browserController || engine.browserController;
+        throw new Error('Browser provider is unavailable. VM runtime is required.');
     };
     const ac = () => {
         const manager = runtime();
         if (manager && typeof manager.getAndroidProviderForUser === 'function') {
             return manager.getAndroidProviderForUser(userId);
         }
-        const scoped = app?.locals?.getAndroidControllerForUser;
-        if (typeof scoped === 'function') {
-            return scoped(userId);
-        }
-        return app?.locals?.androidController || engine.androidController;
+        throw new Error('Android provider is unavailable. VM runtime is required.');
     };
+    const wc = () => app?.locals?.workspaceManager || engine.workspaceManager || null;
     const dc = () => {
         const scoped = app?.locals?.getDesktopProviderForUser;
         if (typeof scoped === 'function') {
@@ -1345,7 +1429,9 @@ async function executeTool(toolName, args, context, engine) {
     const sk = () => app?.locals?.skillRunner || engine.skillRunner;
     const taskRuntime = () => app?.locals?.taskRuntime || engine.taskRuntime;
     const rec = () => app?.locals?.recordingManager || null;
+    const socialVideo = () => app?.locals?.socialVideoService || null;
     const widgets = () => app?.locals?.widgetService || null;
+    const artifactStore = app?.locals?.artifactStore || null;
 
     const integrationManager = integrations();
     if (integrationManager) {
@@ -1370,35 +1456,37 @@ async function executeTool(toolName, args, context, engine) {
         }
     }
 
+    const integratedToolResult = await executeIntegratedTool(toolName, args, {
+        userId,
+        agentId,
+        cliExecutor: runtime() && typeof runtime().getCommandExecutorForUser === 'function'
+            ? await runtime().getCommandExecutorForUser(userId)
+            : null,
+        workspaceManager: wc(),
+        artifactStore,
+    });
+    if (integratedToolResult !== null) {
+        return integratedToolResult;
+    }
+
     switch (toolName) {
+        // task_complete is handled at the engine loop level before executeTool
+        // is called. If it somehow reaches here, return a no-op success so the
+        // loop-level handler can still read the args from the tool call object.
+        case 'task_complete':
+            return { success: true, handled_by: 'engine_loop' };
+
         case 'execute_command': {
             const runtimeManager = runtime();
-            if (runtimeManager && typeof runtimeManager.executeCommand === 'function') {
-                const onSpawn = (pid) => engine.attachProcessToRun(runId, pid);
-                return await runtimeManager.executeCommand(userId, args.command, {
-                    cwd: args.cwd,
-                    timeout: args.timeout || (args.pty ? 20 * 60 * 1000 : 15 * 60 * 1000),
-                    stdinInput: args.stdin_input,
-                    pty: args.pty === true,
-                    inputs: args.inputs || [],
-                    onSpawn,
-                });
+            if (!runtimeManager || typeof runtimeManager.executeCommand !== 'function') {
+                return { error: 'Command execution is unavailable. VM runtime is required.' };
             }
-            const { CLIExecutor } = require('../cli/executor');
-            const executor = app?.locals?.cliExecutor || engine.cliExecutor || new CLIExecutor();
-            const onSpawn = (pid) => engine.attachProcessToRun(runId, pid);
-            if (args.pty) {
-                return await executor.executeInteractive(args.command, args.inputs || [], {
-                    cwd: args.cwd,
-                    timeout: args.timeout || 20 * 60 * 1000,
-                    onSpawn
-                });
-            }
-            return await executor.execute(args.command, {
+            return await runtimeManager.executeCommand(userId, args.command, {
                 cwd: args.cwd,
-                timeout: args.timeout || 15 * 60 * 1000,
+                timeout: args.timeout || (args.pty ? 20 * 60 * 1000 : 15 * 60 * 1000),
                 stdinInput: args.stdin_input,
-                onSpawn
+                pty: args.pty === true,
+                inputs: args.inputs || [],
             });
         }
 
@@ -1906,6 +1994,22 @@ async function executeTool(toolName, args, context, engine) {
             };
         }
 
+        case 'social_video_extract': {
+            const service = socialVideo();
+            if (!service || typeof service.extractFromUrl !== 'function') {
+                return { error: 'Social video extraction service is unavailable.' };
+            }
+            const sourceUrl = String(args.url || '').trim();
+            if (!sourceUrl) {
+                return { error: 'url is required' };
+            }
+            return await service.extractFromUrl(userId, sourceUrl, {
+                includeFrame: args.include_frame !== false,
+                forceStt: args.force_stt === true,
+                agentId,
+            });
+        }
+
         case 'memory_write': {
             const { MemoryManager } = require('../memory/manager');
             const mm = new MemoryManager();
@@ -1986,6 +2090,25 @@ async function executeTool(toolName, args, context, engine) {
                 stripNoResponseMarker: false
             });
             const suppressReply = normalizedMessage === '[NO RESPONSE]';
+            if (isProactiveTrigger(triggerSource)) {
+                const proactiveValidation = validateProactiveSendMessageArgs({
+                    purpose: args.purpose,
+                    normalizedMessage,
+                });
+                if (!proactiveValidation.ok) {
+                    if (proactiveValidation.error) {
+                        return {
+                            error: proactiveValidation.error,
+                        };
+                    }
+                    return {
+                        sent: false,
+                        suppressed: proactiveValidation.suppressed === true,
+                        skipped: proactiveValidation.skipped === true,
+                        reason: proactiveValidation.reason,
+                    };
+                }
+            }
             if (!suppressReply && hasAlreadySentProactiveMessage({
                 triggerSource,
                 runState,
@@ -2017,21 +2140,14 @@ async function executeTool(toolName, args, context, engine) {
 
         case 'read_file': {
             try {
-                const encoding = args.encoding || 'utf-8';
-                if (args.start_line || args.end_line) {
-                    const content = fs.readFileSync(args.path, encoding);
-                    const lines = content.split('\n');
-                    const start = Math.max(0, (args.start_line || 1) - 1);
-                    const end = args.end_line || lines.length;
-                    const sliced = lines.slice(start, end).join('\n');
-                    return {
-                        content: sliced.length > 20000 ? sliced.slice(0, 20000) + '\n...[truncated]' : sliced,
-                        totalLines: lines.length,
-                        rangeShown: [start + 1, Math.min(end, lines.length)]
-                    };
-                }
-                const content = fs.readFileSync(args.path, encoding);
-                return { content: content.length > 20000 ? content.slice(0, 20000) + '\n...[truncated]' : content };
+                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,
+                });
             } catch (err) {
                 return { error: err.message };
             }
@@ -2039,14 +2155,13 @@ async function executeTool(toolName, args, context, engine) {
 
         case 'write_file': {
             try {
-                const dir = path.dirname(args.path);
-                if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-                if (args.mode === 'append') {
-                    fs.appendFileSync(args.path, args.content);
-                } else {
-                    fs.writeFileSync(args.path, args.content);
-                }
-                return { success: true, path: args.path };
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                return workspace.writeFile(userId, {
+                    path: args.path,
+                    content: args.content,
+                    mode: args.mode,
+                });
             } catch (err) {
                 return { error: err.message };
             }
@@ -2054,23 +2169,12 @@ async function executeTool(toolName, args, context, engine) {
 
         case 'edit_file': {
             try {
-                if (!fs.existsSync(args.path)) return { error: `File not found: ${args.path}` };
-                let content = fs.readFileSync(args.path, 'utf-8');
-                let modified = false;
-                const report = [];
-
-                for (const edit of args.edits) {
-                    if (content.includes(edit.oldText)) {
-                        content = content.replace(edit.oldText, edit.newText);
-                        modified = true;
-                        report.push({ success: true, edit: edit.oldText.slice(0, 50) + '...' });
-                    } else {
-                        report.push({ success: false, error: 'Target text not found', edit: edit.oldText.slice(0, 50) + '...' });
-                    }
-                }
-
-                if (modified) fs.writeFileSync(args.path, content);
-                return { success: modified, report, path: args.path };
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                return workspace.editFile(userId, {
+                    path: args.path,
+                    edits: args.edits,
+                });
             } catch (err) {
                 return { error: err.message };
             }
@@ -2078,28 +2182,13 @@ async function executeTool(toolName, args, context, engine) {
 
         case 'list_directory': {
             try {
-                const maxDepth = Math.min(args.depth || (args.recursive ? 3 : 1), 5);
-                const recurse = (dir, currentDepth = 1) => {
-                    const entries = fs.readdirSync(dir, { withFileTypes: true });
-                    const result = [];
-                    for (const e of entries) {
-                        const fullPath = path.join(dir, e.name);
-                        const stats = fs.statSync(fullPath);
-                        const item = {
-                            name: e.name,
-                            type: e.isDirectory() ? 'directory' : 'file',
-                            path: fullPath,
-                            size: stats.size,
-                            mtime: stats.mtime.toISOString()
-                        };
-                        result.push(item);
-                        if (e.isDirectory() && currentDepth < maxDepth && !e.name.startsWith('.') && e.name !== 'node_modules') {
-                            result.push(...recurse(fullPath, currentDepth + 1));
-                        }
-                    }
-                    return result;
-                };
-                return { entries: recurse(args.path) };
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                return workspace.listDirectory(userId, {
+                    path: args.path,
+                    depth: args.depth,
+                    recursive: args.recursive,
+                });
             } catch (err) {
                 return { error: err.message };
             }
@@ -2107,23 +2196,13 @@ async function executeTool(toolName, args, context, engine) {
 
         case 'search_files': {
             try {
-                const { CLIExecutor } = require('../cli/executor');
-                const executor = new CLIExecutor();
-                const includePattern = args.include ? `--include="${args.include}"` : '';
-                const command = `grep -rnE "${args.query.replace(/"/g, '\\"')}" "${args.path}" ${includePattern} | head -n 100`;
-                const result = await executor.execute(command);
-                if (result.exitCode === 1 && !result.stdout) return { results: [], message: 'No matches found' };
-
-                const lines = (result.stdout || '').split('\n').filter(Boolean);
-                const matches = lines.map(line => {
-                    const parts = line.split(':');
-                    return {
-                        file: parts[0],
-                        line: parseInt(parts[1]),
-                        content: parts.slice(2).join(':').trim()
-                    };
+                const workspace = wc();
+                if (!workspace) return { error: 'Workspace service is unavailable.' };
+                return workspace.searchFiles(userId, {
+                    path: args.path,
+                    query: args.query,
+                    include: args.include,
                 });
-                return { matches, count: matches.length };
             } catch (err) {
                 return { error: err.message };
             }
@@ -2488,7 +2567,17 @@ async function executeTool(toolName, args, context, engine) {
             if (!widgetService) return { error: 'Widget service not available' };
             if (!widgetId) return { error: 'save_widget_snapshot is only available during widget refresh runs.' };
             try {
-                const snapshot = widgetService.saveSnapshot(userId, widgetId, args.snapshot, {
+                const snapshotPayload = (
+                    args
+                    && typeof args === 'object'
+                    && !Array.isArray(args)
+                    && args.snapshot
+                    && typeof args.snapshot === 'object'
+                    && !Array.isArray(args.snapshot)
+                )
+                    ? args.snapshot
+                    : args;
+                const snapshot = widgetService.saveSnapshot(userId, widgetId, snapshotPayload, {
                     sourceRunId: runId,
                     status: 'ready',
                 });
@@ -2676,7 +2765,12 @@ async function executeTool(toolName, args, context, engine) {
             const { detectPromptInjection } = require('../../utils/security');
             const mcpManager = mcp();
             if (mcpManager) {
-                const mcpResult = await mcpManager.callToolByName(toolName, args, userId, { agentId });
+                let mcpResult = null;
+                try {
+                    mcpResult = await mcpManager.callToolByName(toolName, args, userId, { agentId });
+                } catch (mcpErr) {
+                    return { error: mcpErr.message, tool: toolName, source: 'mcp' };
+                }
                 if (mcpResult !== null) {
                     const resultText = typeof mcpResult === 'string' ? mcpResult : JSON.stringify(mcpResult);
                     if (detectPromptInjection(resultText)) {
@@ -2701,4 +2795,4 @@ async function executeTool(toolName, args, context, engine) {
     }
 }
 
-module.exports = { getAvailableTools, executeTool };
+module.exports = { getAvailableTools, executeTool, validateProactiveSendMessageArgs };