neoagent 2.4.1-beta.12 → 2.4.1-beta.13

package/server/services/ai/models.js

@@ -7,6 +7,7 @@ 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,
@@ -62,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)',
@@ -374,6 +425,8 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
         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/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 };

package/server/services/ai/settings.js

@@ -59,6 +59,16 @@ const AI_PROVIDER_DEFINITIONS = Object.freeze({
     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/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);