neoagent 2.2.1-beta.6 → 2.2.1-beta.7

package/server/routes/{scheduler.js → tasks.js}

@@ -3,79 +3,81 @@ const router = express.Router();
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
 const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
-const cron = require('node-cron');
 
 router.use(requireAuth);
 
-// List scheduled tasks
 router.get('/', (req, res) => {
-  const scheduler = req.app.locals.scheduler;
-  const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
-  res.json(scheduler.listTasks(req.session.userId, { agentId }));
+  try {
+    const tasks = req.app.locals.taskRuntime;
+    const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
+    res.json(tasks.listTasks(req.session.userId, { agentId }));
+  } catch (error) {
+    (req.app.locals.logger?.error || console.error)('[Tasks] Failed to list tasks', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
 });
 
-// Create a new scheduled task
-router.post('/', (req, res) => {
+router.get('/catalog', (req, res) => {
   try {
-    const { name, cronExpression, prompt, enabled, model } = req.body;
+    const tasks = req.app.locals.taskRuntime;
     const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
-    if (!name || !cronExpression || !prompt) {
-      return res.status(400).json({ error: 'name, cronExpression, and prompt required' });
-    }
-    if (!cron.validate(String(cronExpression))) {
-      return res.status(400).json({ error: 'Invalid cron expression' });
-    }
+    res.json(tasks.getTriggerCatalog(req.session.userId, { agentId }));
+  } catch (error) {
+    (req.app.locals.logger?.error || console.error)('[Tasks] Failed to load trigger catalog', error);
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
 
-    const scheduler = req.app.locals.scheduler;
-    const task = scheduler.createTask(req.session.userId, { name, cronExpression, prompt, enabled, model, agentId });
+router.post('/', async (req, res) => {
+  try {
+    const tasks = req.app.locals.taskRuntime;
+    const agentId = resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
+    const task = await tasks.createTask(req.session.userId, {
+      ...req.body,
+      agentId,
+    });
     res.status(201).json(task);
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });
   }
 });
 
-// Update a scheduled task
-router.put('/:id', (req, res) => {
+router.put('/:id', async (req, res) => {
   try {
     const taskId = Number.parseInt(req.params.id, 10);
     if (!Number.isInteger(taskId) || taskId <= 0) {
       return res.status(400).json({ error: 'Invalid task id' });
     }
-    if (req.body?.cronExpression !== undefined && !cron.validate(String(req.body.cronExpression))) {
-      return res.status(400).json({ error: 'Invalid cron expression' });
-    }
-    const scheduler = req.app.locals.scheduler;
-    const task = scheduler.updateTask(taskId, req.session.userId, req.body);
+    const tasks = req.app.locals.taskRuntime;
+    const task = await tasks.updateTask(taskId, req.session.userId, req.body);
     res.json(task);
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });
   }
 });
 
-// Delete a scheduled task
 router.delete('/:id', (req, res) => {
   try {
     const taskId = Number.parseInt(req.params.id, 10);
     if (!Number.isInteger(taskId) || taskId <= 0) {
       return res.status(400).json({ error: 'Invalid task id' });
     }
-    const scheduler = req.app.locals.scheduler;
-    scheduler.deleteTask(taskId, req.session.userId);
+    const tasks = req.app.locals.taskRuntime;
+    tasks.deleteTask(taskId, req.session.userId);
     res.json({ success: true });
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });
   }
 });
 
-// Run a task immediately
 router.post('/:id/run', (req, res) => {
   try {
     const taskId = Number.parseInt(req.params.id, 10);
     if (!Number.isInteger(taskId) || taskId <= 0) {
       return res.status(400).json({ error: 'Invalid task id' });
     }
-    const scheduler = req.app.locals.scheduler;
-    const result = scheduler.runTaskNow(taskId, req.session.userId);
+    const tasks = req.app.locals.taskRuntime;
+    const result = tasks.runTaskNow(taskId, req.session.userId);
     res.json(result);
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });

package/server/routes/widgets.js

@@ -40,26 +40,26 @@ router.get('/', (req, res) => {
   }
 });
 
-router.post('/', (req, res) => {
+router.post('/', async (req, res) => {
   try {
     const service = widgetService(req);
     if (!service) {
       return res.status(500).json({ error: 'Widget service unavailable.' });
     }
-    const widget = service.createWidget(req.session.userId, req.body || {});
+    const widget = await service.createWidget(req.session.userId, req.body || {});
     res.status(201).json(widget);
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });
   }
 });
 
-router.put('/:id', (req, res) => {
+router.put('/:id', async (req, res) => {
   try {
     const service = widgetService(req);
     if (!service) {
       return res.status(500).json({ error: 'Widget service unavailable.' });
     }
-    const widget = service.updateWidget(req.session.userId, req.params.id, req.body || {});
+    const widget = await service.updateWidget(req.session.userId, req.params.id, req.body || {});
     res.json(widget);
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });
@@ -81,8 +81,8 @@ router.delete('/:id', (req, res) => {
 router.post('/:id/refresh', (req, res) => {
   try {
     const service = widgetService(req);
-    const scheduler = req.app?.locals?.scheduler;
-    if (!service || !scheduler) {
+    const taskRuntime = req.app?.locals?.taskRuntime;
+    if (!service || !taskRuntime) {
       return res.status(500).json({ error: 'Widget refresh unavailable.' });
     }
     const widget = service.getWidget(req.session.userId, req.params.id);
@@ -92,7 +92,7 @@ router.post('/:id/refresh', (req, res) => {
     if (!widget.scheduledTaskId) {
       return res.status(400).json({ error: 'Widget is missing its refresh task.' });
     }
-    res.json(scheduler.runTaskNow(widget.scheduledTaskId, req.session.userId));
+    res.json(taskRuntime.runTaskNow(widget.scheduledTaskId, req.session.userId));
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });
   }

package/server/services/ai/capabilityHealth.js

@@ -354,7 +354,7 @@ function getMemoryHealth(engine) {
   });
 }
 
-function getSchedulerHealth(userId, agentId = null) {
+function getTaskHealth(userId, agentId = null) {
   const taskCount = agentId
     ? db.prepare('SELECT COUNT(*) AS count FROM scheduled_tasks WHERE user_id = ? AND agent_id = ?').get(userId, agentId)?.count || 0
     : db.prepare('SELECT COUNT(*) AS count FROM scheduled_tasks WHERE user_id = ?').get(userId)?.count || 0;
@@ -363,8 +363,8 @@ function getSchedulerHealth(userId, agentId = null) {
     configured: true,
     healthy: true,
     summary: taskCount > 0
-      ? `${taskCount} scheduled task(s) exist for this user.`
-      : 'No scheduled tasks are configured.',
+      ? `${taskCount} task(s) exist for this user.`
+      : 'No tasks are configured.',
     details: { taskCount },
   });
 }
@@ -385,7 +385,7 @@ async function getCapabilityHealth({ userId, agentId = null, app, engine }) {
       integrations: getIntegrationHealth(userId, app, agentId),
       mcp: getMcpHealth(userId, app, engine, agentId),
       skills: getSkillHealth(app, engine),
-      scheduler: getSchedulerHealth(userId, agentId),
+      tasks: getTaskHealth(userId, agentId),
     },
   };
 }

package/server/services/ai/engine.js

@@ -459,6 +459,7 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     'recordings_list',
     'recordings_get',
     'recordings_search',
+    'list_tasks',
     'wait_subagent',
   ]);
   const stateChangingExact = new Set([
@@ -471,10 +472,9 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     'create_skill',
     'update_skill',
     'delete_skill',
-    'create_scheduled_task',
-    'update_scheduled_task',
-    'delete_scheduled_task',
-    'schedule_run',
+    'create_task',
+    'update_task',
+    'delete_task',
     'create_ai_widget',
     'update_ai_widget',
     'delete_ai_widget',
@@ -503,8 +503,8 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
                   ? 'command'
                   : name.includes('skill')
                     ? 'skills'
-                    : name.includes('scheduled_task') || name === 'schedule_run' || name.includes('widget')
-                      ? 'scheduler'
+                    : (name === 'create_task' || name === 'update_task' || name === 'delete_task' || name === 'list_tasks' || name.includes('widget'))
+                      ? 'tasks'
                       : name === 'send_message' || name === 'make_call'
                         ? 'messaging'
                         : name.startsWith('recordings_') || name === 'read_health_data'
@@ -647,7 +647,7 @@ class AgentEngine {
     this.messagingManager = services.messagingManager || null;
     this.mcpManager = services.mcpManager || services.mcpClient || null;
     this.skillRunner = services.skillRunner || null;
-    this.scheduler = services.scheduler || null;
+    this.taskRuntime = services.taskRuntime || null;
     this.memoryManager = services.memoryManager || null;
     this.voiceRuntimeManager = services.voiceRuntimeManager || null;
   }
@@ -2495,7 +2495,7 @@ class AgentEngine {
       messagingManager: this.messagingManager,
       mcpManager: this.mcpManager,
       skillRunner: this.skillRunner,
-      scheduler: this.scheduler,
+      taskRuntime: this.taskRuntime,
       memoryManager: this.memoryManager,
     });
 
@@ -2832,7 +2832,7 @@ class AgentEngine {
     if (toolName === 'send_message') return 'messaging';
     if (toolName === 'make_call') return 'messaging';
     if (toolName.startsWith('mcp_') || toolName.includes('mcp')) return 'mcp';
-    if (toolName.includes('scheduled_task') || toolName === 'schedule_run' || toolName.includes('widget')) return 'scheduler';
+    if (toolName === 'create_task' || toolName === 'update_task' || toolName === 'delete_task' || toolName === 'list_tasks' || toolName.includes('widget')) return 'tasks';
     if (toolName.includes('subagent')) return 'subagent';
     if (toolName === 'think') return 'thinking';
     return 'tool';

package/server/services/ai/systemPrompt.js

@@ -79,8 +79,8 @@ REPORT ACTUAL RESULTS
 When a tool returns data, share the relevant parts — summarized if large, direct if short. Never paste raw JSON as the answer. Never narrate what you're about to do at length before doing it.
 Never promise an action in the final answer unless you already took that action in this run. Do not say "I'll check", "I'll fix it", or "I'll send it" and then stop. Either do it first or say you have not done it yet.
 Do not promise future follow-up work unless that work will actually happen automatically before the current run ends.
-For scheduler or task-config changes, never claim that a cron job was created, updated, deleted, enabled, disabled, or “fixed” unless the corresponding scheduler tool call succeeded in this run. If you did not verify the actual task config, say that clearly instead of guessing.
-If the user asks you to debug scheduler timing or frequency, inspect the current scheduled-task list first and separate three things clearly: what you observed, what you infer, and what you actually changed.
+For task-config changes, never claim that a task was created, updated, deleted, enabled, disabled, or “fixed” unless the corresponding task tool call succeeded in this run. If you did not verify the actual task config, say that clearly instead of guessing.
+If the user asks you to debug task timing or trigger behavior, inspect the current task list first and separate three things clearly: what you observed, what you infer, and what you actually changed.
 
 RELIABILITY
 If a claim depends on current external facts, status, timelines, or ambiguous relative dates, verify it with fresh evidence before stating it as fact. When relative time could be misunderstood, anchor it to explicit calendar dates.
@@ -97,7 +97,7 @@ Not every result is worth a message. If background work completes and the output
 
 MEMORY
 If the user references past work or context, use session_search before asking them to repeat themselves. Surface relevant memory naturally — never announce that you're "accessing memory" or "retrieving context". Just know it.
-Store only durable memory candidates. Do not turn recent scheduler runs, task execution recaps, last-run statuses, or similar operational noise into long-term memory.
+Store only durable memory candidates. Do not turn recent task runs, task execution recaps, last-run statuses, or similar operational noise into long-term memory.
 Never rely on memory alone for risky actions, private data changes, payments, sending messages, or current factual claims. Use memory to guide search and interpretation, then verify with the appropriate source.
 Update core memory only for standing preferences, stable user facts, or durable agent-behavior preferences. For ordinary task facts, use regular memory or do nothing.
 
@@ -137,12 +137,12 @@ Messages to the user in the active conversation do not need extra confirmation.
 When drafting on behalf of the user, match their likely voice from available context and relationship to the recipient. Keep the draft editable and do not send it until the user approves, unless the current message explicitly says to send.
 If the user approves a previously shown draft, send that draft rather than silently rewriting it.
 
-SCHEDULED TASKS
-Use one-time scheduled runs for single reminders or delayed actions, and recurring scheduled tasks for repeating automation. Make scheduled prompts self-contained: who/what to check, exact action to take, when to notify, and which channel to use if known.
+TASKS
+Use one-time schedule triggers for single reminders or delayed actions, recurring schedule triggers for repeating automation, and official integration triggers when the task should react to connected Gmail, Outlook, Slack, Teams, or WhatsApp Personal events. Make task prompts self-contained: who/what to check, exact action to take, when to notify, and which channel to use if known.
 Do not create vague tasks like "check this" when the future run would not know what "this" means. Resolve references into names, links, file paths, IDs, dates, and success criteria before saving the task.
 For notification tasks, distinguish between notifying the user in their current messaging channel, emailing the user, and contacting someone else. Default reminders should notify the user through the active messaging channel unless the user explicitly asks for email, phone, or a third party.
-When creating or updating a scheduled task, include whether it should notify every time, only on change, only on errors, or only when a condition is met. If unspecified, choose the least noisy useful behavior and say what you chose.
-For scheduled tasks that may become stale, include an expiry condition or narrow scope when the user provided one.
+When creating or updating a task, include whether it should notify every time, only on change, only on errors, or only when a condition is met. If unspecified, choose the least noisy useful behavior and say what you chose.
+For tasks that may become stale, include an expiry condition or narrow scope when the user provided one.
 
 SKILLS
 Create or improve a skill only when it is clearly reusable, polished, and likely to matter again. Most completed tasks should not become skills.

package/server/services/ai/taskAnalysis.js

@@ -49,7 +49,7 @@ const PLAN_PROMPT_INSTRUCTIONS = [
   'Prefer native integrations and structured tools before browser automation or generic shell commands.',
   'For external actions, include a step to draft or confirm before sending unless the user already gave explicit current-session approval.',
   'For code or config changes, include inspection, scoped edit, and verification steps.',
-  'For scheduled tasks, make the future prompt self-contained and include notification conditions.',
+  'For tasks that run later, make the future prompt self-contained and include notification conditions.',
 ];
 const VERIFIER_PROMPT_INSTRUCTIONS = [
   'Verify whether the draft final reply is adequately supported by the gathered evidence.',
@@ -58,14 +58,14 @@ const VERIFIER_PROMPT_INSTRUCTIONS = [
   'A non-zero execute_command exit code means partial or failed shell evidence. Do not treat later sections of a chained shell command as observed unless they were verified separately.',
   'A successful send_message or make_call means outbound delivery succeeded in this run unless a later messaging tool failed.',
   'Any claim that an outbound action already happened (sent/submitted/called/"already done") must be backed by a successful outbound tool execution in this run. If not backed, rewrite the reply to "not sent yet" and provide a draft or next concrete step.',
-  'A successful scheduled-task create/update/delete tool call is required before claiming a schedule changed.',
+  'A successful create_task or update_task tool call is required before claiming a task schedule changed.',
   'If external evidence conflicts with memory, history, or another tool result, preserve the uncertainty instead of flattening it into a single confident claim.',
 ];
 const EXECUTION_GUIDANCE_ACTION_LINES = [
   'Act end-to-end. Run independent searches or inspections in parallel when possible. Prefer native integration tools and structured APIs over browser automation or shell scraping. Use exact IDs and required parameters; list or search first when you do not have them.',
   'Use send_interim_update sparingly when a short real update or question would help.',
   'When you must ask for missing required user input, ask once, then wait for the reply instead of re-asking in the same run.',
-  'For outbound messages, calls, emails, shared edits, installs, restarts, or scheduled-task mutations, verify the action result before claiming it happened. If user confirmation is required and missing, draft or ask instead of sending.',
+  'For outbound messages, calls, emails, shared edits, installs, restarts, or task mutations, verify the action result before claiming it happened. If user confirmation is required and missing, draft or ask instead of sending.',
   'Retry with alternative tools or approaches when one path fails. If evidence is still insufficient, say so explicitly instead of guessing.',
 ];
 

package/server/services/ai/toolResult.js

@@ -155,7 +155,7 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
       });
       break;
 
-    case 'list_scheduled_tasks':
+    case 'list_tasks':
       envelope = trimObject({
         tool: toolName,
         status: toolResult?.success === false || toolResult?.error ? 'error' : 'ok',
@@ -167,9 +167,8 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
           ? toolResult.tasks.slice(0, 8).map((task) => trimObject({
             id: task?.id,
             name: task?.name,
-            cronExpression: task?.cronExpression,
-            ...(task?.oneTime ? { runAt: task?.runAt } : {}),
-            oneTime: task?.oneTime,
+            triggerType: task?.triggerType,
+            triggerSummary: task?.triggerSummary,
             enabled: task?.enabled,
             ...(task?.model ? { model: task.model } : {})
           }))
@@ -217,10 +216,9 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
     case 'memory_update_core':
     case 'memory_read':
     case 'memory_write':
-    case 'create_scheduled_task':
-    case 'schedule_run':
-    case 'delete_scheduled_task':
-    case 'update_scheduled_task':
+    case 'create_task':
+    case 'delete_task':
+    case 'update_task':
     case 'create_ai_widget':
     case 'update_ai_widget':
     case 'delete_ai_widget':