neoagent 2.5.2-beta.0 → 2.5.2-beta.10

package/server/services/ai/tools.js

@@ -9,6 +9,7 @@ const {
     normalizeOutgoingMessageForPlatform,
 } = require('../messaging/formatting_guides');
 const { INTERIM_KINDS, normalizeInterimKind } = require('./interim');
+const { normalizeWhatsAppId } = require('../../utils/whatsapp');
 const {
     executeIntegratedTool,
     getIntegratedToolDefinitions,
@@ -255,22 +256,32 @@ function hasAlreadySentProactiveMessage({ triggerSource, runState, deliveryState
 }
 
 function markProactiveMessageSent({ runState, deliveryState, content }) {
-    const message = String(content || '');
-    if (runState) {
-        runState.messagingSent = true;
-        runState.lastSentMessage = message;
-        if (Array.isArray(runState.sentMessages)) {
-            runState.sentMessages.push(message);
-        }
+  const message = String(content || '');
+  const sentAt = new Date().toISOString();
+  if (runState) {
+    runState.messagingSent = true;
+    runState.finalDeliverySent = true;
+    runState.lastFinalDeliveryAt = sentAt;
+    if (runState.progressLedger && typeof runState.progressLedger === 'object') {
+      runState.progressLedger.lastUserVisibleUpdateAt = sentAt;
+      runState.progressLedger.lastFinalDeliveryAt = sentAt;
+      runState.progressLedger.progressState = 'complete';
     }
-
-    if (deliveryState) {
-        deliveryState.messagingSent = true;
-        deliveryState.lastSentMessage = message;
-        if (!Array.isArray(deliveryState.sentMessages)) {
-            deliveryState.sentMessages = [];
-        }
-        deliveryState.sentMessages.push(message);
+    runState.lastSentMessage = message;
+    if (Array.isArray(runState.sentMessages)) {
+      runState.sentMessages.push(message);
+    }
+  }
+
+  if (deliveryState) {
+    deliveryState.messagingSent = true;
+    deliveryState.finalDeliverySent = true;
+    deliveryState.lastFinalDeliveryAt = sentAt;
+    deliveryState.lastSentMessage = message;
+    if (!Array.isArray(deliveryState.sentMessages)) {
+      deliveryState.sentMessages = [];
+    }
+    deliveryState.sentMessages.push(message);
     }
 }
 
@@ -310,6 +321,31 @@ function normalizeMessagingTarget(target = {}) {
     return { platform, to };
 }
 
+function canonicalMessagingAddress(platform, value) {
+    const normalizedPlatform = String(platform || '').trim().toLowerCase();
+    const raw = String(value || '').trim();
+    if (!normalizedPlatform || !raw) return '';
+    if (normalizedPlatform !== 'whatsapp') return raw;
+
+    const lower = raw.toLowerCase();
+    const normalizedId = normalizeWhatsAppId(lower);
+    if (!normalizedId) return '';
+    if (lower.includes('@g.us')) return `group:${normalizedId}`;
+    if (lower.includes('@lid')) return `lid:${normalizedId}`;
+    return `direct:${normalizedId}`;
+}
+
+function isOriginMessagingDelivery({ triggerSource, source, chatId, platform, to }) {
+    if (triggerSource !== 'messaging') return true;
+    const originPlatform = String(source || '').trim().toLowerCase();
+    const targetPlatform = String(platform || '').trim().toLowerCase();
+    if (!originPlatform || !targetPlatform || originPlatform !== targetPlatform) return false;
+
+    const originAddress = canonicalMessagingAddress(originPlatform, chatId);
+    const targetAddress = canonicalMessagingAddress(targetPlatform, to);
+    return Boolean(originAddress && targetAddress && originAddress === targetAddress);
+}
+
 function buildAndroidUiMatchProperties(extra = {}) {
     return {
         x: { type: 'number', description: 'Absolute X coordinate' },
@@ -1613,6 +1649,7 @@ async function executeTool(toolName, args, context, engine) {
         case 'browser_extract': {
             const { provider, backend } = await bc();
             if (!provider) return { error: 'Browser controller not available' };
+            if (!args.selector) return { error: 'browser_extract requires a "selector" argument' };
             return { ...await provider.extract(args.selector, args.attribute, args.all), backend };
         }
 
@@ -1625,7 +1662,9 @@ async function executeTool(toolName, args, context, engine) {
         case 'browser_evaluate': {
             const { provider, backend } = await bc();
             if (!provider) return { error: 'Browser controller not available' };
-            return { ...await provider.evaluate(args.script), backend };
+            const script = args.script ?? args.javascript;
+            if (!script) return { error: 'browser_evaluate requires a "script" argument' };
+            return { ...await provider.evaluate(script), backend };
         }
 
         case 'android_start_emulator': {
@@ -2234,7 +2273,18 @@ async function executeTool(toolName, args, context, engine) {
                 persistConversation: triggerSource === 'schedule' || triggerSource === 'tasks'
             });
             // Track that the agent explicitly sent a message during this run
-            if (!suppressReply && sendResult?.suppressed !== true) {
+            if (
+                !suppressReply
+                && sendResult?.success === true
+                && sendResult?.suppressed !== true
+                && isOriginMessagingDelivery({
+                    triggerSource,
+                    source: context.source,
+                    chatId: context.chatId,
+                    platform: args.platform,
+                    to: args.to,
+                })
+            ) {
                 markProactiveMessageSent({ runState, deliveryState, content: normalizedMessage });
                 if (runState && triggerSource === 'messaging') {
                     runState.explicitMessageSent = true;

package/server/services/messaging/manager.js

@@ -515,6 +515,13 @@ class MessagingManager extends EventEmitter {
     }
 
     const result = await platform.sendMessage(to, normalizedContent, sendOptions);
+    if (result?.success === false) {
+      const reason = result.error || result.reason || 'platform rejected the message';
+      const error = new Error(`Platform ${platformName} delivery failed: ${reason}`);
+      error.code = 'MESSAGING_DELIVERY_FAILED';
+      error.deliveryResult = result;
+      throw error;
+    }
 
     db.prepare('INSERT INTO messages (user_id, agent_id, run_id, role, content, platform, platform_chat_id, media_path, metadata) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
       .run(userId, agentId, runId, 'assistant', normalizedContent, platformName, to, mediaPath, metadata ? JSON.stringify(metadata) : null);

package/server/services/runtime/backends/local-vm.js

@@ -250,8 +250,8 @@ class VmBrowserProvider {
   async typeText(text, options = {}) { return this.#materialize(await this.client.request('POST', '/browser/type-text', { text, ...options })); }
   async pressKey(key, screenshot = true) { return this.#materialize(await this.client.request('POST', '/browser/press-key', { key, screenshot })); }
   async scroll(deltaX, deltaY, screenshot = true) { return this.#materialize(await this.client.request('POST', '/browser/scroll', { deltaX, deltaY, screenshot })); }
-  extract(selector, attribute, all = false) { return this.client.request('POST', '/browser/extract', { selector, attribute, all }); }
-  evaluate(script) { return this.client.request('POST', '/browser/execute', { code: script }); }
+  async extract(selector, attribute, all = false) { return this.client.request('POST', '/browser/extract', { selector, attribute, all }); }
+  async evaluate(script) { return this.client.request('POST', '/browser/execute', { code: script }); }
   async screenshot(options = {}) { return this.#materialize(await this.client.request('POST', '/browser/screenshot', options)); }
   async screenshotJpeg(quality = 80, options = {}) {
     const result = await this.client.request('POST', '/browser/screenshot-jpeg', { ...options, quality });
@@ -259,11 +259,11 @@ class VmBrowserProvider {
     if (!content) throw new Error('VM browser screenshot-jpeg returned no data.');
     return Buffer.from(content, 'base64');
   }
-  launch(options = {}) { return this.client.request('POST', '/browser/launch', options); }
-  closeBrowser() { return this.client.request('POST', '/browser/close'); }
-  fill(selector, value) { return this.type(selector, value); }
-  extractContent(options = {}) { return this.client.request('POST', '/browser/extract', options); }
-  executeJS(code) { return this.evaluate(code); }
+  async launch(options = {}) { return this.client.request('POST', '/browser/launch', options); }
+  async closeBrowser() { return this.client.request('POST', '/browser/close'); }
+  async fill(selector, value) { return this.type(selector, value); }
+  async extractContent(options = {}) { return this.client.request('POST', '/browser/extract', options); }
+  async executeJS(code) { return this.evaluate(code); }
   async getPageInfo() {
     const status = await this.client.request('GET', '/browser/status');
     this.headless = status?.headless !== false;