neoagent 2.4.1-beta.31 → 2.4.1-beta.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.4.1-beta.31",
+  "version": "2.4.1-beta.33",
   "description": "Proactive personal AI agent with no limits",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",

package/server/public/.last_build_id

@@ -1 +1 @@
-2351b2d608550a07f9f6f1166c4e2dd1
+49442e542f5b85df16e4fff2751cb6a3

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"c416acfeb8126e097f758c664aaa3da929e27d
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "2374886575" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "2270904145" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -133653,7 +133653,7 @@ r===$&&A.b()
 o.push(A.jM(p,A.j9(!1,new A.a2(B.un,A.ds(new A.cB(B.ho,new A.a7n(r,p),p),p,p),p),!1,B.H,!0),p,p,0,0,0,p))}r=!1
 if(!s.ay)if(!s.ch){r=s.e
 r===$&&A.b()
-r=B.b.t("mpx7ced1-e804d27").length!==0&&r.b}if(r){r=s.d
+r=B.b.t("mpzv8963-3cb08c9").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.av&&!r.aP?84:0
 q=s.e
@@ -139137,7 +139137,7 @@ $S:0}
 A.ZM.prototype={}
 A.Su.prototype={
 nc(a){var s=this
-if(B.b.t("mpx7ced1-e804d27").length===0||s.a!=null)return
+if(B.b.t("mpzv8963-3cb08c9").length===0||s.a!=null)return
 s.AM()
 s.a=A.qe(B.R2,new A.b9L(s))},
 AM(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -139155,7 +139155,7 @@ if(!t.f.b(k)){s=1
 break}i=J.T(k,"buildId")
 h=i==null?null:B.b.t(J.p(i))
 j=h==null?"":h
-if(J.bf(j)===0||J.d(j,"mpx7ced1-e804d27")){s=1
+if(J.bf(j)===0||J.d(j,"mpzv8963-3cb08c9")){s=1
 break}n.b=!0
 n.D()
 p=2
@@ -139172,7 +139172,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$AM,r)},
 vu(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$vu=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.t("mpx7ced1-e804d27").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.t("mpzv8963-3cb08c9").length===0||n.c){s=1
 break}n.c=!0
 n.D()
 p=4

package/server/services/ai/tools.js

@@ -274,6 +274,33 @@ function markProactiveMessageSent({ runState, deliveryState, content }) {
     }
 }
 
+function normalizeStoredSettingString(value) {
+    if (value == null) return '';
+    if (typeof value !== 'string') return String(value || '').trim();
+    let current = value.trim();
+    for (let i = 0; i < 2; i += 1) {
+        if (!current) return '';
+        try {
+            const parsed = JSON.parse(current);
+            if (typeof parsed === 'string') {
+                current = parsed.trim();
+                continue;
+            }
+            return '';
+        } catch {
+            return current;
+        }
+    }
+    return current;
+}
+
+function normalizeMessagingTarget(target = {}) {
+    const platform = normalizeStoredSettingString(target.platform);
+    const to = normalizeStoredSettingString(target.to);
+    if (!platform || !to) return null;
+    return { platform, to };
+}
+
 function buildAndroidUiMatchProperties(extra = {}) {
     return {
         x: { type: 'number', description: 'Absolute X coordinate' },
@@ -2323,8 +2350,8 @@ async function executeTool(toolName, args, context, engine) {
                     || null
                 );
                 const loadDefaultTarget = () => ({
-                    platform: loadAgentSetting('last_platform'),
-                    to: loadAgentSetting('last_chat_id')
+                    platform: normalizeStoredSettingString(loadAgentSetting('last_platform')),
+                    to: normalizeStoredSettingString(loadAgentSetting('last_chat_id'))
                 });
 
                 let taskConfig = null;
@@ -2336,26 +2363,43 @@ async function executeTool(toolName, args, context, engine) {
                         try {
                             taskConfig = JSON.parse(task.task_config || '{}');
                             taskTarget = {
-                                platform: taskConfig.notifyPlatform || null,
-                                to: taskConfig.notifyTo || null
+                                platform: normalizeStoredSettingString(taskConfig.notifyPlatform),
+                                to: normalizeStoredSettingString(taskConfig.notifyTo)
                             };
                         } catch { }
                     }
                 }
 
                 const fallbackTarget = loadDefaultTarget();
+                const recentTargets = db.prepare(
+                    `SELECT platform, platform_chat_id
+                     FROM messages
+                     WHERE user_id = ?
+                       AND agent_id = ?
+                       AND platform IS NOT NULL
+                       AND platform_chat_id IS NOT NULL
+                     ORDER BY id DESC
+                     LIMIT 20`
+                ).all(userId, agentId);
                 const candidateTargets = [];
                 const seenTargets = new Set();
                 const addCandidate = (target) => {
-                    if (!target?.platform || !target?.to) return;
-                    const key = `${target.platform}:${target.to}`;
+                    const normalizedTarget = normalizeMessagingTarget(target);
+                    if (!normalizedTarget) return;
+                    const key = `${normalizedTarget.platform}:${normalizedTarget.to}`;
                     if (seenTargets.has(key)) return;
                     seenTargets.add(key);
-                    candidateTargets.push(target);
+                    candidateTargets.push(normalizedTarget);
                 };
 
                 addCandidate(taskTarget);
                 addCandidate(fallbackTarget);
+                for (const row of recentTargets) {
+                    addCandidate({
+                        platform: row.platform,
+                        to: row.platform_chat_id
+                    });
+                }
 
                 if (candidateTargets.length === 0) {
                     throw new Error('No messaging target is configured for this task run. Connect a platform and send at least one message on this server, or recreate the task after reconnecting.');

package/server/services/messaging/formatting_guides.js

@@ -99,9 +99,34 @@ function adaptSpokenFormatting(text) {
     .trim();
 }
 
+function coerceMessageContent(content) {
+  if (typeof content === 'string') return content;
+  if (content == null) return '';
+  if (typeof content === 'number' || typeof content === 'boolean' || typeof content === 'bigint') {
+    return String(content);
+  }
+  if (typeof content !== 'object') return String(content || '');
+
+  for (const key of ['text', 'content', 'message', 'summary']) {
+    if (typeof content[key] === 'string' && content[key].trim()) {
+      return content[key];
+    }
+  }
+
+  if (content.result != null && content.result !== content) {
+    return coerceMessageContent(content.result);
+  }
+
+  try {
+    return JSON.stringify(content, null, 2);
+  } catch {
+    return String(content || '');
+  }
+}
+
 function normalizeOutgoingMessageForPlatform(platform, content, options = {}) {
   const profile = getPlatformFormattingProfile(platform);
-  let text = String(content || '');
+  let text = coerceMessageContent(content);
 
   if (options.stripNoResponseMarker !== false) {
     text = text.replace(/\[NO RESPONSE\]/gi, '');

package/server/services/messaging/manager.js

@@ -104,6 +104,9 @@ class MessagingManager extends EventEmitter {
       return null;
     }
 
+    const normalizedIncomingContent = normalizeOutgoingMessageForPlatform(platformName, msg?.content, {
+      stripNoResponseMarker: false
+    });
     const agentId = this._agentId(userId, {
       ...options,
       agentId: options?.agentId ?? msg?.agentId ?? null,
@@ -135,7 +138,7 @@ class MessagingManager extends EventEmitter {
         userId,
         agentId,
         'user',
-        msg.content,
+        normalizedIncomingContent,
         platformName,
         msg.messageId,
         msg.chatId,
@@ -143,7 +146,7 @@ class MessagingManager extends EventEmitter {
         msg.timestamp,
       );
 
-    const enrichedMsg = { ...msg, agentId, platform: platformName };
+    const enrichedMsg = { ...msg, content: normalizedIncomingContent, agentId, platform: platformName };
 
     if (this.isShuttingDown) {
       return enrichedMsg;

package/server/services/tasks/runtime.js

@@ -13,11 +13,58 @@ const { TaskRepository } = require('./task_repository');
 const { TriggerRegistry } = require('./trigger_registry');
 const scheduleAdapter = require('./adapters/schedule');
 const { normalizeJsonObject } = require('./utils');
+const { normalizeOutgoingMessageForPlatform } = require('../messaging/formatting_guides');
 
 const MAX_AUTONOMOUS_RETRIES = 1;
 const MAX_RECURRING_TASK_START_DELAY_MS = 90 * 1000;
 const INTEGRATION_TRIGGER_POLL_CRON = '* * * * *';
 
+function normalizeStoredString(value) {
+  if (value == null) return '';
+  if (typeof value !== 'string') return String(value || '').trim();
+  let current = value.trim();
+  for (let i = 0; i < 2; i += 1) {
+    if (!current) return '';
+    try {
+      const parsed = JSON.parse(current);
+      if (typeof parsed === 'string') {
+        current = parsed.trim();
+        continue;
+      }
+      return '';
+    } catch {
+      return current;
+    }
+  }
+  return current;
+}
+
+function normalizeNotifyTarget(target = {}) {
+  const platform = normalizeStoredString(target.platform);
+  const to = normalizeStoredString(target.to);
+  if (!platform || !to) return null;
+  return { platform, to };
+}
+
+function stringifyTaskResult(result) {
+  if (typeof result === 'string') return result;
+  if (result == null) return '';
+  if (typeof result !== 'object') return String(result);
+
+  for (const key of ['content', 'message', 'text', 'summary', 'finalResponse', 'final_response']) {
+    if (typeof result[key] === 'string' && result[key].trim()) {
+      return result[key];
+    }
+  }
+
+  if (result.result != null && result.result !== result) {
+    const nested = stringifyTaskResult(result.result);
+    if (nested) return nested;
+  }
+
+  return '';
+}
+
 class TaskRuntime {
   constructor(io, agentEngine, app = null) {
     this.io = io;
@@ -343,6 +390,17 @@ 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);
+          const fallbackDelivery = await this._deliverTaskResultIfNeeded({
+            userId,
+            agentId,
+            taskId,
+            taskConfig: normalizedConfig,
+            result,
+            deliveryState,
+          });
+          if (fallbackDelivery && result && typeof result === 'object') {
+            result.taskDelivery = fallbackDelivery;
+          }
           this.io.to(`user:${userId}`).emit('tasks:task_complete', { taskId, result });
           return result;
         } catch (err) {
@@ -362,7 +420,11 @@ class TaskRuntime {
       }
     } catch (err) {
       console.error(`[Tasks] Task ${taskId} error:`, err.message);
-      this.io.to(`user:${userId}`).emit('tasks:task_error', { taskId, error: err.message });
+      this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
+        taskId,
+        reason: 'execution_failed',
+        timestamp: new Date().toISOString(),
+      });
       return { skipped: false, error: err.message };
     }
   }
@@ -486,25 +548,134 @@ class TaskRuntime {
 
   _getDefaultNotifyTarget(userId, agentId = null) {
     const scopedAgentId = resolveAgentId(userId, agentId);
-    return {
+    return normalizeNotifyTarget({
       platform: this._getAgentSetting(userId, scopedAgentId, 'last_platform'),
       to: this._getAgentSetting(userId, scopedAgentId, 'last_chat_id'),
-    };
+    });
+  }
+
+  _buildNotifyTargets(userId, agentId, taskConfig = {}) {
+    const scopedAgentId = resolveAgentId(userId, agentId);
+    const candidates = [
+      normalizeNotifyTarget({
+        platform: taskConfig.notifyPlatform,
+        to: taskConfig.notifyTo,
+      }),
+      this._getDefaultNotifyTarget(userId, scopedAgentId),
+      ...this.taskRepository.listRecentMessageTargets(userId, scopedAgentId).map((row) => normalizeNotifyTarget({
+        platform: row.platform,
+        to: row.platform_chat_id,
+      })),
+    ];
+
+    const unique = [];
+    const seen = new Set();
+    for (const target of candidates) {
+      if (!target) continue;
+      const key = `${target.platform}:${target.to}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      unique.push(target);
+    }
+    return unique;
   }
 
   _ensureDefaultNotifyTarget(userId, agentId, taskConfig, taskId) {
     const normalized = { ...taskConfig };
-    if (!normalized.callTo && (!normalized.notifyPlatform || !normalized.notifyTo)) {
-      const notifyTarget = this._getDefaultNotifyTarget(userId, agentId);
-      if (notifyTarget.platform && notifyTarget.to) {
+    const existingTarget = normalizeNotifyTarget({
+      platform: normalized.notifyPlatform,
+      to: normalized.notifyTo,
+    });
+    if (existingTarget) {
+      normalized.notifyPlatform = existingTarget.platform;
+      normalized.notifyTo = existingTarget.to;
+    }
+    if (!normalized.callTo && !existingTarget) {
+      const notifyTarget = this._buildNotifyTargets(userId, agentId, normalized)[0];
+      if (notifyTarget) {
         normalized.notifyPlatform = notifyTarget.platform;
         normalized.notifyTo = notifyTarget.to;
-        this.taskRepository.updateTaskConfig(taskId, userId, normalized);
       }
     }
+    if (
+      normalized.notifyPlatform !== taskConfig.notifyPlatform
+      || normalized.notifyTo !== taskConfig.notifyTo
+    ) {
+      this.taskRepository.updateTaskConfig(taskId, userId, normalized);
+    }
     return normalized;
   }
 
+  async _deliverTaskResultIfNeeded({
+    userId,
+    agentId,
+    taskId,
+    taskConfig,
+    result,
+    deliveryState,
+  }) {
+    if (deliveryState?.messagingSent || taskConfig.callTo) return null;
+    const manager = this.app?.locals?.messagingManager || this.agentEngine?.messagingManager || null;
+    if (!manager) return null;
+
+    const targets = this._buildNotifyTargets(userId, agentId, taskConfig);
+    if (!targets.length) return null;
+
+    let lastError = null;
+    for (const target of targets) {
+      const message = normalizeOutgoingMessageForPlatform(
+        target.platform,
+        stringifyTaskResult(result),
+        { stripNoResponseMarker: false },
+      );
+      if (!message || message.toUpperCase() === '[NO RESPONSE]') return null;
+
+      const status = typeof manager.getPlatformStatus === 'function'
+        ? manager.getPlatformStatus(userId, target.platform, { agentId })
+        : null;
+      if (!status || status.status !== 'connected') {
+        lastError = new Error(`Platform ${target.platform} is not connected on this server.`);
+        continue;
+      }
+
+      try {
+        const sendResult = await manager.sendMessage(userId, target.platform, target.to, message, {
+          agentId,
+          runId: result?.runId || null,
+          persistConversation: true,
+        });
+        deliveryState.messagingSent = true;
+        deliveryState.lastSentMessage = message;
+        if (!Array.isArray(deliveryState.sentMessages)) {
+          deliveryState.sentMessages = [];
+        }
+        deliveryState.sentMessages.push(message);
+
+        if (taskConfig.notifyPlatform !== target.platform || taskConfig.notifyTo !== target.to) {
+          this.taskRepository.updateTaskConfig(taskId, userId, {
+            ...taskConfig,
+            notifyPlatform: target.platform,
+            notifyTo: target.to,
+          });
+        }
+
+        return {
+          sent: true,
+          platform: target.platform,
+          to: target.to,
+          result: sendResult,
+        };
+      } catch (error) {
+        lastError = error;
+      }
+    }
+
+    if (lastError) {
+      console.error(`[Tasks] Task ${taskId} notification delivery failed:`, lastError.message);
+    }
+    return null;
+  }
+
   _getTaskConversation(userId, taskId, taskName, agentId = null) {
     const scopedAgentId = resolveAgentId(userId, agentId);
     const platform = 'tasks';

package/server/services/tasks/task_repository.js

@@ -131,6 +131,19 @@ class TaskRepository {
       .run(JSON.stringify(taskConfig), taskId, userId);
   }
 
+  listRecentMessageTargets(userId, agentId, limit = 20) {
+    return db.prepare(
+      `SELECT platform, platform_chat_id
+       FROM messages
+       WHERE user_id = ?
+         AND agent_id = ?
+         AND platform IS NOT NULL
+         AND platform_chat_id IS NOT NULL
+       ORDER BY id DESC
+       LIMIT ?`
+    ).all(userId, agentId, Math.max(1, Math.min(Number(limit) || 20, 100)));
+  }
+
   getAgentSetting(userId, agentId, key) {
     return db.prepare('SELECT value FROM agent_settings WHERE user_id = ? AND agent_id = ? AND key = ?')
       .get(userId, agentId, key);