neoagent 2.4.1-beta.32 → 2.4.1-beta.34

package/server/services/ai/engine.js

@@ -61,6 +61,17 @@ function generateTitle(task) {
   return cleaned.slice(0, 90);
 }
 
+function buildInitialRunMetadata(options = {}) {
+  const metadata = {};
+  if (options.taskId != null && String(options.taskId).trim()) {
+    metadata.taskId = options.taskId;
+  }
+  if (options.widgetId != null && String(options.widgetId).trim()) {
+    metadata.widgetId = options.widgetId;
+  }
+  return metadata;
+}
+
 function planningDepthForForceMode(forceMode) {
   return forceMode === 'plan_execute' ? 'deep' : 'light';
 }
@@ -1653,8 +1664,19 @@ class AgentEngine {
     };
 
     const runTitle = generateTitle(userMessage);
-    db.prepare(`INSERT OR REPLACE INTO agent_runs(id, user_id, agent_id, title, status, trigger_type, trigger_source, model)
-      VALUES(?, ?, ?, ?, 'running', ?, ?, ?)`).run(runId, userId, agentId, runTitle, triggerType, triggerSource, model);
+    const initialRunMetadata = buildInitialRunMetadata(options);
+    db.prepare(`INSERT OR REPLACE INTO agent_runs(
+      id, user_id, agent_id, title, status, trigger_type, trigger_source, model, metadata_json
+    ) VALUES(?, ?, ?, ?, 'running', ?, ?, ?, ?)`).run(
+      runId,
+      userId,
+      agentId,
+      runTitle,
+      triggerType,
+      triggerSource,
+      model,
+      Object.keys(initialRunMetadata).length ? JSON.stringify(initialRunMetadata) : null,
+    );
 
     const retryMessagingState = options.messagingRetryState || {};
     const carriedVisibleMessage = String(retryMessagingState.lastVisibleMessage || '').trim();
@@ -1666,6 +1688,7 @@ class AgentEngine {
       status: 'running',
       aborted: false,
       messagingSent: false,
+      noResponse: false,
       explicitMessageSent: carriedExplicitMessageSent,
       lastSentMessage: carriedExplicitMessageSent ? carriedVisibleMessage : '',
       sentMessages: [],
@@ -2199,7 +2222,17 @@ class AgentEngine {
             break;
           }
           if (iteration < maxIterations) {
-            const fallbackStatus = (toolExecutions.length > 0 || failedStepCount > 0 || messagingSent) ? 'continue' : 'complete';
+            const proactiveRunNeedsDecision = (
+              (triggerSource === 'schedule' || triggerSource === 'tasks')
+              && this.activeRuns.get(runId)?.noResponse !== true
+              && options.deliveryState?.noResponse !== true
+            );
+            const fallbackStatus = (
+              proactiveRunNeedsDecision
+              || toolExecutions.length > 0
+              || failedStepCount > 0
+              || messagingSent
+            ) ? 'continue' : 'complete';
             const loopState = await runWithModelFallback('loop decision', () => this.decideLoopState({
               provider,
               providerName,
@@ -2596,6 +2629,18 @@ class AgentEngine {
         && !messagingSent
         && runMeta?.widgetSnapshotSaved !== true
       ) {
+        const explicitNoResponse = (
+          runMeta?.noResponse === true
+          || options.deliveryState?.noResponse === true
+        );
+        if (
+          (triggerSource === 'schedule' || triggerSource === 'tasks')
+          && !explicitNoResponse
+        ) {
+          throw new Error(
+            'Background run ended without producing a result or an explicit no-response decision.',
+          );
+        }
         if (iteration >= maxIterations) {
           throw new Error(`Iteration limit reached before explicit completion after ${maxIterations} iterations.`);
         }
@@ -3358,4 +3403,4 @@ class AgentEngine {
   }
 }
 
-module.exports = { AgentEngine, getProviderForUser };
+module.exports = { AgentEngine, buildInitialRunMetadata, getProviderForUser };

package/server/services/ai/tools.js

@@ -274,6 +274,15 @@ function markProactiveMessageSent({ runState, deliveryState, content }) {
     }
 }
 
+function markProactiveNoResponse({ runState, deliveryState }) {
+    if (runState) {
+        runState.noResponse = true;
+    }
+    if (deliveryState) {
+        deliveryState.noResponse = true;
+    }
+}
+
 function normalizeStoredSettingString(value) {
     if (value == null) return '';
     if (typeof value !== 'string') return String(value || '').trim();
@@ -2139,6 +2148,9 @@ async function executeTool(toolName, args, context, engine) {
                             error: proactiveValidation.error,
                         };
                     }
+                    if (proactiveValidation.reason === 'no_response') {
+                        markProactiveNoResponse({ runState, deliveryState });
+                    }
                     return {
                         sent: false,
                         suppressed: proactiveValidation.suppressed === true,

package/server/services/tasks/integration_runtime.js

@@ -275,7 +275,10 @@ async function pollIntegrationTask(runtime, task) {
   const startIndex = rows.findIndex((row) => row.fingerprint === existingFingerprint);
   const pending = startIndex >= 0 ? rows.slice(startIndex + 1) : rows.slice(-1);
   for (const row of pending) {
-    await runtime.fireTaskFromTrigger(task.id, task.user_id, row);
+    const result = await runtime.fireTaskFromTrigger(task.id, task.user_id, row);
+    if (result?.error || (result?.skipped && result.reason !== 'duplicate_trigger')) {
+      break;
+    }
   }
 }
 

package/server/services/tasks/runtime.js

@@ -62,11 +62,7 @@ function stringifyTaskResult(result) {
     if (nested) return nested;
   }
 
-  try {
-    return JSON.stringify(result, null, 2);
-  } catch {
-    return String(result || '');
-  }
+  return '';
 }
 
 class TaskRuntime {
@@ -189,6 +185,8 @@ class TaskRuntime {
       manual: true,
       triggerType: task.trigger_type || 'schedule',
       triggerSource: 'manual',
+    }).catch((error) => {
+      console.error(`[Tasks] Manual task ${taskId} error:`, error.message);
     });
     return { running: true };
   }
@@ -203,9 +201,8 @@ class TaskRuntime {
     if (String(task.last_trigger_fingerprint || '') === fingerprint) {
       return { skipped: true, reason: 'duplicate_trigger' };
     }
-    this.taskRepository.markTaskTriggered(taskId, userId, fingerprint);
 
-    return this._executeTask(taskId, userId, {
+    const result = await this._executeTask(taskId, userId, {
       manual: false,
       oneTime: false,
       scheduledAt: triggerPayload.timestamp || new Date().toISOString(),
@@ -213,39 +210,58 @@ class TaskRuntime {
       triggerSource: task.trigger_type || 'schedule',
       triggerPayload: triggerPayload.context || {},
     });
+    if (!result?.error && !result?.skipped) {
+      this.taskRepository.markTaskTriggered(taskId, userId, fingerprint);
+    }
+    return result;
   }
 
   _startOneTimePoller() {
     this.oneTimePoller = cron.schedule('* * * * *', async () => {
-      const due = this.taskRepository.listDueOneTimeTasks();
+      try {
+        await this._runDueOneTimeTasks();
+      } catch (error) {
+        console.error('[Tasks] One-time task poll failed:', error.message);
+      }
+    });
+  }
 
-      for (const task of due) {
-        this.scheduleJobs.delete(task.id);
-        try {
-          await this._executeTask(task.id, task.user_id, {
-            scheduledAt: task.run_at || new Date().toISOString(),
-            oneTime: true,
-            triggerType: 'schedule',
-            triggerSource: 'schedule',
-          });
-        } catch (err) {
-          console.error(`[Tasks] One-time task ${task.id} error:`, err.message);
+  async _runDueOneTimeTasks() {
+    const due = this.taskRepository.listDueOneTimeTasks();
+
+    for (const task of due) {
+      this.scheduleJobs.delete(task.id);
+      try {
+        const result = await this._executeTask(task.id, task.user_id, {
+          scheduledAt: task.run_at || new Date().toISOString(),
+          oneTime: true,
+          triggerType: 'schedule',
+          triggerSource: 'schedule',
+        });
+        if (result?.skipped) {
+          continue;
         }
-        this.taskRepository.deleteById(task.id, task.user_id);
+        this.taskRepository.deleteTask(task.id, task.user_id);
         this.io.to(`user:${task.user_id}`).emit('tasks:task_deleted', { taskId: task.id });
+      } catch (err) {
+        console.error(`[Tasks] One-time task ${task.id} error:`, err.message);
       }
-    });
+    }
   }
 
   _startIntegrationPoller() {
     this.integrationPoller = cron.schedule(INTEGRATION_TRIGGER_POLL_CRON, async () => {
-      const tasks = this.taskRepository.listEnabledByTriggerTypes(POLLED_TRIGGER_TYPES);
-      for (const task of tasks) {
-        try {
-          await pollIntegrationTask(this, task);
-        } catch (error) {
-          console.error(`[Tasks] Trigger poll failed for task ${task.id}:`, error.message);
+      try {
+        const tasks = this.taskRepository.listEnabledByTriggerTypes(POLLED_TRIGGER_TYPES);
+        for (const task of tasks) {
+          try {
+            await pollIntegrationTask(this, task);
+          } catch (error) {
+            console.error(`[Tasks] Trigger poll failed for task ${task.id}:`, error.message);
+          }
         }
+      } catch (error) {
+        console.error('[Tasks] Integration trigger poll failed:', error.message);
       }
     });
   }
@@ -258,13 +274,17 @@ class TaskRuntime {
     const cronExpression = String(triggerConfig.cronExpression || '').trim();
     if (!cronExpression) return;
     const job = cron.schedule(cronExpression, async () => {
-      await this._executeTask(task.id, task.user_id, {
-        scheduledAt: new Date().toISOString(),
-        manual: false,
-        oneTime: false,
-        triggerType: 'schedule',
-        triggerSource: 'schedule',
-      });
+      try {
+        await this._executeTask(task.id, task.user_id, {
+          scheduledAt: new Date().toISOString(),
+          manual: false,
+          oneTime: false,
+          triggerType: 'schedule',
+          triggerSource: 'schedule',
+        });
+      } catch (error) {
+        console.error(`[Tasks] Scheduled task ${task.id} error:`, error.message);
+      }
     });
     this.scheduleJobs.set(task.id, { task: job, userId: task.user_id });
   }
@@ -324,6 +344,15 @@ class TaskRuntime {
     this.taskRepository.markTaskRun(taskId, userId);
     this.io.to(`user:${userId}`).emit('tasks:task_running', { taskId, timestamp: new Date().toISOString() });
 
+    let normalizedConfig = taskConfig;
+    const taskName = task.name || `Task ${taskId}`;
+    const deliveryState = {
+      messagingSent: false,
+      noResponse: false,
+      lastSentMessage: '',
+      sentMessages: [],
+    };
+    let completedRunId = null;
     try {
       if (task.task_type === 'widget_refresh') {
         const widgetService = this.app?.locals?.widgetService;
@@ -339,8 +368,7 @@ class TaskRuntime {
         return result;
       }
 
-      const normalizedConfig = this._ensureDefaultNotifyTarget(userId, agentId, taskConfig, taskId);
-      const taskName = task.name || `Task ${taskId}`;
+      normalizedConfig = this._ensureDefaultNotifyTarget(userId, agentId, taskConfig, taskId);
       const triggerSummary = this._summarizeTrigger(task.trigger_type, triggerConfig);
       let notifyHint = '';
 
@@ -366,7 +394,6 @@ class TaskRuntime {
       ].filter(Boolean).join('\n\n');
 
       const conversationId = this._getTaskConversation(userId, taskId, taskName, agentId);
-      const deliveryState = { messagingSent: false, lastSentMessage: '', sentMessages: [] };
       let attempt = 0;
       let recoveryNote = '';
       while (attempt <= MAX_AUTONOMOUS_RETRIES) {
@@ -394,6 +421,7 @@ class TaskRuntime {
           const result = typeof this.agentEngine.runWithModel === 'function'
             ? await this.agentEngine.runWithModel(userId, finalPrompt, runOptions, normalizedConfig.model || null)
             : await this.agentEngine.run(userId, finalPrompt, runOptions);
+          completedRunId = result?.runId || null;
           const fallbackDelivery = await this._deliverTaskResultIfNeeded({
             userId,
             agentId,
@@ -405,11 +433,30 @@ class TaskRuntime {
           if (fallbackDelivery && result && typeof result === 'object') {
             result.taskDelivery = fallbackDelivery;
           }
+          if (fallbackDelivery?.error) {
+            const deliveryError = new Error(fallbackDelivery.error);
+            deliveryError.code = 'TASK_DELIVERY_FAILED';
+            throw deliveryError;
+          }
+          if (
+            !deliveryState.messagingSent
+            && !deliveryState.noResponse
+            && !stringifyTaskResult(result).trim()
+          ) {
+            throw new Error(
+              'Background task completed without producing a result or an explicit no-response decision.',
+            );
+          }
           this.io.to(`user:${userId}`).emit('tasks:task_complete', { taskId, result });
           return result;
         } catch (err) {
+          if (completedRunId) {
+            this.taskRepository.markAgentRunFailed(completedRunId, userId, err.message);
+          }
+          if (err?.code === 'TASK_DELIVERY_FAILED') throw err;
           if (attempt >= MAX_AUTONOMOUS_RETRIES) throw err;
           attempt += 1;
+          completedRunId = null;
           recoveryNote = [
             '\n\n[SYSTEM: Previous task attempt failed]',
             `Error: ${String(err?.message || 'Unknown runtime error')}`,
@@ -424,12 +471,24 @@ class TaskRuntime {
       }
     } catch (err) {
       console.error(`[Tasks] Task ${taskId} error:`, err.message);
+      if (err?.code !== 'TASK_DELIVERY_FAILED') {
+        await this._deliverTaskResultIfNeeded({
+          userId,
+          agentId,
+          taskId,
+          taskConfig: normalizedConfig,
+          result: {
+            content: `Background task "${taskName}" could not complete after retrying. Check the task run logs for details.`,
+          },
+          deliveryState,
+        });
+      }
       this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
         taskId,
         reason: 'execution_failed',
         timestamp: new Date().toISOString(),
       });
-      return { skipped: false, error: err.message };
+      return { skipped: false, error: err.message, runId: completedRunId };
     }
   }
 
@@ -518,7 +577,10 @@ class TaskRuntime {
       triggerSummary,
       nextRun: triggerType === 'schedule' ? scheduleAdapter.nextRun(triggerConfig) : null,
       enabled: !!row.enabled,
-      lastRun: row.last_run || null,
+      lastRun: row.last_run_started_at || row.last_run || null,
+      lastRunId: row.last_run_id || null,
+      lastRunStatus: row.last_run_status || null,
+      lastRunError: row.last_run_error || null,
       lastTriggeredAt: row.last_triggered_at || null,
       taskType: row.task_type || 'agent_prompt',
       taskConfig,
@@ -618,13 +680,18 @@ class TaskRuntime {
     result,
     deliveryState,
   }) {
-    if (deliveryState?.messagingSent || taskConfig.callTo) return null;
-    const manager = this.app?.locals?.messagingManager || this.agentEngine?.messagingManager || null;
-    if (!manager) return null;
-
+    if (deliveryState?.messagingSent || deliveryState?.noResponse || taskConfig.callTo) return null;
     const targets = this._buildNotifyTargets(userId, agentId, taskConfig);
     if (!targets.length) return null;
 
+    const manager = this.app?.locals?.messagingManager || this.agentEngine?.messagingManager || null;
+    if (!manager) {
+      return {
+        sent: false,
+        error: 'Messaging delivery is unavailable on this server.',
+      };
+    }
+
     let lastError = null;
     for (const target of targets) {
       const message = normalizeOutgoingMessageForPlatform(
@@ -676,6 +743,10 @@ class TaskRuntime {
 
     if (lastError) {
       console.error(`[Tasks] Task ${taskId} notification delivery failed:`, lastError.message);
+      return {
+        sent: false,
+        error: lastError.message,
+      };
     }
     return null;
   }

package/server/services/tasks/task_repository.js

@@ -59,16 +59,34 @@ class TaskRepository {
   }
 
   listTasksForAgent(userId, agentId, includeLegacyMainTasks) {
+    const select = `
+      SELECT
+        scheduled_tasks.*,
+        latest_run.id AS last_run_id,
+        latest_run.status AS last_run_status,
+        latest_run.error AS last_run_error,
+        latest_run.created_at AS last_run_started_at
+      FROM scheduled_tasks
+      LEFT JOIN agent_runs AS latest_run ON latest_run.id = (
+        SELECT candidate.id
+        FROM agent_runs AS candidate
+        WHERE candidate.user_id = scheduled_tasks.user_id
+          AND json_valid(candidate.metadata_json)
+          AND CAST(json_extract(candidate.metadata_json, '$.taskId') AS TEXT) = CAST(scheduled_tasks.id AS TEXT)
+        ORDER BY candidate.created_at DESC, candidate.rowid DESC
+        LIMIT 1
+      )`;
     return includeLegacyMainTasks
       ? db.prepare(
-        `SELECT * FROM scheduled_tasks
-         WHERE user_id = ? AND (agent_id = ? OR agent_id IS NULL)
-         ORDER BY created_at DESC`
+        `${select}
+         WHERE scheduled_tasks.user_id = ?
+           AND (scheduled_tasks.agent_id = ? OR scheduled_tasks.agent_id IS NULL)
+         ORDER BY scheduled_tasks.created_at DESC`
       ).all(userId, agentId)
       : db.prepare(
-        `SELECT * FROM scheduled_tasks
-         WHERE user_id = ? AND agent_id = ?
-         ORDER BY created_at DESC`
+        `${select}
+         WHERE scheduled_tasks.user_id = ? AND scheduled_tasks.agent_id = ?
+         ORDER BY scheduled_tasks.created_at DESC`
       ).all(userId, agentId);
   }
 
@@ -126,6 +144,17 @@ class TaskRepository {
     db.prepare('UPDATE scheduled_tasks SET last_run = datetime(\'now\') WHERE id = ? AND user_id = ?').run(taskId, userId);
   }
 
+  markAgentRunFailed(runId, userId, error) {
+    db.prepare(
+      `UPDATE agent_runs
+       SET status = 'failed',
+           error = ?,
+           updated_at = datetime('now'),
+           completed_at = COALESCE(completed_at, datetime('now'))
+       WHERE id = ? AND user_id = ?`
+    ).run(String(error || 'Task execution failed.'), runId, userId);
+  }
+
   updateTaskConfig(taskId, userId, taskConfig) {
     db.prepare('UPDATE scheduled_tasks SET task_config = ? WHERE id = ? AND user_id = ?')
       .run(JSON.stringify(taskConfig), taskId, userId);