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

package/server/services/ai/engine.js

@@ -78,6 +78,11 @@ function buildSkipTaskAnalysisResult(forceMode) {
     draft_reply: '',
     goal: 'Complete the user request accurately.',
     success_criteria: [],
+    complexity: forceMode === 'plan_execute' ? 'complex' : 'standard',
+    autonomy_level: forceMode === 'plan_execute' ? 'high' : 'normal',
+    progress_update_policy: 'optional',
+    parallel_work: false,
+    completion_confidence_required: forceMode === 'plan_execute' ? 'high' : 'medium',
   };
 }
 
@@ -87,6 +92,11 @@ function buildAnalyzeTaskFallback(forceMode, userMessage = '') {
     verification_need: 'light',
     planning_depth: planningDepthForForceMode(forceMode),
     goal: userMessage ? String(userMessage).trim().slice(0, 300) : '',
+    complexity: forceMode === 'plan_execute' ? 'complex' : 'standard',
+    autonomy_level: forceMode === 'plan_execute' ? 'high' : 'normal',
+    progress_update_policy: 'optional',
+    parallel_work: false,
+    completion_confidence_required: forceMode === 'plan_execute' ? 'high' : 'medium',
   };
 }
 
@@ -97,6 +107,19 @@ function applyForcedAnalysisMode(analysis, forceMode) {
     ...analysis,
     mode: 'plan_execute',
     planning_depth: 'deep',
+    complexity: 'complex',
+    autonomy_level: 'high',
+    completion_confidence_required: analysis.completion_confidence_required || 'high',
+  };
+}
+
+function buildAutonomyPolicyFromAnalysis(analysis = {}) {
+  return {
+    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',
   };
 }
 
@@ -150,22 +173,19 @@ async function getProviderForUser(userId, task = '', isSubagent = false, modelOv
   if (userSelectedDefault && userSelectedDefault !== 'auto') {
     selectedModelDef = models.find((m) => m.id === userSelectedDefault) || fallbackModel;
   } else {
-    const taskStr = String(task || '').toLowerCase();
-
-    // Basic detection
-    let isPlanning = /\b(plan|think|analy[sz]e|complex|step by step)\b/.test(taskStr);
-    let isCoding = false;
-
-    // Enhanced detection if enabled
-    if (smarterSelection) {
-      isPlanning = isPlanning || /\b(reason|strategy|logical|math|complex)\b/.test(taskStr);
-      isCoding = /\b(code|program|script|debug|refactor|function|implementation|logic)\b/.test(taskStr);
-    }
-
-    if (isPlanning) {
+    const selectionHint = providerConfig.selectionHint && typeof providerConfig.selectionHint === 'object'
+      ? providerConfig.selectionHint
+      : {};
+    const preferredPurpose = String(selectionHint.purpose || '').trim().toLowerCase();
+    const highAutonomy = selectionHint.autonomyLevel === 'high' || selectionHint.complexity === 'complex';
+    const requestedPurpose = ['planning', 'coding', 'general', 'fast'].includes(preferredPurpose)
+      ? preferredPurpose
+      : '';
+
+    if (smarterSelection && requestedPurpose) {
+      selectedModelDef = availableModels.find((m) => m.purpose === requestedPurpose) || fallbackModel;
+    } else if (smarterSelection && highAutonomy) {
       selectedModelDef = availableModels.find((m) => m.purpose === 'planning') || fallbackModel;
-    } else if (isCoding) {
-      selectedModelDef = availableModels.find((m) => m.purpose === 'coding') || availableModels.find((m) => m.purpose === 'planning') || fallbackModel;
     } else if (isSubagent) {
       selectedModelDef = availableModels.find((m) => m.purpose === 'fast') || fallbackModel;
     } else {
@@ -411,6 +431,40 @@ function buildModelFailureLoopPrompt({ failedModel, nextModel, errorMessage }) {
   ].join(' ');
 }
 
+function normalizeCompletionConfidence(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'high' || normalized === 'medium' || normalized === 'low') return normalized;
+  return 'medium';
+}
+
+function completionConfidenceRank(value) {
+  const normalized = normalizeCompletionConfidence(value);
+  if (normalized === 'high') return 3;
+  if (normalized === 'medium') return 2;
+  return 1;
+}
+
+function shouldAcceptTaskComplete({ confidence, requiredConfidence, iteration, maxIterations }) {
+  const required = normalizeCompletionConfidence(requiredConfidence || 'medium');
+  const actual = normalizeCompletionConfidence(confidence || 'medium');
+  if (completionConfidenceRank(actual) >= completionConfidenceRank(required)) {
+    return { accept: true, reason: '' };
+  }
+
+  const iterationsRemaining = Math.max(0, Number(maxIterations || 0) - Number(iteration || 0));
+  if (iterationsRemaining <= 1) {
+    return {
+      accept: true,
+      reason: `Accepted ${actual}-confidence completion at the iteration limit; final verifier will calibrate the answer.`,
+    };
+  }
+
+  return {
+    accept: false,
+    reason: `Completion confidence "${actual}" is below required "${required}". Continue with verification, recovery, or a narrower truthful result before completing.`,
+  };
+}
+
 function clampRunContext(text, maxChars) {
   const value = normalizeOutgoingMessage(text);
   if (!value) return '';
@@ -1064,12 +1118,14 @@ class AgentEngine {
         '- A progress update is not complete.',
         '- A single failed tool attempt is not blocked if another safe retry, verification step, or alternative path remains.',
         '- A tool-specific API error, timeout, rate limit, or missing result inside this run is usually "continue", not "blocked", if any other available tool could still make progress.',
+        '- If completion_confidence_required is high and the latest draft depends on unverified assumptions, use "continue" so the run can gather evidence, inspect state, or narrow the reply.',
         triggerSource === 'messaging' && messagingSent
           ? '- A reply was already delivered to the user via send_message. Use "complete" unless there is concrete remaining work (e.g., a tool call you still need to make) before the task is truly done. Do not send follow-up elaborations or re-introductions.'
           : triggerSource === 'messaging'
             ? '- For messaging, do not stop on a partial status message. Continue unless the task is actually complete or externally blocked. If you already asked for missing user input, choose "blocked" and wait.'
             : '- Do not stop just because you wrote a status update. Continue unless the task is actually complete or externally blocked.',
         analysis?.goal ? `Goal: ${analysis.goal}` : '',
+        `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'}.`,
         successCriteria.length > 0 ? `Success criteria:\n${successCriteria.map((item, index) => `${index + 1}. ${item}`).join('\n')}` : '',
         `Current iteration: ${iteration} of ${maxIterations}.`,
         `Available tools in this run: ${summarizeAvailableTools(tools) || 'none'}`,
@@ -1780,11 +1836,53 @@ class AgentEngine {
 
       }
 
+      const activeDefaultModelSetting = triggerType === 'subagent'
+        ? aiSettings.default_subagent_model
+        : aiSettings.default_chat_model;
+      if (!_modelOverride && activeDefaultModelSetting === 'auto' && aiSettings.smarter_model_selector !== false) {
+        const requestedPurpose = analysis?.mode === 'plan_execute' || analysis?.complexity === 'complex' || analysis?.autonomy_level === 'high'
+          ? 'planning'
+          : triggerType === 'subagent'
+            ? 'fast'
+            : '';
+        if (requestedPurpose) {
+          const selectedAfterAnalysis = await getProviderForUser(
+            userId,
+            userMessage,
+            triggerType === 'subagent',
+            null,
+            {
+              ...providerStatusConfig,
+              selectionHint: {
+                purpose: requestedPurpose,
+                complexity: analysis?.complexity,
+                autonomyLevel: analysis?.autonomy_level,
+              },
+            }
+          );
+          if (selectedAfterAnalysis.model !== model) {
+            provider = selectedAfterAnalysis.provider;
+            model = selectedAfterAnalysis.model;
+            providerName = selectedAfterAnalysis.providerName;
+            db.prepare('UPDATE agent_runs SET model = ?, updated_at = datetime(\'now\') WHERE id = ?')
+              .run(model, runId);
+            this.emit(userId, 'run:interim', {
+              runId,
+              message: `Switched to ${model} for this run after task analysis.`,
+              phase: 'model_selection'
+            });
+          }
+        }
+      }
+
       // Rebuild loop policy with the resolved analysis mode. Runs in both the
       // normal path and the skipTaskAnalysis path so that forceMode='plan_execute'
       // (or any mode set by buildSkipTaskAnalysisResult) raises the iteration
       // ceiling correctly.
-      loopPolicy = buildLoopPolicy(aiSettings, triggerType, analysis.mode || 'execute', options);
+      loopPolicy = buildLoopPolicy(aiSettings, triggerType, analysis.mode || 'execute', {
+        ...options,
+        autonomyPolicy: buildAutonomyPolicyFromAnalysis(analysis),
+      });
       maxIterations = loopPolicy.maxIterations;
 
       if (options.skipDeliverableWorkflow !== true) {
@@ -2155,15 +2253,46 @@ class AgentEngine {
           // regular tool execution, it is a loop-exit signal.
           if (toolName === 'task_complete') {
             const finalMessage = String(toolArgs.message || '').trim();
+            const confidence = normalizeCompletionConfidence(toolArgs.confidence || 'medium');
+            const completionDecision = shouldAcceptTaskComplete({
+              confidence,
+              requiredConfidence: analysis?.completion_confidence_required || 'medium',
+              iteration,
+              maxIterations,
+            });
             this.recordRunEvent(userId, runId, 'task_complete_signaled', {
-              confidence: toolArgs.confidence || 'high',
+              confidence,
+              requiredConfidence: analysis?.completion_confidence_required || 'medium',
+              accepted: completionDecision.accept,
               iteration,
               messageLength: finalMessage.length,
             }, { agentId });
             console.info(
-              `[Run ${shortenRunId(runId)}] task_complete signaled at iteration=${iteration} confidence=${toolArgs.confidence || 'high'}`
+              `[Run ${shortenRunId(runId)}] task_complete signaled at iteration=${iteration} confidence=${confidence} accepted=${completionDecision.accept}`
             );
-            // Always honor task_complete as a stop signal, even with no message.
+            if (!completionDecision.accept) {
+              messages.push({
+                role: 'tool',
+                name: toolName,
+                tool_call_id: toolCall.id,
+                content: JSON.stringify({
+                  status: 'continue',
+                  reason: completionDecision.reason,
+                  required_confidence: analysis?.completion_confidence_required || 'medium',
+                }),
+              });
+              messages.push({
+                role: 'system',
+                content: `${completionDecision.reason} Do not ask the user to decide the next step unless external input is truly required.`
+              });
+              continue;
+            }
+            if (completionDecision.reason) {
+              messages.push({
+                role: 'system',
+                content: completionDecision.reason,
+              });
+            }
             lastContent = finalMessage; // empty string is valid; downstream handles it
             directAnswerEligible = true;
             break; // exit the for-loop; the while condition will also exit

package/server/services/ai/loopPolicy.js

@@ -46,6 +46,13 @@ function clampFinite(n, lo, hi, fallback) {
  * @returns {LoopPolicy}
  */
 function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = 'execute', options = {}) {
+  const autonomyPolicy = options.autonomyPolicy && typeof options.autonomyPolicy === 'object'
+    ? options.autonomyPolicy
+    : {};
+  const complexity = String(autonomyPolicy.complexity || '').trim().toLowerCase();
+  const autonomyLevel = String(autonomyPolicy.autonomy_level || autonomyPolicy.autonomyLevel || '').trim().toLowerCase();
+  const parallelWork = autonomyPolicy.parallel_work === true || autonomyPolicy.parallelWork === true;
+
   // ── maxIterations ────────────────────────────────────────────────────────
   // Resolve raw value from options → aiSettings → mode/context defaults,
   // then clamp to [1, MAX_ALLOWED_ITERATIONS] and floor to integer.
@@ -58,6 +65,10 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
     rawIterations = DEFAULT_WIDGET_MAX_ITERATIONS;
   } else if (analysisMode === 'plan_execute') {
     rawIterations = DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS;
+  } else if (complexity === 'complex' || autonomyLevel === 'high') {
+    rawIterations = DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS;
+  } else if (parallelWork || complexity === 'standard') {
+    rawIterations = Math.max(DEFAULT_MAX_ITERATIONS, 28);
   } else {
     rawIterations = DEFAULT_MAX_ITERATIONS;
   }

package/server/services/ai/models.js

@@ -6,6 +6,8 @@ const { OpenAIProvider } = require('./providers/openai');
 const { GithubCopilotProvider } = require('./providers/githubCopilot');
 const { OpenAICodexProvider } = require('./providers/openaiCodex');
 const { ClaudeCodeProvider } = require('./providers/claudeCode');
+const { GrokOAuthProvider } = require('./providers/grokOauth');
+const { NvidiaProvider } = require('./providers/nvidia');
 const {
     AI_PROVIDER_DEFINITIONS,
     getProviderConfigs,
@@ -19,6 +21,18 @@ const STATIC_MODELS = [
         provider: 'grok',
         purpose: 'general'
     },
+    {
+        id: 'grok-4',
+        label: 'Grok 4 (xAI OAuth / Default)',
+        provider: 'grok-oauth',
+        purpose: 'general'
+    },
+    {
+        id: 'grok-4-mini',
+        label: 'Grok 4 Mini (xAI OAuth / Fast)',
+        provider: 'grok-oauth',
+        purpose: 'coding'
+    },
     {
         id: 'gpt-5.3',
         label: 'GPT-5.3 (Copilot Default)',
@@ -49,6 +63,56 @@ const STATIC_MODELS = [
         provider: 'openai-codex',
         purpose: 'general'
     },
+    // — NVIDIA NIM — free tier ————————————————————————————————————————————
+    {
+        id: 'nvidia/nemotron-3-super-120b-a12b',
+        label: 'Nemotron Super 120B (NVIDIA / Free)',
+        provider: 'nvidia',
+        purpose: 'general'
+    },
+    {
+        id: 'moonshotai/kimi-k2.5',
+        label: 'Kimi K2.5 (NVIDIA NIM / Free)',
+        provider: 'nvidia',
+        purpose: 'coding'
+    },
+    {
+        id: 'minimaxai/minimax-m2.5',
+        label: 'MiniMax M2.5 (NVIDIA NIM / Free)',
+        provider: 'nvidia',
+        purpose: 'planning'
+    },
+    {
+        id: 'z-ai/glm5',
+        label: 'GLM 5 (NVIDIA NIM / Free)',
+        provider: 'nvidia',
+        purpose: 'fast'
+    },
+    // — NVIDIA NIM — notable models ————————————————————————————————————————
+    {
+        id: 'meta/llama-4-maverick-17b-128e-instruct',
+        label: 'Llama 4 Maverick 17B (NVIDIA NIM)',
+        provider: 'nvidia',
+        purpose: 'general'
+    },
+    {
+        id: 'meta/llama-4-scout-17b-16e-instruct',
+        label: 'Llama 4 Scout 17B (NVIDIA NIM)',
+        provider: 'nvidia',
+        purpose: 'planning'
+    },
+    {
+        id: 'deepseek-ai/deepseek-r1-0528',
+        label: 'DeepSeek R1 0528 (NVIDIA NIM)',
+        provider: 'nvidia',
+        purpose: 'general'
+    },
+    {
+        id: 'qwen/qwq-32b',
+        label: 'QwQ 32B (NVIDIA NIM)',
+        provider: 'nvidia',
+        purpose: 'planning'
+    },
     {
         id: 'gpt-5-nano',
         label: 'GPT-5 Nano (Fast / Subagents)',
@@ -359,6 +423,10 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
         return new OpenAICodexProvider({ apiKey: runtime.apiKey, ...providerOverrides });
     } else if (providerStr === 'claude-code') {
         return new ClaudeCodeProvider({ apiKey: runtime.apiKey, ...providerOverrides });
+    } else if (providerStr === 'grok-oauth') {
+        return new GrokOAuthProvider({ apiKey: runtime.apiKey, ...providerOverrides });
+    } else if (providerStr === 'nvidia') {
+        return new NvidiaProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
     }
     throw new Error(`Unknown provider: ${providerStr}`);
 }

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

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const path = require('path');
+const OpenAI = require('openai');
+const { GrokProvider } = require('./grok');
+
+const GROK_OAUTH_BASE_URL = 'https://api.x.ai/v1';
+const GROK_OAUTH_CLIENT_ID = 'b1a00492-073a-47ea-816f-4c329264a828';
+const GROK_OAUTH_TOKEN_URL = 'https://auth.x.ai/oauth2/token';
+const GROK_OAUTH_SCOPES = 'openid profile email offline_access grok-cli:access api:access';
+
+function normalizeExpiresAt(data) {
+  if (typeof data.expires_at === 'number' && Number.isFinite(data.expires_at)) {
+    return data.expires_at > 10_000_000_000 ? data.expires_at : data.expires_at * 1000;
+  }
+  if (typeof data.expires_in === 'number' && Number.isFinite(data.expires_in)) {
+    return Date.now() + (data.expires_in * 1000);
+  }
+  return null;
+}
+
+function persistEnvValue(key, value) {
+  if (!value) return;
+  try {
+    const { ENV_FILE } = require('../../../../runtime/paths');
+    const safeKey = String(key).replace(/[\r\n]/g, '');
+    const safeValue = String(value).replace(/[\r\n]/g, '');
+    const raw = fs.existsSync(ENV_FILE) ? fs.readFileSync(ENV_FILE, 'utf8') : '';
+    const lines = raw ? raw.split('\n') : [];
+    let replaced = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith(`${safeKey}=`)) {
+        lines[i] = `${safeKey}=${safeValue}`;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced) lines.push(`${safeKey}=${safeValue}`);
+    const output = lines.filter((_, idx, arr) => idx !== arr.length - 1 || arr[idx] !== '').join('\n') + '\n';
+    fs.mkdirSync(path.dirname(ENV_FILE), { recursive: true });
+    fs.writeFileSync(ENV_FILE, output, { mode: 0o600 });
+  } catch { }
+}
+
+async function refreshGrokOAuthAccessToken(refreshToken, fetchImpl = fetch) {
+  if (!refreshToken) return null;
+  const response = await fetchImpl(GROK_OAUTH_TOKEN_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'Accept': 'application/json',
+    },
+    body: new URLSearchParams({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: GROK_OAUTH_CLIENT_ID,
+    }),
+  });
+
+  const text = await response.text();
+  let data = {};
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    data = {};
+  }
+
+  if (!response.ok) {
+    if (data?.error === 'invalid_grant') {
+      throw new Error('Grok OAuth refresh token is invalid or expired. Re-run `neoagent login grok-oauth` to re-authenticate.');
+    }
+    const detail = data?.error_description || data?.error || text || 'Unknown error';
+    throw new Error(`Grok OAuth refresh failed: HTTP ${response.status} ${detail}`);
+  }
+  if (!data.access_token) {
+    throw new Error('Grok OAuth refresh succeeded but no access_token was returned.');
+  }
+
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token || refreshToken,
+    expires: normalizeExpiresAt(data),
+  };
+}
+
+class GrokOAuthProvider extends GrokProvider {
+  constructor(config = {}) {
+    const authToken = config.apiKey || process.env.GROK_OAUTH_ACCESS_TOKEN;
+    super({
+      ...config,
+      apiKey: authToken,
+      baseUrl: GROK_OAUTH_BASE_URL,
+    });
+    this.name = 'grok-oauth';
+    this.models = ['grok-4', 'grok-4-mini'];
+
+    if (!authToken) {
+      console.warn('[GrokOAuth] No access token. Run `neoagent login grok-oauth` to authenticate.');
+    }
+
+    this.authToken = authToken || null;
+    this.refreshToken = config.refreshToken || process.env.GROK_OAUTH_REFRESH_TOKEN || null;
+    this.fetchImpl = config.fetch || fetch;
+  }
+
+  async refreshClient() {
+    const refreshed = await refreshGrokOAuthAccessToken(this.refreshToken, this.fetchImpl);
+    if (!refreshed?.access) return false;
+    this.authToken = refreshed.access;
+    this.refreshToken = refreshed.refresh || this.refreshToken;
+    process.env.GROK_OAUTH_ACCESS_TOKEN = this.authToken;
+    persistEnvValue('GROK_OAUTH_ACCESS_TOKEN', this.authToken);
+    if (this.refreshToken) {
+      process.env.GROK_OAUTH_REFRESH_TOKEN = this.refreshToken;
+      persistEnvValue('GROK_OAUTH_REFRESH_TOKEN', this.refreshToken);
+    }
+    this.client = new OpenAI({ apiKey: this.authToken, baseURL: GROK_OAUTH_BASE_URL });
+    return true;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    try {
+      return await super.chat(messages, tools, options);
+    } catch (err) {
+      if (err?.status !== 401 || !this.refreshToken) throw err;
+      await this.refreshClient();
+      return await super.chat(messages, tools, options);
+    }
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    try {
+      yield* super.stream(messages, tools, options);
+    } catch (err) {
+      if (err?.status !== 401 || !this.refreshToken) throw err;
+      await this.refreshClient();
+      yield* super.stream(messages, tools, options);
+    }
+  }
+}
+
+module.exports = { GrokOAuthProvider, refreshGrokOAuthAccessToken, GROK_OAUTH_SCOPES, GROK_OAUTH_CLIENT_ID };

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

@@ -0,0 +1,165 @@
+const OpenAI = require('openai');
+const { BaseProvider } = require('./base');
+
+const NVIDIA_BASE_URL = 'https://integrate.api.nvidia.com/v1';
+
+// Context windows per model (tokens)
+const CONTEXT_WINDOWS = {
+  'nvidia/nemotron-3-super-120b-a12b': 262144,
+  'moonshotai/kimi-k2.5':             262144,
+  'minimaxai/minimax-m2.5':           196608,
+  'z-ai/glm5':                        202752,
+  'meta/llama-4-maverick-17b-128e-instruct': 1048576,
+  'meta/llama-4-scout-17b-16e-instruct':     1048576,
+  'deepseek-ai/deepseek-r1-0528':     163840,
+  'qwen/qwq-32b':                     131072,
+};
+
+// Reasoning models: no temperature, no top_p
+const REASONING_MODELS = new Set([
+  'deepseek-ai/deepseek-r1-0528',
+  'qwen/qwq-32b',
+]);
+
+class NvidiaProvider extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'nvidia';
+    this.models = Object.keys(CONTEXT_WINDOWS);
+    this.client = new OpenAI({
+      apiKey: config.apiKey || process.env.NVIDIA_API_KEY,
+      baseURL: config.baseUrl || NVIDIA_BASE_URL,
+    });
+  }
+
+  getContextWindow(model) {
+    return CONTEXT_WINDOWS[model] ?? 131072;
+  }
+
+  _isReasoningModel(model) {
+    return REASONING_MODELS.has(model);
+  }
+
+  _buildParams(model, messages, tools, options) {
+    const params = {
+      model,
+      messages,
+      max_tokens: options.maxTokens || 8192,
+    };
+
+    if (!this._isReasoningModel(model)) {
+      params.temperature = options.temperature ?? 0.6;
+    }
+
+    if (tools && tools.length > 0) {
+      params.tools = this.formatTools(tools);
+      params.tool_choice = 'auto';
+    }
+
+    return params;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.getDefaultModel();
+    const params = this._buildParams(model, messages, tools, options);
+    let response;
+    try {
+      response = await this.client.chat.completions.create(params);
+    } catch (err) {
+      throw new Error(`NVIDIA NIM request failed: ${err?.message || String(err)}`);
+    }
+    return this._normalizeResponse(response);
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || this.getDefaultModel();
+    const params = {
+      ...this._buildParams(model, messages, tools, options),
+      stream: true,
+      stream_options: { include_usage: true },
+    };
+
+    let stream;
+    try {
+      stream = await this.client.chat.completions.create(params);
+    } catch (err) {
+      throw new Error(`NVIDIA NIM request failed: ${err?.message || String(err)}`);
+    }
+
+    let toolCalls = [];
+    let content = '';
+    let finalUsage = null;
+
+    for await (const chunk of stream) {
+      if (chunk.usage && (!chunk.choices || chunk.choices.length === 0)) {
+        finalUsage = this._normalizeUsage(chunk.usage);
+        continue;
+      }
+
+      const delta = chunk.choices?.[0]?.delta;
+      if (!delta) continue;
+
+      if (delta.content) {
+        content += delta.content;
+        yield { type: 'content', content: delta.content };
+      }
+
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (!toolCalls[tc.index]) {
+            toolCalls[tc.index] = {
+              id: tc.id || '',
+              type: 'function',
+              function: { name: tc.function?.name || '', arguments: '' },
+            };
+          }
+          if (tc.id) toolCalls[tc.index].id = tc.id;
+          if (tc.function?.name) toolCalls[tc.index].function.name = tc.function.name;
+          if (tc.function?.arguments) toolCalls[tc.index].function.arguments += tc.function.arguments;
+        }
+      }
+
+      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 };
+        return;
+      }
+      if (finishReason === 'stop') {
+        yield { type: 'done', content, usage: this._normalizeUsage(chunk.usage) || finalUsage };
+        return;
+      }
+    }
+
+    if (toolCalls.length > 0) {
+      yield { type: 'tool_calls', toolCalls, content, usage: finalUsage };
+    } else {
+      yield { type: 'done', content, usage: finalUsage };
+    }
+  }
+
+  _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 };