neoagent 2.4.1-beta.8 → 2.4.1

package/server/services/ai/tools.js

@@ -274,6 +274,42 @@ 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();
+    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' },
@@ -1289,7 +1325,7 @@ function getAvailableTools(app, options = {}) {
     // 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.',
+        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, unverified claims, unresolved tool failures, or confidence below the current run requirement.',
         parameters: {
             type: 'object',
             properties: {
@@ -1300,10 +1336,10 @@ function getAvailableTools(app, options = {}) {
                 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.'
+                    description: 'How confident are you the task is fully and correctly complete? Use "low" only when the final answer is intentionally limited or incomplete; low confidence may be rejected so the run can keep working.'
                 }
             },
-            required: ['message']
+            required: ['message', 'confidence']
         }
     });
 
@@ -1405,7 +1441,7 @@ async function executeTool(toolName, args, context, engine) {
         const manager = runtime();
         if (manager && typeof manager.getBrowserProviderForUser === 'function') {
             const backend = typeof manager.getActiveBrowserBackend === 'function'
-                ? manager.getActiveBrowserBackend(userId)
+                ? await Promise.resolve(manager.getActiveBrowserBackend(userId))
                 : 'vm';
             return { provider: await manager.getBrowserProviderForUser(userId), backend };
         }
@@ -1489,7 +1525,7 @@ async function executeTool(toolName, args, context, engine) {
                 timeout: args.timeout || (args.pty ? 20 * 60 * 1000 : 15 * 60 * 1000),
                 stdinInput: args.stdin_input,
                 pty: args.pty === true,
-                inputs: args.inputs || [],
+                inputs: Array.isArray(args.inputs) ? args.inputs : [],
             };
             if (typeof runtimeManager.executeCliCommand === 'function') {
                 return await runtimeManager.executeCliCommand(userId, args.command, execOptions);
@@ -2112,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,
@@ -2323,8 +2362,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 +2375,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.');
@@ -2611,8 +2667,14 @@ async function executeTool(toolName, args, context, engine) {
                 let tools = [];
                 if (autoStart) {
                     try {
-                        await mcpClient.startServer(serverId, args.command, args.name, userId, { agentId });
-                        tools = await mcpClient.listTools(serverId, userId);
+                        const startResult = await mcpClient.startServer(
+                            serverId,
+                            args.command,
+                            args.name,
+                            userId,
+                            { agentId }
+                        );
+                        tools = startResult.tools || [];
                     } catch (startErr) {
                         return { registered: true, id: serverId, started: false, error: `Registered but failed to start: ${startErr.message}` };
                     }
@@ -2635,7 +2697,10 @@ async function executeTool(toolName, args, context, engine) {
                     args: JSON.parse(s.config || '{}').args || [],
                     enabled: !!s.enabled,
                     status: liveStatuses[s.id]?.status || 'stopped',
-                    toolCount: liveStatuses[s.id]?.toolCount || 0
+                    toolCount: liveStatuses[s.id]?.toolCount || 0,
+                    error: liveStatuses[s.id]?.error || null,
+                    consecutiveFails: liveStatuses[s.id]?.consecutiveFails || 0,
+                    nextRetryAt: liveStatuses[s.id]?.nextRetryAt || null
                 }))
             };
         }

package/server/services/android/controller.js

@@ -354,7 +354,7 @@ class AndroidController {
 
   async capturePng(_opts = {}) {
     const serial = this.#requireSerial();
-    return this.#adbCapture(serial, ['exec-out', 'screencap', '-p']);
+    return this.#adbCaptureAsync(serial, ['exec-out', 'screencap', '-p']);
   }
 
   async observe(_opts = {}) { return this.screenshot(); }
@@ -473,6 +473,41 @@ class AndroidController {
     return (r.status === 0 && r.stdout?.length) ? r.stdout : null;
   }
 
+  #adbCaptureAsync(serial, args) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(adbBin(this.sdkDir), ['-s', serial, ...args]);
+      const chunks = [];
+      const errors = [];
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        try { proc.kill('SIGKILL'); } catch {}
+        reject(new Error('adb capture timed out'));
+      }, 15000);
+      timer.unref?.();
+      proc.stdout?.on('data', (chunk) => chunks.push(chunk));
+      proc.stderr?.on('data', (chunk) => errors.push(chunk));
+      proc.on('error', (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        reject(error);
+      });
+      proc.on('close', (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (code === 0 && chunks.length) {
+          resolve(Buffer.concat(chunks));
+          return;
+        }
+        const message = Buffer.concat(errors).toString('utf8').trim();
+        reject(new Error(message || `adb capture exit ${code}`));
+      });
+    });
+  }
+
   #saveArtifact(data) {
     if (!data || !this.artifactStore) return null;
     const alloc = this.artifactStore.allocateFile(this.userId, { kind: 'screenshot', extension: 'png', contentType: 'image/png' });

package/server/services/browser/controller.js

@@ -600,6 +600,24 @@ class BrowserController {
     }
   }
 
+  async hoverPoint(x, y, options = {}) {
+    const page = await this.ensurePage();
+    try {
+      const px = Math.max(0, Math.round(Number(x) || 0));
+      const py = Math.max(0, Math.round(Number(y) || 0));
+      await page.mouse.move(px, py, { steps: options.steps || 1 });
+      return {
+        success: true,
+        x: px,
+        y: py,
+        url: page.url(),
+        title: await page.title()
+      };
+    } catch (err) {
+      return { error: err.message };
+    }
+  }
+
   async scroll(deltaX = 0, deltaY = 0, screenshot = true) {
     const page = await this.ensurePage();
 

package/server/services/browser/extension/manifest.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const BASE_MANIFEST = require('../../../../extensions/chrome-browser/manifest.json');
+const { getVersionInfo } = require('../../../utils/version');
+
+function chromeVersionFor(packageVersion) {
+  const parts = String(packageVersion || '')
+    .match(/\d+/g)
+    ?.slice(0, 4)
+    .map((part) => Math.min(Number(part) || 0, 65535)) || [];
+
+  while (parts.length < 3) {
+    parts.push(0);
+  }
+
+  return parts.join('.');
+}
+
+function getExtensionManifest() {
+  const { packageVersion } = getVersionInfo();
+  const displayVersion = packageVersion || BASE_MANIFEST.version_name || BASE_MANIFEST.version;
+
+  return {
+    ...BASE_MANIFEST,
+    version: chromeVersionFor(displayVersion),
+    version_name: displayVersion,
+  };
+}
+
+module.exports = {
+  chromeVersionFor,
+  getExtensionManifest,
+};

package/server/services/browser/extension/provider.js

@@ -17,6 +17,7 @@ class ExtensionBrowserProvider {
   constructor(options = {}) {
     this.registry = options.registry;
     this.userId = options.userId != null ? String(options.userId) : null;
+    this.tokenId = options.tokenId ? String(options.tokenId) : null;
     this.artifactStore = options.artifactStore || null;
     this.headless = false;
   }
@@ -29,13 +30,16 @@ class ExtensionBrowserProvider {
 
   async #dispatch(command, payload = {}, options = {}) {
     this.#assertReady();
-    const result = await this.registry.dispatch(this.userId, command, payload, options);
+    const result = await this.registry.dispatch(this.userId, command, payload, {
+      ...options,
+      tokenId: options.tokenId || this.tokenId,
+    });
     return this.#materialize(result);
   }
 
   #disconnect() {
     if (!this.registry || this.userId == null) return;
-    const connection = this.registry.getConnection(this.userId);
+    const connection = this.registry.getConnection(this.userId, this.tokenId);
     if (connection) {
       connection.close('browser extension provider closed');
     }
@@ -131,7 +135,7 @@ class ExtensionBrowserProvider {
   }
 
   async closeBrowser() {
-    if (!this.registry || this.userId == null || !this.registry.isConnected(this.userId)) {
+    if (!this.registry || this.userId == null || !this.registry.isConnected(this.userId, this.tokenId)) {
       return { success: true, extensionConnected: false };
     }
     const result = await this.#dispatch(EXTENSION_COMMANDS.CLOSE, {});
@@ -152,14 +156,16 @@ class ExtensionBrowserProvider {
   }
 
   async getPageInfo() {
-    if (!this.registry || this.userId == null || !this.registry.isConnected(this.userId)) {
+    if (!this.registry || this.userId == null || !this.registry.isConnected(this.userId, this.tokenId)) {
       return { url: null, title: null, extensionConnected: false };
     }
-    return this.registry.dispatch(this.userId, EXTENSION_COMMANDS.GET_PAGE_INFO, {});
+    return this.registry.dispatch(this.userId, EXTENSION_COMMANDS.GET_PAGE_INFO, {}, {
+      tokenId: this.tokenId,
+    });
   }
 
   isLaunched() {
-    return Boolean(this.registry && this.userId != null && this.registry.isConnected(this.userId));
+    return Boolean(this.registry && this.userId != null && this.registry.isConnected(this.userId, this.tokenId));
   }
 
   getPageCount() {