neoagent 2.4.1-beta.11 → 2.4.1-beta.13

package/server/services/ai/settings.js

@@ -49,6 +49,26 @@ const AI_PROVIDER_DEFINITIONS = Object.freeze({
     defaultEnabled: true,
     defaultBaseUrl: 'https://api.x.ai/v1'
   },
+  'grok-oauth': {
+    id: 'grok-oauth',
+    label: 'Grok (xAI OAuth)',
+    description: 'Grok models via xAI account. Login with `neoagent login grok-oauth`.',
+    envKey: 'GROK_OAUTH_ACCESS_TOKEN',
+    supportsApiKey: true,
+    supportsBaseUrl: false,
+    defaultEnabled: false,
+    defaultBaseUrl: ''
+  },
+  nvidia: {
+    id: 'nvidia',
+    label: 'NVIDIA NIM',
+    description: 'NVIDIA-hosted models including free-tier Nemotron, Kimi, Llama 4, and DeepSeek. Get a key at build.nvidia.com.',
+    envKey: 'NVIDIA_API_KEY',
+    supportsApiKey: true,
+    supportsBaseUrl: true,
+    defaultEnabled: false,
+    defaultBaseUrl: 'https://integrate.api.nvidia.com/v1'
+  },
   minimax: {
     id: 'minimax',
     label: 'MiniMax Code',

package/server/services/ai/taskAnalysis.js

@@ -1,5 +1,9 @@
 const ANALYSIS_MODES = ['direct_answer', 'execute', 'plan_execute'];
 const VERIFICATION_STATUSES = ['verified', 'needs_revision', 'insufficient_evidence'];
+const COMPLEXITY_LEVELS = ['simple', 'standard', 'complex'];
+const AUTONOMY_LEVELS = ['minimal', 'normal', 'high'];
+const PROGRESS_UPDATE_POLICIES = ['none', 'optional', 'required'];
+const COMPLETION_CONFIDENCE_LEVELS = ['medium', 'high'];
 const TASK_ANALYSIS_SUGGESTED_TOOLS_LIMIT = 12;
 const TASK_ANALYSIS_SUCCESS_CRITERIA_LIMIT = 8;
 const PLAN_STEP_SUGGESTED_TOOLS_LIMIT = 8;
@@ -20,6 +24,11 @@ const ANALYSIS_SCHEMA_EXAMPLE = {
   goal: 'Answer the user accurately.',
   success_criteria: ['Final reply is correct and specific.'],
   suggested_tools: ['web_search', 'browser_navigate'],
+  complexity: 'standard',
+  autonomy_level: 'normal',
+  progress_update_policy: 'optional',
+  parallel_work: false,
+  completion_confidence_required: 'medium',
 };
 const PLAN_SCHEMA_EXAMPLE = {
   steps: [
@@ -42,6 +51,11 @@ const ANALYSIS_PROMPT_INSTRUCTIONS = [
   'Set goal to a concise restatement of what the user is asking for in this message. Never leave goal empty.',
   'Keep goal and success_criteria short and practical.',
   'suggested_tools are optional hints, not a required plan.',
+  'Set complexity from the actual work shape, not from keywords: simple, standard, or complex.',
+  'Set autonomy_level="high" when the agent should decide sequencing, retries, evidence gathering, and verification without asking the user unless blocked.',
+  'Set progress_update_policy="required" for long, slow, voice, messaging, or externally visible work where silence would be confusing.',
+  '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.',
 ];
 const PLAN_PROMPT_INSTRUCTIONS = [
   'Create a concise execution plan for the current task.',
@@ -51,6 +65,8 @@ const PLAN_PROMPT_INSTRUCTIONS = [
   'For external actions, include a step to draft or confirm before sending unless the user already gave explicit current-session approval.',
   'For code or config changes, include inspection, scoped edit, and verification steps.',
   'For tasks that run later, make the future prompt self-contained and include notification conditions.',
+  'Call out independent work that can start before slower blocking work finishes.',
+  'Make the final step prove completion against the success criteria, not just produce a plausible answer.',
 ];
 const VERIFIER_PROMPT_INSTRUCTIONS = [
   'Verify whether the draft final reply is adequately supported by the gathered evidence.',
@@ -69,6 +85,7 @@ const EXECUTION_GUIDANCE_ACTION_LINES = [
   'When you must ask for missing required user input, ask once, then wait for the reply instead of re-asking in the same run.',
   'For outbound messages, calls, emails, shared edits, installs, restarts, or task mutations, verify the action result before claiming it happened. If user confirmation is required and missing, draft or ask instead of sending.',
   'Retry with alternative tools or approaches when one path fails. If evidence is still insufficient, say so explicitly instead of guessing.',
+  'When completion_confidence_required is high, do not call task_complete with low confidence. Verify, inspect, or revise until confidence is at least medium and preferably high.',
 ];
 
 function buildVerifierSchemaExample(finalReply) {
@@ -185,6 +202,18 @@ function planningDepthForMode(mode) {
   return mode === 'plan_execute' ? 'deep' : mode === 'direct_answer' ? 'none' : 'light';
 }
 
+function defaultAutonomyForMode(mode) {
+  if (mode === 'direct_answer') return 'minimal';
+  if (mode === 'plan_execute') return 'high';
+  return 'normal';
+}
+
+function defaultComplexityForMode(mode) {
+  if (mode === 'direct_answer') return 'simple';
+  if (mode === 'plan_execute') return 'complex';
+  return 'standard';
+}
+
 function verificationNeedFor({ mode, needsVerification, hasDraftReply }) {
   if (needsVerification === true) return 'light';
   if (needsVerification === false) {
@@ -321,6 +350,17 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
     planningDepth,
   });
 
+  const normalizedComplexity = pickEnum(
+    resolveAliasedValue(raw, fallback, 'complexity', 'complexity', ''),
+    COMPLEXITY_LEVELS,
+    defaultComplexityForMode(mode),
+  );
+  const normalizedAutonomyLevel = pickEnum(
+    resolveAliasedValue(raw, fallback, 'autonomy_level', 'autonomyLevel', ''),
+    AUTONOMY_LEVELS,
+    defaultAutonomyForMode(mode),
+  );
+
   return {
     mode,
     freshness_risk: freshnessRisk,
@@ -336,6 +376,19 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
     draft_reply: draftReply,
     goal: resolveAliasedText(raw, fallback, 'goal', 'goal', ''),
     success_criteria: successCriteria,
+    complexity: mode === 'plan_execute' ? 'complex' : normalizedComplexity,
+    autonomy_level: mode === 'plan_execute' ? 'high' : normalizedAutonomyLevel,
+    progress_update_policy: pickEnum(
+      resolveAliasedValue(raw, fallback, 'progress_update_policy', 'progressUpdatePolicy', ''),
+      PROGRESS_UPDATE_POLICIES,
+      mode === 'direct_answer' ? 'none' : 'optional',
+    ),
+    parallel_work: resolveAliasedBoolean(raw, fallback, 'parallel_work', 'parallelWork'),
+    completion_confidence_required: pickEnum(
+      resolveAliasedValue(raw, fallback, 'completion_confidence_required', 'completionConfidenceRequired', ''),
+      COMPLETION_CONFIDENCE_LEVELS,
+      verificationNeed === 'required' || mode === 'plan_execute' ? 'high' : 'medium',
+    ),
   };
 }
 
@@ -483,6 +536,7 @@ function buildPlanPrompt(analysis, capabilityHealth) {
     `Task goal: ${taskGoal}`,
     formatExistingSuccessCriteriaLine(analysis.success_criteria),
     formatSuggestedToolsFromAnalysisLine(analysis.suggested_tools),
+    `Autonomy: complexity=${analysis.complexity || 'standard'}, autonomy_level=${analysis.autonomy_level || 'normal'}, progress_update_policy=${analysis.progress_update_policy || 'optional'}, parallel_work=${analysis.parallel_work === true}, completion_confidence_required=${analysis.completion_confidence_required || 'medium'}`,
   ], PLAN_SCHEMA_EXAMPLE);
 }
 
@@ -494,6 +548,7 @@ function buildExecutionGuidance({ analysis, plan = null, capabilityHealth }) {
     analysis.suggested_tools?.length
       ? `Advisory tool suggestions: ${analysis.suggested_tools.join(', ')}`
       : '',
+    `Autonomy contract: complexity=${analysis.complexity || 'standard'}; autonomy_level=${analysis.autonomy_level || 'normal'}; progress_update_policy=${analysis.progress_update_policy || 'optional'}; parallel_work=${analysis.parallel_work === true}; completion_confidence_required=${analysis.completion_confidence_required || 'medium'}.`,
     capabilityHealth ? `Capability health:\n${capabilityHealth}` : '',
   ];
 
@@ -512,6 +567,7 @@ function buildVerifierPrompt({ analysis, toolExecutionSummary, evidenceSources,
     ...VERIFIER_PROMPT_INSTRUCTIONS,
     `Freshness risk: ${analysis.freshness_risk}`,
     `Verification need: ${analysis.verification_need}`,
+    `Completion confidence required: ${analysis.completion_confidence_required || 'medium'}`,
     formatEvidenceSourcesLine(evidenceSources),
     toolExecutionSummary ? `Execution evidence:\n${toolExecutionSummary}` : '',
     `Draft final reply:\n${finalReply || '(empty)'}`,

package/server/services/ai/tools.js

@@ -1289,7 +1289,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 +1300,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']
         }
     });
 

package/server/services/integrations/google/provider.js

@@ -129,6 +129,19 @@ async function buildAuthorizedClient(connection) {
     credentials = {};
   }
   client.setCredentials(credentials);
+  // Capture any token refresh that happens during the request so the new
+  // access_token + expiry_date are always available on client.credentials.
+  // The library preserves refresh_token internally; this listener just ensures
+  // client.credentials stays in sync when refreshes happen inside deep call stacks.
+  client.on('tokens', (tokens) => {
+    if (tokens.access_token) {
+      client.setCredentials({
+        ...client.credentials,
+        ...tokens,
+        refresh_token: tokens.refresh_token || client.credentials.refresh_token,
+      });
+    }
+  });
   return client;
 }
 

package/server/services/integrations/manager.js

@@ -679,6 +679,11 @@ class IntegrationManager {
             userId,
             resolveAgentId(userId, agentId),
           );
+          return {
+            error: `Your ${provider.label} account connection has expired and needs to be reconnected. Open Official Integrations to reconnect your account.`,
+            expired: true,
+            connectionId: selection.connection.id,
+          };
         }
         return { error: err?.message || 'execution_error' };
       }

package/server/services/integrations/trello/provider.js

@@ -9,7 +9,7 @@ const {
 } = require('../provider_config_store');
 const { getConnectionAccessMode } = require('../access');
 const { fetchJson } = require('../oauth_provider');
-const { encryptValue } = require('../secrets');
+const { encryptValue, decryptValue } = require('../secrets');
 
 const TRELLO_APP = {
   id: 'trello',
@@ -732,7 +732,13 @@ function createTrelloProvider() {
       return 'Trello: native Trello access is connected in this run with one Trello account for board, list, card, comment, and search tools.';
     },
     async executeTool(toolName, args, connection) {
-      return executeTrelloTool(toolName, args, connection);
+      let credentials = {};
+      try {
+        credentials = JSON.parse(decryptValue(connection.credentials_json || '{}') || '{}');
+      } catch {
+        credentials = {};
+      }
+      return executeTrelloTool(toolName, args, { connection, credentials });
     },
     getUserConfig({ userId, agentId }) {
       const normalizedUserId = Number(userId);