neoagent 3.2.1-beta.1 → 3.2.1-beta.3

package/server/services/ai/settings.js

@@ -12,7 +12,7 @@ const AI_PROVIDER_DEFINITIONS = Object.freeze({
   openai: {
     id: 'openai',
     label: 'OpenAI',
-    description: 'GPT-5 and GPT-4.1 models for fast general work and reasoning.',
+    description: 'Current GPT models for general work, coding, and reasoning.',
     envKey: 'OPENAI_API_KEY',
     supportsApiKey: true,
     supportsBaseUrl: true,
@@ -148,11 +148,19 @@ function createDefaultAiSettings() {
     cost_mode: 'balanced_auto',
     chat_history_window: 20,
     tool_replay_budget_chars: 6000,
+    tool_replay_budget_file_chars: null,
+    tool_replay_budget_browser_chars: null,
+    tool_replay_budget_command_chars: null,
+    max_iterations: null,
+    max_consecutive_read_only_iterations: null,
+    max_consecutive_tool_failures: null,
+    max_model_failure_recoveries: null,
+    compaction_threshold: null,
     subagent_max_iterations: 6,
     subagent_max_children_per_run: 10,
     assistant_behavior_notes: '',
     auto_skill_learning: false,
-    fallback_model_id: 'gpt-5-nano',
+    fallback_model_id: 'openai::gpt-5-nano',
     smarter_model_selector: true,
     enabled_models: [],
     default_chat_model: 'auto',
@@ -179,6 +187,14 @@ function parseSettingValue(value) {
   }
 }
 
+function normalizeOptionalNumber(value, min, max, { integer = false } = {}) {
+  if (value == null || value === '') return null;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return null;
+  const normalized = integer ? Math.floor(parsed) : parsed;
+  return Math.min(Math.max(normalized, min), max);
+}
+
 function normalizeProviderConfigs(rawConfigs) {
   const defaults = createDefaultProviderConfigs();
   const parsed = rawConfigs && typeof rawConfigs === 'object' && !Array.isArray(rawConfigs)
@@ -325,6 +341,14 @@ function getAiSettings(userId, agentId = null) {
 
   settings.chat_history_window = Math.max(6, Math.min(Number(settings.chat_history_window) || DEFAULT_AI_SETTINGS.chat_history_window, 40));
   settings.tool_replay_budget_chars = Math.max(1200, Math.min(Number(settings.tool_replay_budget_chars) || DEFAULT_AI_SETTINGS.tool_replay_budget_chars, 12000));
+  settings.tool_replay_budget_file_chars = normalizeOptionalNumber(settings.tool_replay_budget_file_chars, 500, 500_000, { integer: true });
+  settings.tool_replay_budget_browser_chars = normalizeOptionalNumber(settings.tool_replay_budget_browser_chars, 500, 500_000, { integer: true });
+  settings.tool_replay_budget_command_chars = normalizeOptionalNumber(settings.tool_replay_budget_command_chars, 500, 500_000, { integer: true });
+  settings.max_iterations = normalizeOptionalNumber(settings.max_iterations, 1, 400, { integer: true });
+  settings.max_consecutive_read_only_iterations = normalizeOptionalNumber(settings.max_consecutive_read_only_iterations, 3, 25, { integer: true });
+  settings.max_consecutive_tool_failures = normalizeOptionalNumber(settings.max_consecutive_tool_failures, 1, 50, { integer: true });
+  settings.max_model_failure_recoveries = normalizeOptionalNumber(settings.max_model_failure_recoveries, 0, 10, { integer: true });
+  settings.compaction_threshold = normalizeOptionalNumber(settings.compaction_threshold, 0.1, 1);
   settings.subagent_max_iterations = Math.max(2, Math.min(Number(settings.subagent_max_iterations) || DEFAULT_AI_SETTINGS.subagent_max_iterations, 12));
   settings.subagent_max_children_per_run = Math.max(
     1,

package/server/services/ai/taskAnalysis.js

@@ -17,6 +17,7 @@ const TASK_ANALYSIS_CONFIDENCE_DEFAULT = 0.55;
 const VERIFICATION_CONFIDENCE_VERIFIED = 0.85;
 const VERIFICATION_CONFIDENCE_DEFAULT = 0.5;
 const JSON_ONLY_RESPONSE_RULE = 'Return JSON only. No markdown, no prose, no code fences.';
+const { isDeferredWorkReply } = require('./terminal_reply');
 const ANALYSIS_SCHEMA_EXAMPLE = {
   mode: 'execute',
   needs_verification: true,
@@ -256,7 +257,10 @@ function isDirectAnswerEligibleAnalysis(analysis) {
     planningDepth: analysis.planning_depth,
   });
 
-  return promotedMode === 'direct_answer' && !analysis.needs_subagents && Boolean(draftReply);
+  return promotedMode === 'direct_answer'
+    && !analysis.needs_subagents
+    && Boolean(draftReply)
+    && !isDeferredWorkReply(draftReply);
 }
 
 function extractJsonCandidate(text) {

package/server/services/ai/terminal_reply.js

@@ -0,0 +1,45 @@
+'use strict';
+
+function normalizeReply(content) {
+  return String(content || '')
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/^[\s>*_`#-]+/, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+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);
+}
+
+/**
+ * Detect replies that only announce or promise work which has not happened yet.
+ * This is intentionally conservative and supplements the model completion judge;
+ * it is a deterministic last line of defence against terminating after a status
+ * phrase such as "I'm working on it" or "let me check".
+ */
+function isDeferredWorkReply(content) {
+  const text = normalizeReply(content);
+  if (!text || hasExternalBlocker(text)) return false;
+
+  const acknowledgement = '(?:(?:sure|okay|ok|alright|absolutely|of course|got it|understood)[,.!]?\\s+)?';
+  const taskTarget = '(?:it|this|that|your\\s+(?:request|task|issue)|the\\s+(?:request|task|issue|problem|code|logs?|repository|repo|build|tests?))';
+  const activeWork = `(?:working\\s+(?:on|through)\\s+${taskTarget}|checking(?:\\s+${taskTarget})?|looking\\s+(?:into|at)\\s+${taskTarget}|investigating\\s+${taskTarget}|reviewing\\s+${taskTarget}|researching\\s+${taskTarget}|testing\\s+${taskTarget}|debugging\\s+${taskTarget}|running\\s+${taskTarget}|processing\\s+${taskTarget}|handling\\s+${taskTarget}|starting\\s+${taskTarget}|continuing\\s+${taskTarget})`;
+  const promisedWork = '(?:check|look\\s+into|investigate|review|research|test|debug|run|work\\s+on|handle|start|continue|fix|send|create|update|delete|install|restart|deploy|publish|do\\s+that|take\\s+care\\s+of)';
+  const patterns = [
+    new RegExp(`^${acknowledgement}i(?:'m| am)\\s+(?:(?:still|currently|now|already)\\s+)?${activeWork}\\b`),
+    new RegExp(`^${acknowledgement}i(?:'ll| will)\\s+(?:now\\s+)?${promisedWork}\\b`),
+    new RegExp(`^${acknowledgement}(?:let me|allow me to)\\s+${promisedWork}\\b`),
+    new RegExp(`^${acknowledgement}(?:i(?:'m| am)\\s+going to)\\s+${promisedWork}\\b`),
+    /^(?:(?:please )?give me\s+(?:(?:a|one|another)\s+)?(?:moment|minute|bit)|hang tight|please wait|one moment|bear with me)\b/,
+    /^(?: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/,
+  ];
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+module.exports = {
+  isDeferredWorkReply,
+};

package/server/services/ai/toolEvidence.js

@@ -34,30 +34,50 @@ const EVIDENCE_SOURCE_RULES = [
   { source: 'subagent', match: (name) => name.includes('subagent') },
 ];
 
+const STATE_CHANGING_DEVICE_TOOLS = new Set([
+  'android_install_apk',
+  'android_long_press',
+  'android_open_app',
+  'android_open_intent',
+  'android_press_key',
+  'android_start_emulator',
+  'android_stop_emulator',
+  'android_swipe',
+  'android_tap',
+  'android_type',
+  'desktop_click',
+  'desktop_drag',
+  'desktop_launch_app',
+  'desktop_press_key',
+  'desktop_scroll',
+  'desktop_select_device',
+  'desktop_type',
+]);
+
 function deriveEvidenceSource(name) {
   const rule = EVIDENCE_SOURCE_RULES.find((entry) => entry.match(name));
   return rule ? rule.source : 'tool';
 }
 
-function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '') {
+function resolveDeclaredToolAccess(toolDefinition, toolArgs = {}) {
+  const access = String(toolDefinition?.access || '').trim().toLowerCase();
+  if (access === 'read' || access === 'write') return access;
+  if (access !== 'dynamic_http_method') return null;
+
+  const method = String(toolArgs?.method || toolArgs?.http_method || 'GET')
+    .trim()
+    .toUpperCase();
+  return ['GET', 'HEAD', 'OPTIONS'].includes(method) ? 'read' : 'write';
+}
+
+function classifyToolExecution(
+  toolName,
+  toolArgs = {},
+  result,
+  errorMessage = '',
+  toolDefinition = null,
+) {
   const name = String(toolName || '');
-  const evidenceRelevantPrefixes = ['browser_', 'android_'];
-  const evidenceRelevantExact = new Set([
-    'web_search',
-    'http_request',
-    'read_file',
-    'read_files',
-    'search_files',
-    'list_directory',
-    'code_navigate',
-    'query_structured_data',
-    'session_search',
-    'memory_recall',
-    'analyze_image',
-    'read_health_data',
-    'list_tasks',
-    'wait_subagent',
-  ]);
   const stateChangingExact = new Set([
     'execute_command',
     'write_file',
@@ -79,22 +99,30 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     'mcp_add_server',
     'mcp_remove_server',
     'spawn_subagent',
+    'delegate_to_agent',
     'cancel_subagent',
   ]);
 
-  const evidenceSource = deriveEvidenceSource(name);
+  const declaredAccess = resolveDeclaredToolAccess(toolDefinition, toolArgs);
+  const evidenceSource = declaredAccess ? 'integration' : deriveEvidenceSource(name);
 
-  const evidenceRelevant = evidenceRelevantExact.has(name)
-    || evidenceRelevantPrefixes.some((prefix) => name.startsWith(prefix));
-  const stateChanged = (
-    name === 'execute_command'
-      ? !isClearlyReadOnlyShellCommand(toolArgs?.command || '')
-      : stateChangingExact.has(name)
-  )
+  // Any successful, substantive tool result can advance the run. This default
+  // is deliberate: MCP, skills, and newly added integrations must not become
+  // invisible to the churn guard just because their names were not added to a
+  // central allow-list. Repetition detection still rejects unchanged retries.
+  const evidenceRelevant = isSubstantiveProgressToolName(name);
+  let directStateChange;
+  if (name === 'execute_command' || name === 'android_shell') {
+    directStateChange = !isClearlyReadOnlyShellCommand(toolArgs?.command || '');
+  } else {
+    directStateChange = declaredAccess === 'write'
+      || STATE_CHANGING_DEVICE_TOOLS.has(name)
+      || stateChangingExact.has(name);
+  }
+  const stateChanged = directStateChange
     || (name.startsWith('github_') && isProgressToolCall(name, toolArgs))
     || (name === 'http_request' && isProgressToolCall(name, toolArgs))
-    || name.startsWith('android_')
-    || ['browser_click', 'browser_type', 'browser_evaluate'].includes(name);
+    || ['browser_click', 'browser_evaluate', 'browser_navigate', 'browser_type'].includes(name);
 
   let normalizedError = String(errorMessage || result?.error || '').trim();
   if (!normalizedError && name === 'execute_command' && result && typeof result === 'object') {
@@ -167,7 +195,7 @@ function gatheredNewEvidence(execution, repetitionObservation = null) {
 function isSubstantiveProgressToolName(toolName = '') {
   const name = String(toolName || '').trim();
   if (!name) return false;
-  if (name === 'send_message' || name === 'send_interim_update' || name === 'make_call') return false;
+  if (name === 'send_message' || name === 'send_interim_update' || name === 'make_call' || name === 'notify_user') return false;
   if (name === 'think' || name === 'activate_tools' || name === 'task_complete') return false;
   return true;
 }
@@ -254,4 +282,5 @@ module.exports = {
   summarizeAvailableTools,
   inferToolFailureMessage,
   buildAutonomousRecoveryContext,
+  resolveDeclaredToolAccess,
 };