feat: add nvidia provider

src/commands/login/login.tsx

@@ -25,6 +25,7 @@ import { OpenAILoginFlow } from '../../components/OpenAILoginFlow.js'
 import { OpenRouterLoginFlow } from '../../components/OpenRouterLoginFlow.js'
 import { LocalLoginFlow } from '../../components/LocalLoginFlow.js'
 import { OpenCodeLoginFlow } from '../../components/OpenCodeLoginFlow.js'
+import { NvidiaLoginFlow } from '../../components/NvidiaLoginFlow.js'
 
 import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
 
@@ -48,7 +49,7 @@ import {
 import { resetUserCache } from '../../utils/user.js';
 
 // TODO
-type AuthProviderChoice = 'anthropic' | 'openai' | 'openrouter' | 'local' | 'opencode'
+type AuthProviderChoice = 'anthropic' | 'openai' | 'openrouter' | 'local' | 'opencode' | 'nvidia'
 
 /* 第一层: 入口函数 call()
  * CLI 执行 /login 真正被调用的函数
@@ -88,18 +89,26 @@ export async function call(
             void checkAndDisableAutoModeIfNeeded(appState.toolPermissionContext, context.setAppState, appState.fastMode);
           }
 
-          // For OpenCode provider, pre-fetch models so /model shows them immediately
+          // Pre-fetch models for providers that support dynamic model listing
           const { getAPIProvider } = await import('../../utils/model/providers.js')
-          if (getAPIProvider() === 'opencode') {
+          const provider = getAPIProvider()
+          if (provider === 'opencode') {
             const { fetchOpencodeModels } = await import('../../services/api/opencodeClient.js')
             await fetchOpencodeModels()
+          } else if (provider === 'nvidia') {
+            const { fetchNvidiaModels } = await import('../../services/api/nvidiaClient.js')
+            await fetchNvidiaModels()
           }
 
+          // Clear cached model strings so they re-initialize with the new provider
+          const { clearModelStrings } = await import('../../utils/model/modelStrings.js')
+          clearModelStrings()
+
           // Increment authVersion to trigger re-fetching of auth-dependent data
           context.setAppState(prev => ({
             ...prev,
             authVersion: prev.authVersion + 1,
-            mainLoopModel: 'big-pickle',
+            mainLoopModel: provider === 'nvidia' ? null : 'big-pickle',
             mainLoopModelForSession: null,
           }));
         }
@@ -187,6 +196,18 @@ export function Login(props: {
         ),
         value: 'local',
       },
+      {
+        label: (
+          <Text>
+            NVIDIA{' '}
+            <Text dimColor={true}>
+              NVIDIA NIM API key from build.nvidia.com
+            </Text>
+            {'\n'}
+          </Text>
+        ),
+        value: 'nvidia',
+      },
     ],
     [],
   )
@@ -235,6 +256,11 @@ export function Login(props: {
         onDone={onFlowDone}
         startingMessage="Configure local model server (Ollama, LM Studio, vLLM, etc.)."
       />
+    ) : selectedProvider === 'nvidia' ? (
+      <NvidiaLoginFlow
+        onDone={onFlowDone}
+        startingMessage="Better-Clawd can use NVIDIA with your NVIDIA API key."
+      />
     ) : (
       <ConsoleOAuthFlow
         onDone={onFlowDone}

src/components/NvidiaLoginFlow.tsx

@@ -0,0 +1,106 @@
+import * as React from 'react'
+import { useState, useEffect } from 'react'
+import { Box, Text } from '../ink.js'
+import { saveNvidiaApiKey, getNvidiaApiKey } from '../utils/auth.js'
+import { Spinner } from './Spinner.js'
+import TextInput from './TextInput.js'
+
+type NvidiaLoginFlowProps = {
+  onDone: () => void
+  startingMessage?: string
+}
+
+export function NvidiaLoginFlow({
+  onDone,
+  startingMessage,
+}: NvidiaLoginFlowProps): React.ReactNode {
+  const [isBusy, setIsBusy] = useState(false)
+  const [status, setStatus] = useState<string | null>(null)
+  const [inputValue, setInputValue] = useState('')
+  const [cursorOffset, setCursorOffset] = useState(0)
+  const [existingKey, setExistingKey] = useState<string | null>(null)
+
+  useEffect(() => {
+    const key = getNvidiaApiKey()
+    if (key) {
+      setExistingKey(key)
+    }
+  }, [])
+
+  async function handleSubmit(value?: string): Promise<void> {
+    if (!value && !existingKey) {
+      setStatus('Please enter an API key or press Esc to cancel')
+      return
+    }
+
+    const trimmed = value?.trim() || ''
+    const keyToSave = trimmed || existingKey || ''
+
+    if (!keyToSave) {
+      setStatus('Please enter an API key or press Esc to cancel')
+      return
+    }
+
+    setIsBusy(true)
+    setStatus(null)
+    try {
+      await saveNvidiaApiKey(keyToSave)
+      onDone()
+    } catch (error) {
+      setStatus(error instanceof Error ? error.message : String(error))
+    } finally {
+      setIsBusy(false)
+    }
+  }
+
+  if (isBusy) {
+    return (
+      <Box flexDirection="column" gap={1}>
+        <Box>
+          <Spinner />
+          <Text>Configuring NVIDIA login for Better-Clawd...</Text>
+        </Box>
+        <Text dimColor={true}>
+          NVIDIA GPU-accelerated models are accessed via the NVIDIA API
+          catalog at `https://integrate.api.nvidia.com/v1`.
+        </Text>
+      </Box>
+    )
+  }
+
+  return (
+    <Box flexDirection="column" gap={1}>
+      <Text>
+        {startingMessage ??
+          'Better-Clawd can use NVIDIA with your NVIDIA API key.'}
+      </Text>
+      <Text dimColor={true}>
+        Paste your NVIDIA API key to use models from the NVIDIA API catalog
+        via the OpenAI-compatible endpoint.
+      </Text>
+      <Box>
+        <Text>Paste your NVIDIA API key:</Text>
+        <TextInput
+          value={inputValue}
+          onChange={setInputValue}
+          onSubmit={handleSubmit}
+          onExit={() => {
+            setInputValue('')
+            setCursorOffset(0)
+          }}
+          cursorOffset={cursorOffset}
+          onChangeCursorOffset={setCursorOffset}
+          columns={72}
+          mask="*"
+          focus={true}
+          placeholder={existingKey || undefined}
+        />
+      </Box>
+      {status ? <Text color="error">{status}</Text> : null}
+      <Text dimColor={true}>
+        Press <Text bold={true}>Enter</Text> to save, or <Text bold={true}>Esc</Text>{' '}
+        to cancel.
+      </Text>
+    </Box>
+  )
+}

src/hooks/useApiKeyVerification.ts

@@ -62,13 +62,23 @@ export function useApiKeyVerification(): ApiKeyVerificationResult {
       }
       return 'missing'
     }
-    
+
     // Check OpenCode Zen authentication
     // OpenCode Zen uses free models by default, no API key required
     if (authProvider === 'opencode') {
       return 'valid'
     }
-    
+
+    // Check NVIDIA authentication
+    if (authProvider === 'nvidia') {
+      const config = getGlobalConfig()
+      const hasApiKey = !!config.nvidiaApiKey
+      if (hasApiKey) {
+        return 'valid'
+      }
+      return 'missing'
+    }
+
     // Anthropic authentication
     if (!isAnthropicAuthEnabled() || isClaudeAISubscriber()) {
       return 'valid'
@@ -142,7 +152,20 @@ export function useApiKeyVerification(): ApiKeyVerificationResult {
         setStatus('valid')
         return
       }
-      
+
+      // Check NVIDIA authentication
+      if (authProvider === 'nvidia') {
+        const { getGlobalConfig: getConfig } = await import('../utils/config.js')
+        const freshConfig = getConfig()
+        const hasApiKey = !!freshConfig.nvidiaApiKey
+        if (hasApiKey) {
+          setStatus('valid')
+        } else {
+          setStatus('missing')
+        }
+        return
+      }
+
       // Anthropic authentication
       if (!isAnthropicAuthEnabled() || isClaudeAISubscriber()) {
         setStatus('valid')
@@ -227,7 +250,19 @@ export function useApiKeyVerification(): ApiKeyVerificationResult {
       setStatus('valid')
       return
     }
-    
+
+    // Check NVIDIA authentication
+    if (authProvider === 'nvidia') {
+      const config = getGlobalConfig()
+      const hasApiKey = !!config.nvidiaApiKey
+      if (hasApiKey) {
+        setStatus('valid')
+      } else {
+        setStatus('missing')
+      }
+      return
+    }
+
     // Anthropic authentication
     if (!isAnthropicAuthEnabled() || isClaudeAISubscriber()) {
       setStatus('valid')

src/server/config/providerPresets.json

@@ -210,6 +210,25 @@
       "ANTHROPIC_AUTH_TOKEN": "ollama"
     }
   },
+  {
+    "id": "nvidia",
+    "name": "NVIDIA NIM",
+    "baseUrl": "https://integrate.api.nvidia.com/v1",
+    "apiFormat": "openai_chat",
+    "defaultModels": {
+      "main": "nvidia/llama-3.1-nemotron-70b-instruct",
+      "haiku": "nvidia/llama-3.1-nemotron-70b-instruct",
+      "sonnet": "nvidia/llama-3.1-nemotron-70b-instruct",
+      "opus": "nvidia/llama-3.1-nemotron-70b-instruct"
+    },
+    "needsApiKey": true,
+    "websiteUrl": "https://build.nvidia.com",
+    "apiKeyUrl": "https://build.nvidia.com",
+    "authStrategy": "api_key",
+    "defaultEnv": {
+      "NVIDIA_BASE_URL": "https://integrate.api.nvidia.com/v1"
+    }
+  },
   {
     "id": "custom",
     "name": "Custom",

src/services/api/client.ts

@@ -26,6 +26,7 @@ import {
 } from 'src/utils/model/providers.js'
 import { getProxyFetchOptions } from 'src/utils/proxy.js'
 import { createOpenCodeFetchOverride, fetchOpencodeModels } from './opencodeClient.js'
+import { createNvidiaFetchOverride } from './nvidiaClient.js'
 import {
   getIsNonInteractiveSession,
   getSessionId,
@@ -155,7 +156,13 @@ export async function getAnthropicClient({
     opencodeFetchOverride = createOpenCodeFetchOverride(resolvedModel)
   }
 
-  const resolvedFetch = buildFetch(fetchOverride || opencodeFetchOverride, source)
+  // For NVIDIA provider, use custom fetch to convert Anthropic format to OpenAI-compatible format
+  let nvidiaFetchOverride: ClientOptions['fetch'] | undefined
+  if (provider === 'nvidia') {
+    nvidiaFetchOverride = createNvidiaFetchOverride()
+  }
+
+  const resolvedFetch = buildFetch(fetchOverride || opencodeFetchOverride || nvidiaFetchOverride, source)
 
   const ARGS = {
     defaultHeaders,
@@ -366,6 +373,11 @@ export async function getAnthropicClient({
     clientConfig.apiKey = 'opencode-zen'
   }
 
+  // Handle NVIDIA - uses custom fetch override to convert Anthropic format to OpenAI format
+  if (provider === 'nvidia') {
+    clientConfig.apiKey = 'nvidia-nim'
+  }
+
   return new Anthropic(clientConfig)
 }
 
@@ -375,8 +387,8 @@ async function configureApiKeyHeaders(
 ): Promise<void> {
   const provider = getAPIProvider()
   
-  // Skip for OpenRouter, OpenAI, Local, and OpenCode - they use apiKey parameter instead
-  if (provider === 'openrouter' || provider === 'openai' || provider === 'local' || provider === 'opencode') {
+  // Skip for OpenRouter, OpenAI, Local, OpenCode, and NVIDIA - they use apiKey parameter instead
+  if (provider === 'openrouter' || provider === 'openai' || provider === 'local' || provider === 'opencode' || provider === 'nvidia') {
     return
   }
 

src/services/api/nvidiaClient.ts

@@ -0,0 +1,246 @@
+import { getNvidiaApiKey } from '../../utils/auth.js'
+import { getNvidiaBaseUrl } from '../../utils/model/providers.js'
+import {
+  convertAnthropicMessagesToOpenAI,
+  convertAnthropicToolsToOpenAI,
+  convertOpenAIStreamToAnthropic,
+  type AnthropicMessage,
+} from './copilotClient.js'
+
+/**
+ * NVIDIA NIM API uses the OpenAI-compatible `/v1/chat/completions` protocol.
+ * This fetch override intercepts Anthropic Messages API calls and translates
+ * them to the OpenAI format that NVIDIA expects.
+ */
+
+const NVIDIA_MODEL = process.env.NVIDIA_MODEL || 'nvidia/llama-3.1-nemotron-70b-instruct'
+
+function normalizeBaseUrl(url: string): string {
+  return url.replace(/\/$/, '')
+}
+
+function chatCompletionsUrl(base: string): string {
+  const b = normalizeBaseUrl(base)
+  if (b.endsWith('/v1')) {
+    return `${b}/chat/completions`
+  }
+  return `${b}/v1/chat/completions`
+}
+
+export function createNvidiaFetchOverride(): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
+  const baseUrl = getNvidiaBaseUrl()
+  const apiKey = getNvidiaApiKey()
+  const endpoint = chatCompletionsUrl(baseUrl)
+
+  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+    const url = input instanceof URL ? input.href : typeof input === 'string' ? input : input.url
+
+    // Only intercept Messages API calls
+    if (!url.includes('/messages') && !url.includes('/v1/')) {
+      return fetch(input, init)
+    }
+
+    // Stub out token counting and model listing
+    if (url.includes('/count_tokens') || url.includes('/models')) {
+      return new Response(JSON.stringify({ input_tokens: 0 }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    let anthropicBody: Record<string, unknown> = {}
+    if (init?.body) {
+      try {
+        anthropicBody = JSON.parse(
+          typeof init.body === 'string' ? init.body : new TextDecoder().decode(init.body as ArrayBuffer),
+        )
+      } catch {
+        return fetch(input, init)
+      }
+    }
+
+    const systemBlocks = anthropicBody.system as
+      | Array<{ type: string; text: string }>
+      | string
+      | undefined
+    let systemPrompt = ''
+    if (typeof systemBlocks === 'string') {
+      systemPrompt = systemBlocks
+    } else if (Array.isArray(systemBlocks)) {
+      systemPrompt = systemBlocks
+        .filter(b => b.type === 'text')
+        .map(b => b.text)
+        .join('\n\n')
+    }
+
+    const anthropicMessages = (anthropicBody.messages || []) as AnthropicMessage[]
+    const openaiMessages = convertAnthropicMessagesToOpenAI(anthropicMessages, systemPrompt)
+
+    const anthropicTools = (anthropicBody.tools || []) as Array<{
+      name: string
+      description?: string
+      input_schema?: Record<string, unknown>
+    }>
+    const openaiTools = anthropicTools.length > 0 ? convertAnthropicToolsToOpenAI(anthropicTools) : undefined
+
+    const isStreaming = anthropicBody.stream === true
+
+    // Use the model from the user's selection, falling back to the env var / default
+    const selectedModel = (anthropicBody.model as string) || NVIDIA_MODEL
+
+    const requestBody: Record<string, unknown> = {
+      model: selectedModel,
+      messages: openaiMessages,
+      stream: isStreaming,
+    }
+
+    if (anthropicBody.max_tokens) {
+      requestBody.max_tokens = anthropicBody.max_tokens
+    }
+
+    if (openaiTools && openaiTools.length > 0) {
+      requestBody.tools = openaiTools
+      requestBody.tool_choice = 'auto'
+    }
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'User-Agent': 'claude-code/2.1.88',
+      'HTTP-Referer': 'https://claude.ai/',
+      'X-Title': 'Better-Clawd',
+      'X-BILLING-INVOKE-ORIGIN': 'Better-Clawd',
+    }
+    if (apiKey) {
+      headers.Authorization = `Bearer ${apiKey}`
+    }
+
+    const nvidiaResponse = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestBody),
+      signal: init?.signal,
+    })
+
+    if (!nvidiaResponse.ok) {
+      return nvidiaResponse
+    }
+
+    if (!isStreaming) {
+      const data = (await nvidiaResponse.json()) as {
+        id: string
+        choices: Array<{
+          message: {
+            role: string
+            content: string | null
+            tool_calls?: Array<{
+              id: string
+              function: { name: string; arguments: string }
+            }>
+          }
+          finish_reason: string
+        }>
+        usage?: { prompt_tokens: number; completion_tokens: number }
+      }
+
+      const choice = data.choices[0]
+      const anthropicContent: Array<{
+        type: string
+        text?: string
+        id?: string
+        name?: string
+        input?: unknown
+      }> = []
+
+      if (choice?.message?.content) {
+        anthropicContent.push({ type: 'text', text: choice.message.content })
+      }
+
+      if (choice?.message?.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+          anthropicContent.push({
+            type: 'tool_use',
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments || '{}'),
+          })
+        }
+      }
+
+      const anthropicResponse = {
+        id: data.id || `msg_nvidia_${Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        content: anthropicContent,
+        model: selectedModel,
+        stop_reason: choice?.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn',
+        usage: {
+          input_tokens: data.usage?.prompt_tokens || 0,
+          output_tokens: data.usage?.completion_tokens || 0,
+        },
+      }
+
+      return new Response(JSON.stringify(anthropicResponse), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    }
+
+    // Streaming response
+    if (!nvidiaResponse.body) {
+      return nvidiaResponse
+    }
+
+    const transformStream = convertOpenAIStreamToAnthropic(nvidiaResponse.body, selectedModel)
+
+    return new Response(transformStream, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      },
+    })
+  }
+}
+
+let cachedNvidiaModels: string[] | null = null
+
+export function getCachedNvidiaModels(): string[] {
+  return cachedNvidiaModels || []
+}
+
+/**
+ * Fetch available models from the NVIDIA API catalog.
+ */
+export async function fetchNvidiaModels(apiKey?: string): Promise<string[]> {
+  const baseUrl = getNvidiaBaseUrl()
+  const key = apiKey || getNvidiaApiKey()
+  const normalizedBase = normalizeBaseUrl(baseUrl)
+  const modelsUrl = normalizedBase.endsWith('/v1')
+    ? `${normalizedBase}/models`
+    : `${normalizedBase}/v1/models`
+
+  const headers: Record<string, string> = {}
+  if (key) {
+    headers.Authorization = `Bearer ${key}`
+  }
+
+  try {
+    const res = await fetch(modelsUrl, { headers, signal: AbortSignal.timeout(20_000) })
+    if (!res.ok) {
+      cachedNvidiaModels = []
+      return []
+    }
+    const json = (await res.json()) as { data?: Array<{ id: string }> }
+    if (json.data && Array.isArray(json.data)) {
+      const modelIds = json.data.map((m: { id: string }) => m.id)
+      cachedNvidiaModels = modelIds
+      return modelIds
+    }
+    cachedNvidiaModels = []
+    return []
+  } catch {
+    cachedNvidiaModels = []
+    return []
+  }
+}

src/services/voice/doubaoSTT.ts

@@ -0,0 +1,34 @@
+// @generated stub from scan-missing-imports
+// 该文件自动生成，对应 ant-internal 的 feature() gated 模块。
+// 所有外部 build 的代码路径在 DCE 后都不会真的执行这里的代码，这只是
+// bun build resolver 的占位符。
+const __target = function noop() {}
+const __handler: ProxyHandler<any> = {
+  get(_t, prop) {
+    if (prop === '__esModule') return true
+    if (prop === 'default') return new Proxy(__target, __handler)
+    if (prop === Symbol.toPrimitive) return () => undefined
+    if (prop === Symbol.iterator) return function* () {}
+    if (prop === Symbol.asyncIterator) return async function* () {}
+    if (prop === 'then') return undefined
+    return new Proxy(__target, __handler)
+  },
+  apply() {
+    return new Proxy(__target, __handler)
+  },
+  construct() {
+    return new Proxy(__target, __handler)
+  },
+}
+const stub: any = new Proxy(__target, __handler)
+export default stub
+export const __stubMissing = true
+// 兼容常见的命名导出 —— 没列在这里的也会通过 default Proxy 兜底
+export const createCachedMCState = stub
+export const isCachedMicrocompactEnabled = stub
+export const isModelSupportedForCacheEditing = stub
+export const getCachedMCConfig = stub
+export const markToolsSentToAPI = stub
+export const resetCachedMCState = stub
+export const checkProtectedNamespace = stub
+export const getCoordinatorUserContext = stub

src/setup.ts

@@ -400,6 +400,9 @@ export async function setup(
   } else if (configuredAuthProvider === 'opencode') {
     const { fetchOpencodeModels } = await import('./services/api/opencodeClient.js')
     void fetchOpencodeModels()
+  } else if (configuredAuthProvider === 'nvidia') {
+    const { fetchNvidiaModels } = await import('./services/api/nvidiaClient.js')
+    void fetchNvidiaModels()
   }
 
   // If permission mode is set to bypass, verify we're in a safe environment

src/utils/auth.ts

@@ -307,7 +307,7 @@ export function getOpenRouterApiKeyWithSource(): {
     : { key: null, source: 'none' }
 }
 
-export function getConfiguredAuthProvider(): 'anthropic' | 'openrouter' | 'openai' | 'local' | 'opencode' | null {
+export function getConfiguredAuthProvider(): 'anthropic' | 'openrouter' | 'openai' | 'local' | 'opencode' | 'nvidia' | null {
   // First try to get from cache for performance
   const storedProvider = getGlobalConfig().authProvider
   if (storedProvider) {
@@ -319,13 +319,13 @@ export function getConfiguredAuthProvider(): 'anthropic' | 'openrouter' | 'opena
 }
 
 // Read authProvider directly from file to bypass cache
-export function getConfiguredAuthProviderFromFile(): 'anthropic' | 'openrouter' | 'openai' | 'local' | 'opencode' | null {
+export function getConfiguredAuthProviderFromFile(): 'anthropic' | 'openrouter' | 'openai' | 'local' | 'opencode' | 'nvidia' | null {
   try {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { readFileSync } = require('fs') as typeof import('fs')
     const raw = readFileSync(getGlobalClaudeFile(), 'utf8')
     const config = JSON.parse(raw) as {
-      authProvider?: 'anthropic' | 'openrouter' | 'openai' | 'local' | 'opencode'
+      authProvider?: 'anthropic' | 'openrouter' | 'openai' | 'local' | 'opencode' | 'nvidia'
     }
 
     if (config.authProvider) {
@@ -430,6 +430,36 @@ export async function saveOpenRouterApiKey(apiKey: string): Promise<void> {
   clearStoredProviderCache()
 }
 
+export function getNvidiaApiKey(): string | null {
+  if (process.env.NVIDIA_API_KEY) {
+    return process.env.NVIDIA_API_KEY
+  }
+
+  const config = getGlobalConfig()
+  return config.nvidiaApiKey || null
+}
+
+export async function saveNvidiaApiKey(apiKey: string): Promise<void> {
+  if (!apiKey || typeof apiKey !== 'string') {
+    throw new Error('Invalid API key: API key must be a non-empty string.')
+  }
+
+  const trimmedKey = apiKey.trim()
+
+  if (!trimmedKey) {
+    throw new Error('Invalid API key: API key cannot be empty or whitespace only.')
+  }
+
+  saveGlobalConfig(current => ({
+    ...current,
+    authProvider: 'nvidia',
+    nvidiaApiKey: trimmedKey,
+  }))
+  // Clear provider cache so it will be re-read on next access
+  const { clearStoredProviderCache } = await import('./model/providers.js')
+  clearStoredProviderCache()
+}
+
 export async function saveOpenCodeApiKey(apiKey: string, modelName?: string): Promise<void> {
   saveGlobalConfig(current => ({
     ...current,

src/utils/config.ts

@@ -187,7 +187,7 @@ export type GlobalConfig = {
   apiKeyHelper?: string
   
   // Authentication provider configuration
-  authProvider?: 'anthropic' | 'openai' | 'openrouter' | 'local' | 'opencode'
+  authProvider?: 'anthropic' | 'openai' | 'openrouter' | 'local' | 'opencode' | 'nvidia'
   
   // OpenRouter API key
   openRouterApiKey?: string
@@ -203,6 +203,9 @@ export type GlobalConfig = {
   // OpenCode Zen configuration
   openCodeApiKey?: string
   openCodeModelName?: string
+
+  // NVIDIA API key
+  nvidiaApiKey?: string
   
   projects?: Record<string, ProjectConfig>
   numStartups: number
@@ -663,6 +666,7 @@ export const GLOBAL_CONFIG_KEYS = [
   'openAiAccessToken',
   'localBaseUrl',
   'localModelName',
+  'nvidiaApiKey',
   'installMethod',
   'autoUpdates',
   'autoUpdatesProtectedForNative',

src/utils/model/model.ts

@@ -277,6 +277,11 @@ export function getDefaultMainLoopModelSetting(): ModelName | ModelAlias {
     return 'big-pickle'
   }
 
+  // Check if using NVIDIA provider
+  if (apiProvider === 'nvidia') {
+    return getModelStrings().sonnet46
+  }
+
   // Ants default to defaultModel from flag config, or Opus 1M if not configured
   if (process.env.USER_TYPE === 'ant') {
     return (

src/utils/model/modelOptions.ts

@@ -499,6 +499,33 @@ function getModelOptionsBase(fastMode = false): ModelOption[] {
     return [getDefaultOptionForUser(fastMode)]
   }
 
+  // NVIDIA API: Show dynamically fetched models from the NVIDIA API catalog
+  if (getAPIProvider() === 'nvidia') {
+    // Trigger background fetch of NVIDIA models (non-blocking)
+    // This will populate the cache for subsequent calls
+    void import('../../services/api/nvidiaClient.js').then(({ fetchNvidiaModels }) => {
+      fetchNvidiaModels()
+    })
+
+    const { getCachedNvidiaModels } = require('../../services/api/nvidiaClient.js') as {
+      getCachedNvidiaModels: () => string[]
+    }
+    const models = getCachedNvidiaModels()
+
+    if (models && models.length > 0) {
+      return [
+        getDefaultOptionForUser(fastMode),
+        ...models.map(m => ({
+          value: m,
+          label: m,
+          description: 'NVIDIA NIM model',
+        })),
+      ]
+    }
+
+    return [getDefaultOptionForUser(fastMode)]
+  }
+
   // OpenCode Zen: Fetch models dynamically from API
   // If no API key, show only free models
   // If API key is provided, show all models except free ones

src/utils/model/modelStrings.ts

@@ -50,6 +50,15 @@ function getBuiltinModelStrings(provider: APIProvider): ModelStrings {
     return out as ModelStrings
   }
 
+  if (provider === 'nvidia') {
+    const out = getBuiltinModelStrings('firstParty') as Record<string, string>
+    out.haiku45 = process.env.NVIDIA_HAIKU_MODEL || 'nvidia/llama-3.1-nemotron-70b-instruct'
+    out.sonnet45 = process.env.NVIDIA_SONNET_MODEL || 'nvidia/llama-3.1-nemotron-70b-instruct'
+    out.sonnet46 = process.env.NVIDIA_SONNET_MODEL || 'nvidia/llama-3.1-nemotron-70b-instruct'
+    out.opus46 = process.env.NVIDIA_OPUS_MODEL || 'nvidia/llama-3.1-nemotron-70b-instruct'
+    return out as ModelStrings
+  }
+
   const out = {} as ModelStrings
   for (const key of MODEL_KEYS) {
     out[key] = ALL_MODEL_CONFIGS[key][provider]
@@ -191,3 +200,12 @@ export async function ensureModelStringsInitialized(): Promise<void> {
   // For Bedrock, wait for the profile fetch
   await updateBedrockModelStrings()
 }
+
+/**
+ * Clear cached model strings so the next call to getModelStrings()
+ * re-initializes from the current provider. Call this after changing
+ * the auth provider (e.g., after /login).
+ */
+export function clearModelStrings(): void {
+  setModelStringsState(null as unknown as ModelStrings)
+}

src/utils/model/providers.ts

@@ -8,6 +8,7 @@ export type APIProvider =
   | 'openai'
   | 'local'
   | 'opencode'
+  | 'nvidia'
   | 'bedrock'
   | 'vertex'
   | 'foundry'
@@ -53,6 +54,9 @@ function getStoredProviderPreference(): APIProvider | null {
       case 'opencode':
         result = 'opencode'
         break
+      case 'nvidia':
+        result = config.nvidiaApiKey ? 'nvidia' : null
+        break
       case 'anthropic':
         result = 'firstParty'
         break
@@ -90,6 +94,8 @@ function getExplicitProviderOverride(): APIProvider | null {
       return 'local'
     case 'opencode':
       return 'opencode'
+    case 'nvidia':
+      return 'nvidia'
     case 'bedrock':
       return 'bedrock'
     case 'vertex':
@@ -126,6 +132,19 @@ export function isOpenRouterConfigured(): boolean {
   return getStoredProviderPreference() === 'openrouter'
 }
 
+export function isNvidiaConfigured(): boolean {
+  if (getExplicitProviderOverride() === 'nvidia' || Boolean(process.env.NVIDIA_API_KEY)) {
+    return true
+  }
+
+  // Check config file
+  return getStoredProviderPreference() === 'nvidia'
+}
+
+export function getNvidiaBaseUrl(): string {
+  return process.env.NVIDIA_BASE_URL ?? 'https://integrate.api.nvidia.com/v1'
+}
+
 export function isOpenAIConfigured(): boolean {
   if (
     getExplicitProviderOverride() === 'openai' ||
@@ -199,7 +218,9 @@ export function getAPIProvider(): APIProvider | null {
         ? 'foundry'
         : isOpencodeConfigured()
           ? 'opencode'
-          : isOpenAIConfigured()
+          : isNvidiaConfigured()
+            ? 'nvidia'
+            : isOpenAIConfigured()
             ? 'openai'
             : isOpenRouterConfigured()
               ? 'openrouter'
@@ -213,7 +234,7 @@ export function getAPIProviderForStatsig(): AnalyticsMetadata_I_VERIFIED_THIS_IS
 export function isAnthropicCompatibleProvider(
   provider: APIProvider = getAPIProvider(),
 ): boolean {
-  return provider !== 'openai' && provider !== 'opencode'
+  return provider !== 'openai' && provider !== 'opencode' && provider !== 'nvidia'
 }
 
 /**