neoagent 2.3.1-beta.0 → 2.3.1-beta.100

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();
@@ -91,10 +95,155 @@ function compactToolDefinition(tool, options = {}) {
     return compact;
 }
 
+function normalizeScheduleTriggerConfig(inputConfig = {}) {
+    if (!inputConfig || typeof inputConfig !== 'object' || Array.isArray(inputConfig)) {
+        return inputConfig;
+    }
+
+    const normalized = { ...inputConfig };
+    const schedule = (normalized.schedule && typeof normalized.schedule === 'object' && !Array.isArray(normalized.schedule))
+        ? normalized.schedule
+        : null;
+
+    const modeCandidate = String(
+        normalized.mode
+        || normalized.type
+        || normalized.scheduleType
+        || normalized.schedule_type
+        || (normalized.oneTime || normalized.one_time ? 'one_time' : '')
+        || ''
+    ).trim().toLowerCase();
+    if (modeCandidate === 'once') normalized.mode = 'one_time';
+    else if (modeCandidate === 'one_time' || modeCandidate === 'recurring') normalized.mode = modeCandidate;
+
+    const cronCandidate = normalized.cronExpression
+        || normalized.cron_expression
+        || normalized.cron
+        || schedule?.cronExpression
+        || schedule?.cron_expression
+        || schedule?.cron;
+    if (cronCandidate != null) {
+        normalized.cronExpression = String(cronCandidate).trim();
+    }
+
+    const runAtCandidate = normalized.runAt
+        || normalized.run_at
+        || normalized.at
+        || normalized.when
+        || schedule?.runAt
+        || schedule?.run_at
+        || schedule?.at
+        || schedule?.when;
+    if (runAtCandidate != null) {
+        normalized.runAt = String(runAtCandidate).trim();
+    }
+
+    if (!normalized.mode) {
+        normalized.mode = normalized.runAt ? 'one_time' : 'recurring';
+    }
+
+    delete normalized.schedule;
+    return normalized;
+}
+
+function normalizeTaskTriggerInput(triggerType, triggerConfig) {
+    if (String(triggerType || '').trim() !== 'schedule') {
+        return triggerConfig;
+    }
+    return normalizeScheduleTriggerConfig(triggerConfig || {});
+}
+
+function resolveTaskTriggerArgs(args = {}, fallbackTriggerType = null) {
+    let triggerType = args.trigger_type !== undefined
+        ? String(args.trigger_type || '').trim()
+        : String(fallbackTriggerType || '').trim();
+    let triggerConfig = args.trigger_config;
+    let hasType = args.trigger_type !== undefined;
+    let hasConfig = args.trigger_config !== undefined;
+
+    if (args.trigger && typeof args.trigger === 'object' && !Array.isArray(args.trigger)) {
+        const trigger = args.trigger;
+        const unifiedType = trigger.type ?? trigger.triggerType ?? trigger.trigger_type;
+        const unifiedHasType = unifiedType !== undefined && unifiedType !== null && String(unifiedType).trim().length > 0;
+        if (unifiedHasType) {
+            triggerType = String(unifiedType).trim();
+            hasType = true;
+        }
+
+        const hasUnifiedConfig = Object.prototype.hasOwnProperty.call(trigger, 'config')
+            || Object.prototype.hasOwnProperty.call(trigger, 'triggerConfig')
+            || Object.prototype.hasOwnProperty.call(trigger, 'trigger_config');
+        if (hasUnifiedConfig) {
+            triggerConfig = trigger.config ?? trigger.triggerConfig ?? trigger.trigger_config;
+            hasConfig = true;
+        }
+    }
+
+    const normalizedType = String(triggerType || '').trim() || null;
+    const normalizedConfig = hasConfig
+        ? normalizeTaskTriggerInput(normalizedType || fallbackTriggerType || 'schedule', triggerConfig)
+        : undefined;
+
+    return {
+        triggerType: normalizedType,
+        triggerConfig: normalizedConfig,
+        hasType,
+        hasConfig,
+    };
+}
+
 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;
@@ -645,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']
             }
@@ -876,15 +1026,16 @@ function getAvailableTools(app, options = {}) {
                 type: 'object',
                 properties: {
                     name: { type: 'string', description: 'Short descriptive name for the task.' },
-                    trigger_type: { type: 'string', description: 'Trigger type such as schedule, gmail_message_received, outlook_email_received, slack_message_received, teams_message_received, or whatsapp_personal_message_received.' },
-                    trigger_config: { type: 'object', description: 'Trigger-specific configuration object.' },
+                    trigger: { type: 'object', description: 'Unified trigger object. Prefer { type: "manual" | "schedule" | integration_trigger_type, config: {...} }.' },
+                    trigger_type: { type: 'string', description: 'Trigger type such as manual, schedule, gmail_message_received, outlook_email_received, slack_message_received, teams_message_received, weather_event, or whatsapp_personal_message_received.' },
+                    trigger_config: { type: 'object', description: 'Trigger-specific configuration object. For schedule triggers prefer { mode: "recurring", cronExpression: "m h dom mon dow" } or { mode: "one_time", runAt: ISO datetime }. 5-field cron only (seconds unsupported).' },
                     prompt: { type: 'string', description: 'The instructions the agent will run when the trigger fires.' },
                     enabled: { type: 'boolean', description: 'Whether to activate immediately.' },
                     model: { type: 'string', description: 'Optional model override.' },
                     call_to: { type: 'string', description: 'Optional E.164 phone number to call via Telnyx when this task fires.' },
                     call_greeting: { type: 'string', description: 'Optional spoken greeting hint for make_call.' }
                 },
-                required: ['name', 'trigger_type', 'trigger_config', 'prompt']
+                required: ['name', 'prompt']
             }
         },
         {
@@ -911,8 +1062,9 @@ function getAvailableTools(app, options = {}) {
                 properties: {
                     task_id: { type: 'number', description: 'The numeric ID of the task to update.' },
                     name: { type: 'string', description: 'New name for the task.' },
-                    trigger_type: { type: 'string', description: 'Updated trigger type.' },
-                    trigger_config: { type: 'object', description: 'Updated trigger-specific configuration.' },
+                    trigger: { type: 'object', description: 'Unified trigger object. Use { type, config } to update trigger in one section.' },
+                    trigger_type: { type: 'string', description: 'Updated trigger type, e.g. manual, schedule, or integration trigger type.' },
+                    trigger_config: { type: 'object', description: 'Updated trigger-specific configuration. For schedule triggers use mode+cronExpression (recurring) or mode+runAt (one_time).' },
                     prompt: { type: 'string', description: 'Updated task prompt.' },
                     enabled: { type: 'boolean', description: 'Enable or disable the task.' },
                     model: { type: 'string', description: 'Specific AI model ID for this task. Set to empty string to clear the override.' },
@@ -1019,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.',
@@ -1053,6 +1206,17 @@ function getAvailableTools(app, options = {}) {
                 required: ['image_path']
             }
         },
+        {
+            name: 'ocr_extract',
+            description: 'Extract raw text from an image locally using Tesseract OCR. This is faster and completely offline compared to analyze_image.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    image_path: { type: 'string', description: 'Absolute path to the image file' }
+                },
+                required: ['image_path']
+            }
+        },
         {
             name: 'read_health_data',
             description: 'Read the user\'s synced mobile health data. Omit metric_type for a summary of all available metrics. With metric_type, returns an aggregate summary (total, avg, min, max over all stored data) plus the most recent individual records. Always report the summary figures — avoid listing every raw record.',
@@ -1103,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'
@@ -1123,7 +1324,8 @@ function getAvailableTools(app, options = {}) {
                     properties: {
                         content: { type: 'string', description: 'Natural assistant message derived from the current task state.' },
                         kind: { type: 'string', enum: Array.from(INTERIM_KINDS), description: 'ack, progress, question, or blocker' },
-                        expects_reply: { type: 'boolean', description: 'Set true only when the current run should pause for the user to answer.' }
+                        expects_reply: { type: 'boolean', description: 'Set true only when the current run should pause for the user to answer.' },
+                        defer_follow_up: { type: 'boolean', description: 'Set true when you choose to deliver the final result later via the user\'s last connected chat target.' }
                     },
                     required: ['content', 'kind']
                 }
@@ -1204,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') {
@@ -1234,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) {
@@ -1259,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,
-                });
-            }
-            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
-                });
+            if (!runtimeManager || typeof runtimeManager.executeCommand !== 'function') {
+                return { error: 'Command execution is unavailable. VM runtime is required.' };
             }
-            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 || [],
             });
         }
 
@@ -1795,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();
@@ -1847,6 +2062,7 @@ async function executeTool(toolName, args, context, engine) {
             }
             const interimContent = typeof args.content === 'string' ? args.content : '';
             const expectsReply = args.expects_reply === true;
+            const deferFollowUp = args.defer_follow_up === true;
             return engine.publishInterimUpdate({
                 userId,
                 runId,
@@ -1858,6 +2074,7 @@ async function executeTool(toolName, args, context, engine) {
                 content: interimContent,
                 kind: normalizeInterimKind(args.kind),
                 expectsReply,
+                deferFollowUp,
             });
         }
 
@@ -1873,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,
@@ -1904,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 };
             }
@@ -1926,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 };
             }
@@ -1941,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 };
             }
@@ -1965,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 };
             }
@@ -1994,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 };
             }
@@ -2205,10 +2397,21 @@ async function executeTool(toolName, args, context, engine) {
             const s = taskRuntime();
             if (!s) return { error: 'Task runtime not available' };
             try {
+                const resolvedTrigger = resolveTaskTriggerArgs(args, 'schedule');
+                if (!resolvedTrigger.hasType || !resolvedTrigger.triggerType) {
+                    return { error: 'Task trigger type is required (use trigger.type or trigger_type).' };
+                }
+                const normalizedTriggerType = String(resolvedTrigger.triggerType || '').trim();
+                const triggerConfig = (!resolvedTrigger.hasConfig || resolvedTrigger.triggerConfig === undefined)
+                    ? (normalizedTriggerType === 'manual' ? {} : undefined)
+                    : resolvedTrigger.triggerConfig;
+                if (triggerConfig === undefined) {
+                    return { error: 'Task trigger config is required (use trigger.config or trigger_config).' };
+                }
                 const task = await s.createTask(userId, {
                     name: args.name,
-                    triggerType: args.trigger_type,
-                    triggerConfig: args.trigger_config,
+                    triggerType: normalizedTriggerType,
+                    triggerConfig,
                     prompt: args.prompt,
                     enabled: args.enabled !== false,
                     model: args.model || null,
@@ -2246,12 +2449,13 @@ async function executeTool(toolName, args, context, engine) {
             const s = taskRuntime();
             if (!s) return { error: 'Task runtime not available' };
             try {
-                const existing = db.prepare('SELECT agent_id FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(args.task_id, userId);
+                const existing = db.prepare('SELECT agent_id, trigger_type FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(args.task_id, userId);
                 if (!existing || existing.agent_id !== agentId) return { error: 'Task not found for this agent.' };
                 const updates = {};
+                const resolvedTrigger = resolveTaskTriggerArgs(args, existing.trigger_type || 'schedule');
                 if (args.name !== undefined) updates.name = args.name;
-                if (args.trigger_type !== undefined) updates.triggerType = args.trigger_type;
-                if (args.trigger_config !== undefined) updates.triggerConfig = args.trigger_config;
+                if (resolvedTrigger.hasType && resolvedTrigger.triggerType) updates.triggerType = resolvedTrigger.triggerType;
+                if (resolvedTrigger.hasConfig && resolvedTrigger.triggerConfig !== undefined) updates.triggerConfig = resolvedTrigger.triggerConfig;
                 if (args.prompt !== undefined) updates.prompt = args.prompt;
                 if (args.enabled !== undefined) updates.enabled = args.enabled;
                 if (args.model !== undefined) updates.model = args.model || null;
@@ -2363,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',
                 });
@@ -2470,6 +2684,20 @@ async function executeTool(toolName, args, context, engine) {
             }
         }
 
+        case 'ocr_extract': {
+            try {
+                const fs = require('fs');
+                if (!fs.existsSync(args.image_path)) {
+                    return { error: 'File not found: ' + args.image_path };
+                }
+                const Tesseract = require('tesseract.js');
+                const result = await Tesseract.recognize(args.image_path, 'eng');
+                return { text: result.data.text, confidence: result.data.confidence };
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
         case 'spawn_subagent': {
             try {
                 const task = args.context ? `${args.task}\n\nContext: ${args.context}` : args.task;
@@ -2537,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)) {
@@ -2562,4 +2795,4 @@ async function executeTool(toolName, args, context, engine) {
     }
 }
 
-module.exports = { getAvailableTools, executeTool };
+module.exports = { getAvailableTools, executeTool, validateProactiveSendMessageArgs };