neoagent 2.4.1-beta.35 → 2.4.1-beta.37

package/server/services/ai/providers/nvidia.js

@@ -1,5 +1,5 @@
 const OpenAI = require('openai');
-const { BaseProvider } = require('./base');
+const { OpenAICompatibleProvider } = require('./openaiCompatible');
 
 const NVIDIA_BASE_URL = 'https://integrate.api.nvidia.com/v1';
 
@@ -21,7 +21,7 @@ const REASONING_MODELS = new Set([
   'qwen/qwq-32b',
 ]);
 
-class NvidiaProvider extends BaseProvider {
+class NvidiaProvider extends OpenAICompatibleProvider {
   constructor(config = {}) {
     super(config);
     this.name = 'nvidia';
@@ -68,7 +68,7 @@ class NvidiaProvider extends BaseProvider {
     } catch (err) {
       throw new Error(`NVIDIA NIM request failed: ${err?.message || String(err)}`);
     }
-    return this._normalizeResponse(response);
+    return this.normalizeResponse(response);
   }
 
   async *stream(messages, tools = [], options = {}) {
@@ -92,7 +92,7 @@ class NvidiaProvider extends BaseProvider {
 
     for await (const chunk of stream) {
       if (chunk.usage && (!chunk.choices || chunk.choices.length === 0)) {
-        finalUsage = this._normalizeUsage(chunk.usage);
+        finalUsage = this.normalizeUsage(chunk.usage);
         continue;
       }
 
@@ -121,11 +121,11 @@ class NvidiaProvider extends BaseProvider {
 
       const finishReason = chunk.choices[0]?.finish_reason;
       if (finishReason === 'tool_calls' || (finishReason === 'stop' && toolCalls.length > 0)) {
-        yield { type: 'tool_calls', toolCalls, content, usage: this._normalizeUsage(chunk.usage) || finalUsage };
+        yield { type: 'tool_calls', toolCalls, content, usage: this.normalizeUsage(chunk.usage) || finalUsage };
         return;
       }
       if (finishReason === 'stop') {
-        yield { type: 'done', content, usage: this._normalizeUsage(chunk.usage) || finalUsage };
+        yield { type: 'done', content, usage: this.normalizeUsage(chunk.usage) || finalUsage };
         return;
       }
     }
@@ -137,29 +137,6 @@ class NvidiaProvider extends BaseProvider {
     }
   }
 
-  _normalizeResponse(response) {
-    const choice = response.choices[0];
-    const msg = choice.message;
-    return {
-      content: msg.content || '',
-      toolCalls: msg.tool_calls?.map((tc) => ({
-        id: tc.id,
-        type: 'function',
-        function: { name: tc.function.name, arguments: tc.function.arguments },
-      })) || [],
-      finishReason: choice.finish_reason,
-      usage: this._normalizeUsage(response.usage),
-    };
-  }
-
-  _normalizeUsage(usage) {
-    if (!usage) return null;
-    return {
-      promptTokens: usage.prompt_tokens ?? 0,
-      completionTokens: usage.completion_tokens ?? 0,
-      totalTokens: usage.total_tokens ?? 0,
-    };
-  }
 }
 
 module.exports = { NvidiaProvider };

package/server/services/ai/providers/ollama.js

@@ -81,33 +81,65 @@ class OllamaProvider extends BaseProvider {
     }));
   }
 
-  async chat(messages, tools = [], options = {}) {
-    const model = options.model || this.config.model || 'llama3.1';
-    await this.ensureModel(model);
+  buildChatBody(messages, tools, options, stream) {
     const body = {
-      model,
+      model: options.model || this.config.model || 'llama3.1',
       messages: messages.map(m => ({
         role: m.role,
         content: m.content || '',
         ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
         ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {})
       })),
-      stream: false,
+      stream,
       options: {
         temperature: options.temperature ?? 0.7,
         num_predict: options.maxTokens || 16384
       }
     };
-
     if (tools.length > 0) {
       body.tools = this.formatToolsForOllama(tools);
     }
+    return body;
+  }
 
+  // Ollama returns HTTP 200 with an error body for some failures and a non-2xx
+  // status for others; surface both as real errors instead of letting callers
+  // see a silently empty response. Tags models that reject tools so the caller
+  // can transparently retry without them.
+  async postChat(body) {
     const res = await fetch(`${this.baseUrl}/api/chat`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(body)
     });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => '');
+      let message = detail;
+      try { message = JSON.parse(detail)?.error || detail; } catch {}
+      const err = new Error(`Ollama /api/chat failed (HTTP ${res.status}): ${message || res.statusText}`);
+      if (/does not support tools|tools.*not supported/i.test(message)) {
+        err.code = 'OLLAMA_TOOLS_UNSUPPORTED';
+      }
+      throw err;
+    }
+    return res;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || 'llama3.1';
+    await this.ensureModel(model);
+
+    let res;
+    try {
+      res = await this.postChat(this.buildChatBody(messages, tools, { ...options, model }, false));
+    } catch (err) {
+      if (err.code === 'OLLAMA_TOOLS_UNSUPPORTED' && tools.length > 0) {
+        console.warn(`[Ollama] Model '${model}' does not support tools; retrying without them.`);
+        res = await this.postChat(this.buildChatBody(messages, [], { ...options, model }, false));
+      } else {
+        throw err;
+      }
+    }
 
     const data = await res.json();
     const msg = data.message || {};
@@ -135,31 +167,19 @@ class OllamaProvider extends BaseProvider {
   async *stream(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || 'llama3.1';
     await this.ensureModel(model);
-    const body = {
-      model,
-      messages: messages.map(m => ({
-        role: m.role,
-        content: m.content || '',
-        ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
-        ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {})
-      })),
-      stream: true,
-      options: {
-        temperature: options.temperature ?? 0.7,
-        num_predict: options.maxTokens || 16384
-      }
-    };
 
-    if (tools.length > 0) {
-      body.tools = this.formatToolsForOllama(tools);
+    let res;
+    try {
+      res = await this.postChat(this.buildChatBody(messages, tools, { ...options, model }, true));
+    } catch (err) {
+      if (err.code === 'OLLAMA_TOOLS_UNSUPPORTED' && tools.length > 0) {
+        console.warn(`[Ollama] Model '${model}' does not support tools; retrying stream without them.`);
+        res = await this.postChat(this.buildChatBody(messages, [], { ...options, model }, true));
+      } else {
+        throw err;
+      }
     }
 
-    const res = await fetch(`${this.baseUrl}/api/chat`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body)
-    });
-
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let content = '';

package/server/services/ai/providers/openai.js

@@ -1,7 +1,7 @@
 const OpenAI = require('openai');
-const { BaseProvider } = require('./base');
+const { OpenAICompatibleProvider } = require('./openaiCompatible');
 
-class OpenAIProvider extends BaseProvider {
+class OpenAIProvider extends OpenAICompatibleProvider {
   constructor(config = {}) {
     super(config);
     this.name = 'openai';
@@ -173,31 +173,6 @@ class OpenAIProvider extends BaseProvider {
     }
   }
 
-  async analyzeImage(options = {}) {
-    const model = options.model || this.getDefaultVisionModel();
-    const b64 = BaseProvider.readImageAsBase64(options.imagePath);
-    const response = await this.client.chat.completions.create({
-      model,
-      max_tokens: options.maxTokens || 4096,
-      messages: [{
-        role: 'user',
-        content: [
-          { type: 'text', text: options.question || 'Describe this image in detail.' },
-          {
-            type: 'image_url',
-            image_url: {
-              url: `data:${options.mimeType || 'image/jpeg'};base64,${b64}`
-            }
-          }
-        ]
-      }]
-    });
-
-    return {
-      content: response.choices[0]?.message?.content || '',
-      model: response.model || model,
-    };
-  }
 }
 
 module.exports = { OpenAIProvider };

package/server/services/ai/providers/openaiCompatible.js

@@ -0,0 +1,70 @@
+const { BaseProvider } = require('./base');
+
+// Shared base for providers that speak the OpenAI Chat Completions wire format
+// (OpenAI, Grok, NVIDIA NIM, GitHub Copilot, ...). It owns the response/usage
+// normalization and vision request that were previously copy-pasted into each
+// provider. Per-provider concerns — client construction, model lists, context
+// windows, reasoning detection, and the streaming loop — stay in the subclasses,
+// since those genuinely differ between vendors.
+class OpenAICompatibleProvider extends BaseProvider {
+  normalizeUsage(usage) {
+    if (!usage) return null;
+    return {
+      promptTokens: usage.prompt_tokens ?? usage.promptTokens ?? 0,
+      completionTokens: usage.completion_tokens ?? usage.completionTokens ?? 0,
+      totalTokens: usage.total_tokens ?? usage.totalTokens ?? 0,
+    };
+  }
+
+  normalizeResponse(response) {
+    const choice = response?.choices?.[0];
+    if (!choice) {
+      throw new Error(`Provider '${this.name}' returned no choices in the response`);
+    }
+    const msg = choice.message || {};
+    return {
+      content: msg.content || '',
+      toolCalls: (msg.tool_calls || [])
+        .filter((tc) => tc?.function)
+        .map((tc) => ({
+          id: tc.id,
+          type: 'function',
+          function: { name: tc.function.name, arguments: tc.function.arguments },
+        })),
+      finishReason: choice.finish_reason,
+      usage: this.normalizeUsage(response.usage),
+    };
+  }
+
+  async analyzeImage(options = {}) {
+    if (!this.supportsVision()) {
+      throw new Error(`Provider '${this.name}' does not support image analysis`);
+    }
+
+    const model = options.model || this.getDefaultVisionModel();
+    const b64 = BaseProvider.readImageAsBase64(options.imagePath);
+    const response = await this.client.chat.completions.create({
+      model,
+      max_tokens: options.maxTokens || 4096,
+      messages: [{
+        role: 'user',
+        content: [
+          { type: 'text', text: options.question || 'Describe this image in detail.' },
+          {
+            type: 'image_url',
+            image_url: {
+              url: `data:${options.mimeType || 'image/jpeg'};base64,${b64}`,
+            },
+          },
+        ],
+      }],
+    });
+
+    return {
+      content: response.choices[0]?.message?.content || '',
+      model: response.model || model,
+    };
+  }
+}
+
+module.exports = { OpenAICompatibleProvider };

package/server/services/ai/taskAnalysis.js

@@ -561,10 +561,13 @@ function buildExecutionGuidance({ analysis, plan = null, capabilityHealth }) {
   return lines.filter(Boolean).join('\n\n');
 }
 
-function buildVerifierPrompt({ analysis, toolExecutionSummary, evidenceSources, finalReply }) {
+function buildVerifierPrompt({ analysis, tools = [], toolExecutionSummary, evidenceSources, finalReply }) {
+  const toolNames = summarizeTools(tools).join(', ');
   return composeJsonPrompt([
     JSON_ONLY_RESPONSE_RULE,
     ...VERIFIER_PROMPT_INSTRUCTIONS,
+    formatAvailableToolsLine(toolNames),
+    'Do not claim a tool or capability was unavailable if it is listed as available in this run. A missing tool execution is missing evidence, not proof of missing tool exposure.',
     `Freshness risk: ${analysis.freshness_risk}`,
     `Verification need: ${analysis.verification_need}`,
     `Completion confidence required: ${analysis.completion_confidence_required || 'medium'}`,

package/server/services/ai/toolEvidence.js

@@ -0,0 +1,207 @@
+'use strict';
+
+// Classifies tool executions into run evidence (what changed, what failed, what
+// is relevant to the user's answer) and builds the deterministic recovery
+// context the engine feeds back to the model after a failure. Kept free of
+// engine state so the classification rules are pure and unit testable.
+
+const { compactToolResult } = require('./toolResult');
+const { summarizeForLog } = require('./logFormat');
+const { normalizeOutgoingMessage, clampRunContext } = require('./messagingFallback');
+
+// Ordered classification rules mapping a tool name to its evidence "source"
+// bucket. First matching rule wins, so order is significant. Declared as data
+// rather than a nested ternary so new tool families can be slotted in by adding
+// a row instead of editing control flow.
+const EVIDENCE_SOURCE_RULES = [
+  { source: 'browser', match: (name) => name.startsWith('browser_') },
+  { source: 'android', match: (name) => name.startsWith('android_') },
+  { source: 'mcp', match: (name) => name.startsWith('mcp_') },
+  { source: 'memory', match: (name) => name.startsWith('memory_') || name === 'session_search' },
+  { source: 'search', match: (name) => name === 'web_search' },
+  { source: 'http', match: (name) => name === 'http_request' },
+  { source: 'files', match: (name) => ['read_file', 'search_files', 'list_directory', 'write_file', 'edit_file'].includes(name) },
+  { source: 'command', match: (name) => name === 'execute_command' },
+  { source: 'skills', match: (name) => name.includes('skill') },
+  { source: 'tasks', match: (name) => name === 'create_task' || name === 'update_task' || name === 'delete_task' || name === 'list_tasks' || name.includes('widget') },
+  { source: 'messaging', match: (name) => name === 'send_message' || name === 'make_call' },
+  { source: 'data', match: (name) => name.startsWith('recordings_') || name === 'read_health_data' },
+  { source: 'vision', match: (name) => name === 'analyze_image' },
+  { source: 'subagent', match: (name) => name.includes('subagent') },
+];
+
+function deriveEvidenceSource(name) {
+  const rule = EVIDENCE_SOURCE_RULES.find((entry) => entry.match(name));
+  return rule ? rule.source : 'tool';
+}
+
+function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '') {
+  const name = String(toolName || '');
+  const evidenceRelevantPrefixes = ['browser_', 'android_'];
+  const evidenceRelevantExact = new Set([
+    'web_search',
+    'http_request',
+    'read_file',
+    'search_files',
+    'list_directory',
+    'session_search',
+    'memory_recall',
+    'analyze_image',
+    'read_health_data',
+    'recordings_list',
+    'recordings_get',
+    'recordings_search',
+    'list_tasks',
+    'wait_subagent',
+  ]);
+  const stateChangingExact = new Set([
+    'execute_command',
+    'write_file',
+    'edit_file',
+    'send_interim_update',
+    'send_message',
+    'make_call',
+    'create_skill',
+    'update_skill',
+    'delete_skill',
+    'create_task',
+    'update_task',
+    'delete_task',
+    'create_ai_widget',
+    'update_ai_widget',
+    'delete_ai_widget',
+    'save_widget_snapshot',
+    'mcp_add_server',
+    'mcp_remove_server',
+    'spawn_subagent',
+    'cancel_subagent',
+  ]);
+
+  const evidenceSource = deriveEvidenceSource(name);
+
+  const evidenceRelevant = evidenceRelevantExact.has(name)
+    || evidenceRelevantPrefixes.some((prefix) => name.startsWith(prefix));
+  const stateChanged = stateChangingExact.has(name)
+    || name.startsWith('android_')
+    || ['browser_click', 'browser_type', 'browser_evaluate'].includes(name);
+
+  let normalizedError = String(errorMessage || result?.error || '').trim();
+  if (!normalizedError && name === 'execute_command' && result && typeof result === 'object') {
+    if (result.timedOut) {
+      normalizedError = `Command timed out after ${result.durationMs || 'unknown'} ms`;
+    } else if (result.killed || result.signal) {
+      normalizedError = 'Command was killed before it finished';
+    } else if (typeof result.exitCode === 'number' && result.exitCode !== 0) {
+      normalizedError = summarizeForLog(result.stderr || result.stdout || `Command exited with code ${result.exitCode}`, 220);
+    }
+  }
+
+  if (!normalizedError && result && typeof result === 'object') {
+    const nestedResult = result.result && typeof result.result === 'object' && !Array.isArray(result.result)
+      ? result.result
+      : null;
+    const detail = normalizeOutgoingMessage(
+      result.reason
+      || result.message
+      || nestedResult?.reason
+      || nestedResult?.message
+      || ''
+    );
+
+    if (result.skipped === true || nestedResult?.skipped === true) {
+      normalizedError = detail || 'Tool reported skipped outcome.';
+    } else if (result.success === false || nestedResult?.success === false) {
+      normalizedError = detail || 'Tool reported success=false.';
+    } else if (result.sent === false || nestedResult?.sent === false) {
+      normalizedError = detail || 'Tool reported sent=false.';
+    }
+  }
+
+  return {
+    toolName: name,
+    ok: !normalizedError,
+    error: normalizedError,
+    evidenceSource,
+    evidenceRelevant,
+    stateChanged,
+    dependsOnOutput: true,
+    summary: compactToolResult(name, toolArgs, result || { error: errorMessage || 'Tool failed' }, {
+      softLimit: 500,
+      hardLimit: 900,
+    }),
+  };
+}
+
+function summarizeToolExecutions(toolExecutions = [], maxItems = 10) {
+  return toolExecutions.slice(-maxItems).map((item, index) => {
+    const status = item.ok ? 'ok' : `error=${item.error}`;
+    return `${index + 1}. ${item.toolName} [${item.evidenceSource}] ${status} :: ${clampRunContext(item.summary || '', 220)}`;
+  }).join('\n');
+}
+
+function summarizeAvailableTools(tools = [], { exclude = [] } = {}) {
+  const excluded = new Set((Array.isArray(exclude) ? exclude : [exclude]).filter(Boolean));
+  return tools
+    .map((tool) => String(tool?.name || '').trim())
+    .filter((name) => name && !excluded.has(name))
+    .slice(0, 24)
+    .join(', ');
+}
+
+function inferToolFailureMessage(toolName, result) {
+  const explicitError = normalizeOutgoingMessage(result?.error || '');
+  if (explicitError) return explicitError;
+
+  if (!result || typeof result !== 'object') return '';
+
+  if (toolName === 'execute_command') {
+    if (result.timedOut) {
+      return `Command timed out after ${result.durationMs || 'unknown'} ms`;
+    }
+    if (result.killed || result.signal) {
+      return 'Command was killed before it finished';
+    }
+    if (typeof result.exitCode === 'number' && result.exitCode !== 0) {
+      return summarizeForLog(result.stderr || result.stdout || `Command exited with code ${result.exitCode}`, 220);
+    }
+  }
+
+  if (toolName === 'http_request' && typeof result.status === 'number' && result.status >= 400) {
+    const bodySnippet = normalizeOutgoingMessage(result.body || '');
+    return summarizeForLog(
+      bodySnippet
+        ? `HTTP request returned status ${result.status}: ${bodySnippet}`
+        : `HTTP request returned status ${result.status}`,
+      240
+    );
+  }
+
+  return '';
+}
+
+function buildAutonomousRecoveryContext({ err, toolExecutions = [], tools = [], userMessage, visibleMessageSent = false }) {
+  const lastFailure = [...toolExecutions].reverse().find((item) => !item.ok);
+  const alternativeTools = summarizeAvailableTools(tools, { exclude: lastFailure?.toolName || null });
+  const parts = [
+    'This is an internal recovery retry for the same user task. Continue the task instead of stopping.',
+    userMessage ? `Original task: ${clampRunContext(userMessage, 260)}` : '',
+    lastFailure?.toolName ? `Previous attempt failed on tool: ${lastFailure.toolName}.` : '',
+    lastFailure?.error ? `Concrete failure: ${summarizeForLog(lastFailure.error, 260)}.` : '',
+    err?.message ? `Run-level error after that failure: ${summarizeForLog(err.message, 220)}.` : '',
+    'Do not send a blocker message just because one tool path failed.',
+    'Use a different safe approach if available: alternate tool, different query, browser path, HTTP fetch, file/code inspection, or command verification.',
+    visibleMessageSent ? 'A user-facing message was already sent in a previous internal attempt. Continue silently unless you have a materially new finished result or a real external blocker.' : '',
+    alternativeTools ? `Other available tools in this run: ${alternativeTools}.` : '',
+    'Only stop if the remaining problem truly requires an external dependency or user action outside this run.'
+  ];
+  return parts.filter(Boolean).join(' ');
+}
+
+module.exports = {
+  classifyToolExecution,
+  deriveEvidenceSource,
+  summarizeToolExecutions,
+  summarizeAvailableTools,
+  inferToolFailureMessage,
+  buildAutonomousRecoveryContext,
+};

package/server/services/ai/toolSelector.js

@@ -14,9 +14,16 @@
 
 const MCP_ALWAYS_INCLUDE_THRESHOLD = 20;
 const MAX_TOOLS = 128; // Strict provider limit (e.g. Github Copilot / OpenAI)
+const ALWAYS_INCLUDE_BUILT_INS = [
+  'send_message',
+  'create_task',
+  'list_tasks',
+  'delete_task',
+  'update_task',
+];
 
 function ensureRequiredTools(selectedTools = [], builtInTools = [], options = {}) {
-  const requiredNames = [];
+  const requiredNames = [...ALWAYS_INCLUDE_BUILT_INS];
   if (options.widgetId) requiredNames.push('save_widget_snapshot');
   if (!requiredNames.length) return selectedTools;
 

package/server/services/memory/manager.js

@@ -21,6 +21,7 @@ const {
 } = require('./intelligence');
 const { AGENT_DATA_DIR } = require('../../../runtime/paths');
 const { isMainAgent, resolveAgentId } = require('../agents/manager');
+const { buildFtsQuery } = require('../../db/ftsQuery');
 const {
   decryptLocalValue,
   encryptLocalValue,
@@ -187,13 +188,6 @@ function parseStringSetting(value) {
   }
 }
 
-function buildFtsQuery(query) {
-  const tokens = String(query || '')
-    .match(/[\p{L}\p{N}_-]{2,}/gu) || [];
-  if (!tokens.length) return null;
-  return tokens.map((token) => `${token.replace(/"/g, '')}*`).join(' AND ');
-}
-
 function stripHighlight(text) {
   return String(text || '').replace(/<\/?mark>/g, '');
 }

package/server/services/websocket.js

@@ -317,7 +317,7 @@ function setupWebSocket(io, services) {
         const data = asObject(raw);
         const runId = toOptionalString(data?.runId, 128);
         console.warn(`[WS] agent:abort received from user ${userId} for run ${runId || 'unknown'}`);
-        agentEngine.abort(runId || null);
+        agentEngine.abort(runId || null, { userId });
         socket.emit('agent:aborted', { runId: runId || null });
       } catch (err) {
         console.error(`[WS] agent:abort failed for user ${userId}:`, err);
@@ -366,8 +366,14 @@ function setupWebSocket(io, services) {
         }
         console.log(`[WS] agent:run_detail requested by user ${userId} run=${runId}`);
         const run = db.prepare('SELECT * FROM agent_runs WHERE id = ? AND user_id = ?').get(runId, userId);
+        if (!run) {
+          // Don't leak steps/history/events for a run the user doesn't own:
+          // agent_steps and run events are keyed only by run_id, so the run
+          // ownership check is the sole authorization gate.
+          return socket.emit('agent:run_detail', { run: null, steps: [], history: [], events: [] });
+        }
         const steps = db.prepare('SELECT * FROM agent_steps WHERE run_id = ? ORDER BY step_index ASC').all(runId);
-        const history = db.prepare('SELECT * FROM conversation_history WHERE agent_run_id = ? ORDER BY created_at ASC').all(runId);
+        const history = db.prepare('SELECT * FROM conversation_history WHERE agent_run_id = ? AND user_id = ? ORDER BY created_at ASC').all(runId, userId);
         const events = listRunEvents(runId);
         socket.emit('agent:run_detail', { run, steps, history, events });
       } catch (err) {