neoagent 3.2.1-beta.1 → 3.2.1-beta.11

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,11 +195,204 @@ 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;
 }
 
+function clampResearchText(value, maxChars = 220) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 1)).trimEnd()}…`;
+}
+
+function uniqueResearchTokens(values = [], { limit = 12 } = {}) {
+  const seen = new Set();
+  const tokens = [];
+  for (const value of values) {
+    const token = String(value || '').replace(/\s+/g, ' ').trim();
+    if (!token) continue;
+    const key = token.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    tokens.push(token);
+    if (tokens.length >= limit) break;
+  }
+  return tokens;
+}
+
+// Research targets come from structured task analysis / goal contract only.
+// Do not NLP-extract entity names from free text.
+function collectResearchTargets(analysis = null, goalContext = null) {
+  return uniqueResearchTokens([
+    ...(Array.isArray(analysis?.research_targets) ? analysis.research_targets : []),
+    ...(Array.isArray(goalContext?.researchTargets) ? goalContext.researchTargets : []),
+  ], { limit: 8 });
+}
+
+function resolveResearchIntensity(analysis = null, goalContext = null) {
+  const declaredDepth = String(
+    analysis?.research_depth
+    || analysis?.researchDepth
+    || '',
+  ).trim().toLowerCase();
+  const declaredTargets = collectResearchTargets(analysis, goalContext);
+  if (
+    ['none', 'light', 'deep'].includes(declaredDepth)
+    && !(declaredDepth === 'none' && declaredTargets.length > 0)
+  ) {
+    return declaredDepth;
+  }
+
+  const mode = String(analysis?.mode || '').trim().toLowerCase();
+  const complexity = String(
+    goalContext?.effectiveComplexity
+    || analysis?.complexity
+    || '',
+  ).trim().toLowerCase();
+  const autonomyLevel = String(
+    goalContext?.effectiveAutonomyLevel
+    || analysis?.autonomy_level
+    || '',
+  ).trim().toLowerCase();
+  const completionConfidence = String(
+    goalContext?.effectiveCompletionConfidence
+    || analysis?.completion_confidence_required
+    || '',
+  ).trim().toLowerCase();
+  const verificationNeed = String(analysis?.verification_need || '').trim().toLowerCase();
+  const freshnessRisk = String(analysis?.freshness_risk || '').trim().toLowerCase();
+  const planningDepth = String(analysis?.planning_depth || '').trim().toLowerCase();
+  const targets = declaredTargets;
+
+  if (mode === 'direct_answer' && verificationNeed === 'none' && freshnessRisk === 'none') {
+    return 'none';
+  }
+
+  const needsExternalEvidence = (
+    targets.length > 0
+    || freshnessRisk === 'possible'
+    || freshnessRisk === 'high'
+  );
+  if (!needsExternalEvidence) {
+    return 'none';
+  }
+
+  const deepSignals = [
+    mode === 'plan_execute',
+    complexity === 'complex',
+    autonomyLevel === 'high',
+    completionConfidence === 'high',
+    verificationNeed === 'required',
+    freshnessRisk === 'high',
+    planningDepth === 'deep',
+    targets.length >= 2,
+  ].filter(Boolean).length;
+
+  if (deepSignals >= 2 || targets.length >= 2 || verificationNeed === 'required' || freshnessRisk === 'high') {
+    return 'deep';
+  }
+
+  return 'light';
+}
+
+function isSuccessfulResearchExecution(item = {}) {
+  if (!item || item.ok !== true) return false;
+  if (!isSubstantiveProgressToolName(item.toolName)) return false;
+  if (item.evidenceSource === 'messaging') return false;
+  return Boolean(item.evidenceRelevant || item.dependsOnOutput || item.stateChanged);
+}
+
+function selectResearchEvidenceCandidates(toolExecutions = [], maxItems = 80) {
+  const candidates = (Array.isArray(toolExecutions) ? toolExecutions : [])
+    .map((execution, index) => ({ execution, evidenceIndex: index + 1 }))
+    .filter(({ execution }) => isSuccessfulResearchExecution(execution));
+  if (candidates.length <= maxItems) return candidates;
+
+  const firstCount = Math.floor(maxItems / 4);
+  return [
+    ...candidates.slice(0, firstCount),
+    ...candidates.slice(-(maxItems - firstCount)),
+  ];
+}
+
+function summarizeResearchEvidenceCatalog(toolExecutions = [], maxItems = 80) {
+  return selectResearchEvidenceCandidates(toolExecutions, maxItems)
+    .map(({ execution, evidenceIndex }) => (
+      `E${evidenceIndex}. ${execution.toolName} [${execution.evidenceSource || 'tool'}] :: ${clampRunContext(execution.summary || '', 160)}`
+    ))
+    .join('\n');
+}
+
+function researchExecutionSignature(execution = {}) {
+  return JSON.stringify([
+    String(execution.toolName || '').trim(),
+    execution.input && typeof execution.input === 'object' ? execution.input : {},
+  ]);
+}
+
+function assessResearchAdequacy({
+  analysis = null,
+  goalContext = null,
+  toolExecutions = [],
+} = {}) {
+  const intensity = resolveResearchIntensity(analysis, goalContext);
+  const targets = collectResearchTargets(analysis, goalContext);
+
+  const successful = (Array.isArray(toolExecutions) ? toolExecutions : [])
+    .filter(isSuccessfulResearchExecution);
+  const uniqueEvidenceCandidateCount = new Set(
+    successful.map((item) => researchExecutionSignature(item)),
+  ).size;
+  const structurallyReady = intensity === 'none' || uniqueEvidenceCandidateCount > 0;
+  const missing = structurallyReady
+    ? []
+    : ['No successful source-bearing tool evidence is available for semantic review.'];
+  const nextActions = [];
+  if (!structurallyReady) {
+    nextActions.push('Gather source-backed evidence before requesting completion.');
+  } else if (intensity !== 'none') {
+    nextActions.push('Have the completion judge map each requested target to concrete evidence entries and assess source quality.');
+  }
+
+  return {
+    intensity,
+    adequate: structurallyReady,
+    structurallyReady,
+    semanticReviewRequired: intensity !== 'none',
+    evidenceCandidateCount: successful.length,
+    uniqueEvidenceCandidateCount,
+    targets,
+    coveredTargets: [],
+    primaryCoveredTargets: [],
+    uncoveredTargets: intensity === 'none' ? [] : targets,
+    primaryUncoveredTargets: intensity === 'none' ? [] : targets,
+    missing,
+    nextActions,
+    reason: structurallyReady
+      ? (intensity === 'none'
+        ? 'No research burden for this run.'
+        : 'Source candidates exist; the AI completion judge must still validate target coverage and source quality.')
+      : clampResearchText(missing.join(' ') || 'Research evidence is still incomplete.', 320),
+  };
+}
+
+function formatResearchAdequacyGuidance(assessment = null) {
+  if (!assessment || assessment.intensity === 'none') return '';
+  const lines = [
+    assessment.structurallyReady
+      ? 'Research self-check: source candidates exist, but semantic target coverage is not inferred from tool names, arguments, or token overlap.'
+      : 'Research self-check: no successful source evidence is available yet.',
+    assessment.reason ? `Gap: ${assessment.reason}` : '',
+    assessment.nextActions?.length
+      ? `Next safe steps:\n- ${assessment.nextActions.join('\n- ')}`
+      : '',
+    'The completion judge must explicitly map every requested target to supporting evidence and judge whether that evidence is primary, secondary, or merely contextual.',
+  ];
+  return lines.filter(Boolean).join('\n');
+}
+
 function isSubstantiveProgressEvidence(item = {}) {
   if (!isSubstantiveProgressToolName(item.toolName)) return false;
   if (item.evidenceSource === 'messaging') return false;
@@ -246,12 +467,18 @@ function buildAutonomousRecoveryContext({ err, toolExecutions = [], tools = [],
 module.exports = {
   classifyToolExecution,
   deriveEvidenceSource,
+  assessResearchAdequacy,
+  formatResearchAdequacyGuidance,
   gatheredNewEvidence,
   isSubstantiveProgressEvidence,
   isSubstantiveProgressToolName,
+  resolveResearchIntensity,
+  selectResearchEvidenceCandidates,
+  summarizeResearchEvidenceCatalog,
   summarizeProgressToolExecutions,
   summarizeToolExecutions,
   summarizeAvailableTools,
   inferToolFailureMessage,
   buildAutonomousRecoveryContext,
+  resolveDeclaredToolAccess,
 };