neoagent 3.2.1-beta.7 → 3.2.1-beta.9

package/server/services/ai/model_failure_cache.js

@@ -1,6 +1,15 @@
 'use strict';
 
+const { isAbortError } = require('../../utils/abort');
+const {
+  getErrorCode,
+  getHttpStatus,
+  isTransientIoError,
+  retryAfterMilliseconds,
+} = require('../../utils/retry');
+
 const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+const DEFAULT_RECOVERY_COOLDOWN_MS = 60 * 1000;
 const failures = new Map();
 
 function cacheKey(userId, agentId, modelSelectionId) {
@@ -11,28 +20,57 @@ function cacheKey(userId, agentId, modelSelectionId) {
   ].join(':');
 }
 
-function readCooldownMs() {
+function readPermanentCooldownMs() {
   const configured = Number(process.env.NEOAGENT_MODEL_NOT_FOUND_COOLDOWN_MS);
   if (!Number.isFinite(configured)) return DEFAULT_COOLDOWN_MS;
   return Math.max(1_000, Math.min(configured, 24 * 60 * 60 * 1000));
 }
 
+function readRecoveryCooldownMs() {
+  const configured = Number(process.env.NEOAGENT_MODEL_RECOVERY_COOLDOWN_MS);
+  if (!Number.isFinite(configured)) return DEFAULT_RECOVERY_COOLDOWN_MS;
+  return Math.max(1_000, Math.min(configured, 15 * 60 * 1000));
+}
+
 function isPermanentModelFailure(error) {
-  const status = Number(
-    error?.status
-    ?? error?.statusCode
-    ?? error?.response?.status,
-  );
+  const status = getHttpStatus(error);
   if (status === 404) return true;
   return /\b404\b.*\b(model|nim|provider|request)\b|\b(model|nim)\b.*\b404\b/i
     .test(String(error?.message || ''));
 }
 
+function isRecoverableModelFailure(error) {
+  if (!error || isAbortError(error) || isPermanentModelFailure(error)) return false;
+  const status = getHttpStatus(error);
+  if (status === 401 || status === 403 || status === 429 || (status >= 500 && status < 600)) {
+    return true;
+  }
+  const code = String(getErrorCode(error) || '');
+  if (code === 'MODEL_EMPTY_RESPONSE' || code === 'MODEL_CALL_TIMEOUT') return true;
+  if (isTransientIoError(error)) return true;
+  return /\bempty response|temporarily unavailable|overloaded|rate.?limit|timed? ?out|network error\b/i
+    .test(String(error?.message || ''));
+}
+
+function resolveCooldownMs(error, now) {
+  if (isPermanentModelFailure(error)) return readPermanentCooldownMs();
+  if (!isRecoverableModelFailure(error)) return 0;
+
+  const configured = readRecoveryCooldownMs();
+  const retryAfter = retryAfterMilliseconds(
+    error?.headers || error?.response?.headers,
+    now,
+  );
+  if (!Number.isFinite(retryAfter)) return configured;
+  return Math.max(configured, Math.min(retryAfter, 15 * 60 * 1000));
+}
+
 function recordModelFailure(userId, agentId, modelSelectionId, error, now = Date.now()) {
   const modelId = String(modelSelectionId || '').trim();
-  if (!modelId || !isPermanentModelFailure(error)) return false;
+  const cooldownMs = resolveCooldownMs(error, now);
+  if (!modelId || cooldownMs <= 0) return false;
   failures.set(cacheKey(userId, agentId, modelId), {
-    expiresAt: now + readCooldownMs(),
+    expiresAt: now + cooldownMs,
   });
   return true;
 }
@@ -64,6 +102,7 @@ module.exports = {
   clearModelFailureCache,
   isModelCoolingDown,
   isPermanentModelFailure,
+  isRecoverableModelFailure,
   recordModelFailure,
   recordModelSuccess,
 };

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

@@ -1,7 +1,63 @@
-const { GoogleGenerativeAI } = require('@google/generative-ai');
+'use strict';
+
+const { GoogleGenAI } = require('@google/genai');
 const { BaseProvider } = require('./base');
 const { fetchResponseText } = require('../../network/http');
 
+function parseToolArguments(value) {
+  try {
+    const parsed = JSON.parse(value || '{}');
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeUsage(usage) {
+  if (!usage) return null;
+  return {
+    inputTokens: usage.promptTokenCount || 0,
+    outputTokens: usage.candidatesTokenCount || 0,
+    reasoningTokens: usage.thoughtsTokenCount || 0,
+    cachedReadTokens: usage.cachedContentTokenCount || 0,
+    cacheWriteTokens: 0,
+    promptTokens: usage.promptTokenCount || 0,
+    completionTokens: usage.candidatesTokenCount || 0,
+    totalTokens: usage.totalTokenCount || 0
+  };
+}
+
+function collectResponseParts(response, toolCalls, seenToolCalls = null) {
+  let content = '';
+  for (const candidate of response?.candidates || []) {
+    for (const part of candidate.content?.parts || []) {
+      if (part.text && part.thought !== true) content += part.text;
+      if (!part.functionCall?.name) continue;
+
+      const args = part.functionCall.args || {};
+      const providerCallId = String(part.functionCall.id || '').trim();
+      const signature = providerCallId
+        || `${part.functionCall.name}:${JSON.stringify(args)}`;
+      if (seenToolCalls?.has(signature)) continue;
+      seenToolCalls?.add(signature);
+
+      toolCalls.push({
+        id: providerCallId
+          || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+        type: 'function',
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(args),
+          thought_signature: part.thoughtSignature
+        }
+      });
+    }
+  }
+  return content;
+}
+
 class GoogleProvider extends BaseProvider {
   constructor(config = {}) {
     super(config);
@@ -29,7 +85,7 @@ class GoogleProvider extends BaseProvider {
       'gemini-1.5-flash': 1048576,
     };
     this.apiKey = config.apiKey || process.env.GOOGLE_AI_KEY;
-    this.genAI = new GoogleGenerativeAI(this.apiKey);
+    this.genAI = new GoogleGenAI({ apiKey: this.apiKey });
   }
 
   async listModels(signal = null) {
@@ -78,11 +134,23 @@ class GoogleProvider extends BaseProvider {
       functionDeclarations: tools.map(tool => ({
         name: tool.name,
         description: tool.description,
-        parameters: tool.parameters || { type: 'object', properties: {} }
+        parametersJsonSchema: tool.parameters || { type: 'object', properties: {} }
       }))
     }];
   }
 
+  buildGenerateConfig(systemInstruction, tools, options) {
+    const config = {};
+    if (systemInstruction) config.systemInstruction = systemInstruction;
+    if (tools.length > 0) config.tools = this.formatTools(tools);
+    if (options.signal) config.abortSignal = options.signal;
+    const maxOutputTokens = Number(options.maxTokens);
+    if (Number.isFinite(maxOutputTokens) && maxOutputTokens > 0) {
+      config.maxOutputTokens = Math.floor(maxOutputTokens);
+    }
+    return config;
+  }
+
   convertMessages(messages) {
     let systemInstruction = '';
     const history = [];
@@ -93,16 +161,16 @@ class GoogleProvider extends BaseProvider {
         continue;
       }
       if (msg.role === 'tool') {
+        const functionResponse = {
+          name: msg.name || 'tool',
+          response: { result: msg.content }
+        };
+        if (msg.tool_call_id) functionResponse.id = msg.tool_call_id;
         history.push({
-          // Gemini chat history only accepts user/model roles. Tool results are
-          // represented as functionResponse parts on a user turn.
+          // The current Gemini API represents tool results as functionResponse
+          // parts on a user turn.
           role: 'user',
-          parts: [{
-            functionResponse: {
-              name: msg.name || 'tool',
-              response: { result: msg.content }
-            }
-          }]
+          parts: [{ functionResponse }]
         });
         continue;
       }
@@ -113,9 +181,10 @@ class GoogleProvider extends BaseProvider {
           const functionCallPart = {
             functionCall: {
               name: tc.function.name,
-              args: JSON.parse(tc.function.arguments || '{}')
+              args: parseToolArguments(tc.function.arguments)
             }
           };
+          if (tc.id) functionCallPart.functionCall.id = tc.id;
           if (tc.function.thought_signature) {
             functionCallPart.thoughtSignature = tc.function.thought_signature;
           }
@@ -149,8 +218,8 @@ class GoogleProvider extends BaseProvider {
       normalizedHistory.push({ role: currentRole, parts: currentParts });
     }
 
-    // Structured helpers can consist entirely of system instructions. Gemini's
-    // chat API still requires a user turn to trigger generation.
+    // Structured helpers can consist entirely of system instructions. Gemini
+    // still requires a user turn to trigger generation.
     if (
       normalizedHistory.length === 0
       || normalizedHistory[normalizedHistory.length - 1].role === 'model'
@@ -174,53 +243,18 @@ class GoogleProvider extends BaseProvider {
   async chat(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || this.getDefaultModel();
     const { systemInstruction, history } = this.convertMessages(messages);
-
-    const genModel = this.genAI.getGenerativeModel({
+    const response = await this.genAI.models.generateContent({
       model,
-      systemInstruction: systemInstruction || undefined,
-      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+      contents: history,
+      config: this.buildGenerateConfig(systemInstruction, tools, options)
     });
-
-    const lastMessage = history.pop();
-    const chat = genModel.startChat({ history });
-    const result = await chat.sendMessage(lastMessage.parts, { signal: options.signal });
-    const response = result.response;
-
-    let content = '';
     const toolCalls = [];
-
-    for (const candidate of response.candidates || []) {
-      for (const part of candidate.content?.parts || []) {
-        if (part.text) content += part.text;
-        if (part.functionCall) {
-          toolCalls.push({
-            id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-            type: 'function',
-            function: {
-              name: part.functionCall.name,
-              arguments: JSON.stringify(part.functionCall.args || {}),
-              thought_signature: part.thoughtSignature
-            }
-          });
-        }
-      }
-    }
-
-    const usage = response.usageMetadata;
+    const content = collectResponseParts(response, toolCalls);
     return {
       content,
       toolCalls,
       finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
-      usage: usage ? {
-        inputTokens: usage.promptTokenCount || 0,
-        outputTokens: usage.candidatesTokenCount || 0,
-        reasoningTokens: usage.thoughtsTokenCount || 0,
-        cachedReadTokens: usage.cachedContentTokenCount || 0,
-        cacheWriteTokens: 0,
-        promptTokens: usage.promptTokenCount || 0,
-        completionTokens: usage.candidatesTokenCount || 0,
-        totalTokens: usage.totalTokenCount || 0
-      } : null,
+      usage: normalizeUsage(response.usageMetadata),
       model
     };
   }
@@ -228,60 +262,32 @@ class GoogleProvider extends BaseProvider {
   async *stream(messages, tools = [], options = {}) {
     const model = options.model || this.config.model || this.getDefaultModel();
     const { systemInstruction, history } = this.convertMessages(messages);
-
-    const genModel = this.genAI.getGenerativeModel({
+    const responseStream = await this.genAI.models.generateContentStream({
       model,
-      systemInstruction: systemInstruction || undefined,
-      tools: tools.length > 0 ? this.formatTools(tools) : undefined
+      contents: history,
+      config: this.buildGenerateConfig(systemInstruction, tools, options)
     });
-
-    const lastMessage = history.pop();
-    const chat = genModel.startChat({ history });
-    const result = await chat.sendMessageStream(lastMessage.parts, { signal: options.signal });
-
     let content = '';
     const toolCalls = [];
+    const seenToolCalls = new Set();
+    let usage = null;
 
-    for await (const chunk of result.stream) {
-      for (const candidate of chunk.candidates || []) {
-        for (const part of candidate.content?.parts || []) {
-          if (part.text) {
-            content += part.text;
-            yield { type: 'content', content: part.text };
-          }
-          if (part.functionCall) {
-            toolCalls.push({
-              id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-              type: 'function',
-              function: {
-                name: part.functionCall.name,
-                arguments: JSON.stringify(part.functionCall.args || {}),
-                thought_signature: part.thoughtSignature
-              }
-            });
-          }
-        }
+    for await (const chunk of responseStream) {
+      const chunkContent = collectResponseParts(chunk, toolCalls, seenToolCalls);
+      if (chunkContent) {
+        content += chunkContent;
+        yield { type: 'content', content: chunkContent };
       }
+      if (chunk.usageMetadata) usage = chunk.usageMetadata;
     }
 
-    const finalResponse = await result.response;
-    const usage = finalResponse.usageMetadata;
-
     yield {
       type: 'done',
       content,
       toolCalls,
       finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
-      usage: usage ? {
-        inputTokens: usage.promptTokenCount || 0,
-        outputTokens: usage.candidatesTokenCount || 0,
-        reasoningTokens: usage.thoughtsTokenCount || 0,
-        cachedReadTokens: usage.cachedContentTokenCount || 0,
-        cacheWriteTokens: 0,
-        promptTokens: usage.promptTokenCount || 0,
-        completionTokens: usage.candidatesTokenCount || 0,
-        totalTokens: usage.totalTokenCount || 0
-      } : null
+      usage: normalizeUsage(usage),
+      model
     };
   }
 }

package/server/services/ai/taskAnalysis.js

@@ -24,6 +24,7 @@ const ANALYSIS_SCHEMA_EXAMPLE = {
   draft_reply: '',
   goal: 'Answer the user accurately.',
   success_criteria: ['Final reply is correct and specific.'],
+  research_targets: [],
   suggested_tools: ['web_search', 'browser_navigate'],
   complexity: 'standard',
   autonomy_level: 'normal',
@@ -59,6 +60,8 @@ const ANALYSIS_PROMPT_INSTRUCTIONS = [
   'Do not suggest create_task, update_task, delete_task, or list_tasks for ordinary immediate work. Use task tools only when the user asks for future, recurring, scheduled, monitored, background, or existing-task management behavior.',
   'Set parallel_work=true when independent tool calls or subagents can materially reduce latency.',
   'Set completion_confidence_required="high" when wrong completion would be costly, state-changing, user-visible, or hard to recover.',
+  'For research, product/device comparisons, reviews, fact-checks, or multi-entity look-into requests, use mode="execute" or mode="plan_execute", never direct_answer. Set needs_verification=true, freshness_risk="possible" or higher, and completion_confidence_required="high".',
+  'When the user asks to look into multiple devices, products, options, or entities, put each named target into research_targets and success_criteria and keep them exact. Prefer suggested_tools that can open primary sources (web_search plus browser_navigate/http_request) rather than answering from memory.',
 ];
 const PLAN_PROMPT_INSTRUCTIONS = [
   'Create a concise execution plan for the current task.',
@@ -83,9 +86,12 @@ const VERIFIER_PROMPT_INSTRUCTIONS = [
   'A successful create_task or update_task tool call is required before claiming a task schedule changed.',
   'If external evidence conflicts with memory, history, or another tool result, preserve the uncertainty instead of flattening it into a single confident claim.',
   'When the draft reply is already correct and fully supported by the evidence, return it unchanged. Do not rewrite for style.',
+  'For multi-entity research or comparison replies, every compared target needs supporting tool evidence. If a target was never searched or opened, mark insufficient_evidence and rewrite the reply so it does not invent that target\'s specs.',
+  'Search-result snippets alone are weak evidence for concrete product claims. Prefer opened pages, fetched docs, or other primary tool output. If only snippets exist, either keep the claim clearly provisional or mark missing_evidence.',
 ];
 const EXECUTION_GUIDANCE_ACTION_LINES = [
   'Act end-to-end. Run independent searches or inspections in parallel when possible. Prefer native integration tools and structured APIs over browser automation or shell scraping. Use exact IDs and required parameters; list or search first when you do not have them.',
+  'For research and multi-entity comparisons, cover each requested target with its own search/open path. Do not stop after one partial lead or invent the remaining devices from memory. Open primary sources before stating concrete specs.',
   'For GitHub issue implementation or PR work, fetch the issue once, then establish or reuse a writable local checkout, create a task branch, inspect/edit/test locally, and push/open the PR. Use direct GitHub file mutation tools only as a fallback when a local checkout is unavailable.',
   'Prefer the highest-level available tool for the job. If a tool accepts normal text, JSON, file paths, or line ranges, pass those directly instead of reconstructing equivalent data through shell commands.',
   'Your shell (execute_command) starts in your workspace, and the file tools (read_file, read_files, write_file, edit_file, replace_file_range, list_directory, search_files) operate on that same workspace. Keep source checkouts and generated files in the shared workspace, then prefer file tools for inspection and edits instead of shell snippets. Clone a repo once and reuse it; do not re-clone or re-list the same tree.',
@@ -317,6 +323,13 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
     'successCriteria',
     TASK_ANALYSIS_SUCCESS_CRITERIA_LIMIT,
   );
+  const researchTargets = resolveAliasedStringList(
+    raw,
+    fallback,
+    'research_targets',
+    'researchTargets',
+    TASK_ANALYSIS_SUCCESS_CRITERIA_LIMIT,
+  );
 
   const draftReply = resolveAliasedText(raw, fallback, 'draft_reply', 'draftReply', '');
   const initialMode = pickEnum(
@@ -398,6 +411,7 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
     draft_reply: draftReply,
     goal: resolveAliasedText(raw, fallback, 'goal', 'goal', ''),
     success_criteria: successCriteria,
+    research_targets: researchTargets,
     complexity: mode === 'plan_execute' ? 'complex' : normalizedComplexity,
     autonomy_level: mode === 'plan_execute' ? 'high' : normalizedAutonomyLevel,
     progress_update_policy: pickEnum(
@@ -567,6 +581,7 @@ function buildExecutionGuidance({ analysis, plan = null, capabilityHealth }) {
     `Execution mode: ${analysis.mode}.`,
     analysis.goal ? `Goal: ${analysis.goal}` : '',
     formatBulletSection('Success criteria', analysis.success_criteria),
+    formatBulletSection('Research targets', analysis.research_targets),
     analysis.suggested_tools?.length
       ? `Advisory tool suggestions: ${analysis.suggested_tools.join(', ')}`
       : '',

package/server/services/ai/terminal_reply.js

@@ -10,7 +10,13 @@ function normalizeReply(content) {
 }
 
 function hasExternalBlocker(text) {
-  return /\b(?:blocked|cannot|can't|could not|couldn't|unable to|do not have access|don't have access|missing (?:access|credentials|permission|information)|need you to|requires? your|waiting for your|please (?:provide|send|choose|confirm|authorize|approve))\b/.test(text);
+  return /\b(?:blocked|cannot|can't|could not|couldn't|unable to|do not have access|don't have access|missing (?:access|credentials|permission|information)|need you to|requires? your|waiting for your|please (?:provide|send|choose|confirm|authorize|approve)|blockiert|kann nicht|konnte nicht|mir fehlt|ich brauche von dir|warte auf dein(?:e|en)?|bitte (?:gib|schick|sende|nenn|bestätige|waehle|wähle|genehmige))\b/.test(text);
+}
+
+function isTerminalQuestionOrBlockerReply(content) {
+  const text = normalizeReply(content);
+  if (!text) return false;
+  return /[?？]/.test(text) || hasExternalBlocker(text);
 }
 
 /**
@@ -36,10 +42,16 @@ function isDeferredWorkReply(content) {
     /^(?:working on it|checking now|on it)[.!…]*$/,
     /\bi(?:'ll| will)\s+(?:get back to you|update you|report back|let you know|keep you posted)\b/,
     /\b(?:i(?:'ll| will)\s+follow up|stay tuned)\b/,
+    /^(?:(?:klar|okay|ok|alles klar)[,.!]?\s+)?ich\s+(?:(?:arbeite|pruefe|prüfe|schaue|untersuche|teste|debugge|starte)\s+(?:(?:gerade|aktuell|jetzt|noch)\b|(?:das|dies|die logs?|den code|deine anfrage|deinen auftrag)\b)|(?:kuemmere|kümmere)\s+mich\s+(?:gerade|aktuell|jetzt|noch)\b)/,
+    /^(?:(?:klar|okay|ok|alles klar)[,.!]?\s+)?ich\s+(?:werde|wuerde|würde)\s+(?:jetzt\s+)?(?:pruefen|prüfen|nachsehen|untersuchen|testen|debuggen|starten|fixen|erledigen)\b/,
+    /^(?:(?:klar|okay|ok|alles klar)[,.!]?\s+)?(?:lass|lasst)\s+mich\s+(?:(?:das|dies|die logs?|den code)\s+)?(?:pruefen|prüfen|nachsehen|untersuchen|testen|debuggen)\b/,
+    /^(?:gib mir|gebt mir)\s+(?:einen\s+)?(?:moment|augenblick)|^(?:bin dran|mache ich)[.!…]*$/,
+    /\bich\s+(?:melde mich|gebe dir bescheid|halte dich auf dem laufenden)\b/,
   ];
   return patterns.some((pattern) => pattern.test(text));
 }
 
 module.exports = {
   isDeferredWorkReply,
+  isTerminalQuestionOrBlockerReply,
 };