fix: nvidia provider chat

desktop/src/lib/tuiConversation.ts

@@ -1,8 +1,9 @@
 /**
  * TUI-style conversation module for desktop.
  *
- * Reuses TUI's approach of directly calling provider APIs via HTTP,
- * without going through the cc-haha sidecar or CLI subprocess.
+ * All requests go through the sidecar proxy (/api/cli-proxy) to avoid
+ * browser CORS restrictions. The sidecar reads ~/.claude.json for auth
+ * and proxies to provider APIs server-side.
  *
  * Supports all provider types:
  *  - Anthropic protocol: firstParty, openrouter, openai, local
@@ -12,6 +13,7 @@
  */
 
 import { getTuiConfig } from '../api/config'
+import { getBaseUrl } from '../api/client'
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -151,18 +153,24 @@ async function* streamOpenAI(
     stream: true,
   }
 
+  // Proxy through sidecar to avoid browser CORS
+  const proxyUrl = `${getBaseUrl()}/api/cli-proxy/chat/completions`
+
   let res: Response
   try {
-    res = await fetch(`${config.baseUrl.replace(/\/$/, '')}/chat/completions`, {
+    res = await fetch(proxyUrl, {
       method: 'POST',
-      headers: openaiHeaders(config.apiKey),
+      headers: {
+        'Content-Type': 'application/json',
+        // API key is read by sidecar from ~/.claude.json
+      },
       body: JSON.stringify(body),
       signal,
     })
   } catch (err) {
     const name = err instanceof TypeError ? err.name : ''
     const msg = err instanceof Error ? err.message : String(err)
-    console.error('[tuiConversation] OpenAI fetch failed:', { name, message: msg, url: config.baseUrl, model: config.model })
+    console.error('[tuiConversation] OpenAI fetch failed:', { name, message: msg, url: proxyUrl, model: config.model })
     yield { type: 'error', message: `Network error: ${msg}${name ? ` (${name})` : ''}` }
     yield { type: 'done' }
     return
@@ -184,7 +192,6 @@ async function* streamOpenAI(
   const decoder = new TextDecoder()
   const reader = res.body.getReader()
   let buffer = ''
-  let hasReceivedContent = false
   const IDLE_TIMEOUT_MS = 3000
 
   yield { type: 'content_block_start', index: 0, blockType: 'text' }
@@ -192,9 +199,6 @@ async function* streamOpenAI(
   while (true) {
     if (signal?.aborted) break
 
-    // Race between read and idle timeout.  Some local providers (Ollama, LM Studio,
-    // etc.) never send [DONE] or close the SSE connection after the response is
-    // complete.  The timeout lets us detect this and finish cleanly.
     const readPromise = reader.read()
     const timeoutPromise = new Promise<{ done: true; value: undefined }>((resolve) =>
       setTimeout(() => resolve({ done: true, value: undefined }), IDLE_TIMEOUT_MS),
@@ -272,18 +276,21 @@ export async function* sendMessage(
     }
     if (options?.system) body.system = options.system
 
+    // Proxy through sidecar to avoid browser CORS
+    const proxyUrl = `${getBaseUrl()}/api/cli-proxy/messages`
+
     let res: Response
     try {
-      res = await fetch(`${config.baseUrl.replace(/\/$/, '')}/messages`, {
+      res = await fetch(proxyUrl, {
         method: 'POST',
-        headers: anthropicHeaders(config.apiKey),
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
         signal: options?.signal,
       })
     } catch (err) {
       const name = err instanceof TypeError ? err.name : ''
       const msg = err instanceof Error ? err.message : String(err)
-      console.error('[tuiConversation] Anthropic fetch failed:', { name, message: msg, url: config.baseUrl, model: config.model })
+      console.error('[tuiConversation] Anthropic fetch failed:', { name, message: msg, url: proxyUrl, model: config.model })
       yield { type: 'error', message: `Network error: ${msg}${name ? ` (${name})` : ''}` }
       yield { type: 'done' }
       return

src/server/api/cli-proxy.ts

@@ -0,0 +1,240 @@
+/**
+ * CLI Proxy API — proxies chat requests for desktop WebView.
+ *
+ * Desktop WebView cannot call provider APIs directly due to CORS restrictions.
+ * This endpoint reads auth config from ~/.claude.json and proxies the request
+ * server-side (no CORS).
+ *
+ * POST /api/cli-proxy/messages — Anthropic Messages API (streaming/non-streaming)
+ * POST /api/cli-proxy/chat/completions — OpenAI Chat Completions (streaming/non-streaming)
+ */
+
+import { readCliAuthProvider } from './models.js'
+
+type ProviderClientConfig = {
+  baseUrl: string
+  apiKey: string
+  model: string
+  protocol: 'anthropic' | 'openai'
+}
+
+// Map authProvider to API config
+async function getCliProviderConfig(): Promise<ProviderClientConfig | null> {
+  const config = await readCliAuthProvider()
+  const authProvider = config?.authProvider
+
+  switch (authProvider) {
+    case 'openrouter': {
+      const apiKey = config?.openRouterApiKey as string | undefined
+      if (!apiKey) return null
+      const model = (config?.openRouterModel as string) || 'anthropic/claude-sonnet-4-6'
+      return {
+        baseUrl: (config?.openRouterBaseUrl as string) || 'https://openrouter.ai/api/v1',
+        apiKey,
+        model,
+        protocol: 'anthropic',
+      }
+    }
+
+    case 'nvidia': {
+      const apiKey = config?.nvidiaApiKey as string | undefined
+      if (!apiKey) return null
+      const model = (config?.nvidiaModel as string) || 'nvidia/llama-3.1-nemotron-70b-instruct'
+      return {
+        baseUrl: (config?.nvidiaBaseUrl as string) || 'https://integrate.api.nvidia.com/v1',
+        apiKey,
+        model,
+        protocol: 'openai',
+      }
+    }
+
+    case 'opencode': {
+      const apiKey = (config?.openCodeApiKey as string) || 'public'
+      const model = (config?.openCodeModelName as string) || 'big-pickle'
+      return {
+        baseUrl: 'https://opencode.ai/zen/v1',
+        apiKey,
+        model,
+        protocol: 'openai',
+      }
+    }
+
+    case 'openai': {
+      const apiKey = (config?.openAiApiKey as string) || (config?.openAiAccessToken as string)
+      if (!apiKey) return null
+      const model = (config?.openAiModel as string) || 'gpt-5.4-codex'
+      return {
+        baseUrl: (config?.openAiBaseUrl as string) || 'https://api.openai.com/v1',
+        apiKey,
+        model,
+        protocol: 'openai',
+      }
+    }
+
+    case 'local': {
+      const baseUrl = config?.localBaseUrl as string
+      if (!baseUrl) return null
+      const model = (config?.localModelName as string) || 'local-model'
+      return {
+        baseUrl,
+        apiKey: 'local-model',
+        model,
+        protocol: 'openai',
+      }
+    }
+
+    case 'anthropic': {
+      const apiKey = config?.anthropicApiKey as string | undefined
+      if (!apiKey) return null
+      const model = (config?.anthropicModel as string) || 'claude-sonnet-4-6'
+      return {
+        baseUrl: (config?.anthropicBaseUrl as string) || 'https://api.anthropic.com/v1',
+        apiKey,
+        model,
+        protocol: 'anthropic',
+      }
+    }
+
+    default:
+      return null
+  }
+}
+
+export async function handleCliProxyApi(
+  req: Request,
+  url: URL,
+  segments: string[],
+): Promise<Response> {
+  const resource = segments[2] // 'messages' | 'chat' | ...
+
+  if (req.method !== 'POST') {
+    return Response.json({ error: 'Method not allowed' }, { status: 405 })
+  }
+
+  const providerConfig = await getCliProviderConfig()
+  if (!providerConfig) {
+    return Response.json(
+      { type: 'error', error: { type: 'authentication_error', message: 'No CLI auth configured. Run /login first.' } },
+      { status: 401 },
+    )
+  }
+
+  if (resource === 'messages') {
+    // Anthropic Messages API
+    return handleAnthropicMessages(req, providerConfig)
+  }
+
+  if (resource === 'chat' && segments[3] === 'completions') {
+    // OpenAI Chat Completions API
+    return handleOpenAiChat(req, providerConfig)
+  }
+
+  return Response.json({ error: 'Not found' }, { status: 404 })
+}
+
+async function handleAnthropicMessages(incomingReq: Request, cfg: ProviderClientConfig): Promise<Response> {
+  let body: Record<string, unknown>
+  try {
+    body = (await incomingReq.json()) as Record<string, unknown>
+  } catch {
+    return Response.json({ type: 'error', error: { type: 'invalid_request_error', message: 'Invalid JSON' } }, { status: 400 })
+  }
+
+  // Override model from config (desktop may send a different one)
+  const model = (body.model as string) || cfg.model
+
+  const url = `${cfg.baseUrl.replace(/\/$/, '')}/messages`
+  const isStream = body.stream === true
+
+  try {
+    const upstream = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': cfg.apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({ ...body, model }),
+      signal: AbortSignal.timeout(120_000),
+    })
+
+    if (!upstream.ok) {
+      const errText = await upstream.text().catch(() => '')
+      return Response.json(
+        { type: 'error', error: { type: 'api_error', message: `Upstream ${upstream.status}: ${errText.slice(0, 500)}` } },
+        { status: upstream.status },
+      )
+    }
+
+    if (isStream && upstream.body) {
+      return new Response(upstream.body, {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+        },
+      })
+    }
+
+    const data = await upstream.json()
+    return Response.json(data)
+  } catch (err) {
+    return Response.json(
+      { type: 'error', error: { type: 'api_error', message: err instanceof Error ? err.message : String(err) } },
+      { status: 502 },
+    )
+  }
+}
+
+async function handleOpenAiChat(incomingReq: Request, cfg: ProviderClientConfig): Promise<Response> {
+  let body: Record<string, unknown>
+  try {
+    body = (await incomingReq.json()) as Record<string, unknown>
+  } catch {
+    return Response.json({ error: 'Invalid JSON' }, { status: 400 })
+  }
+
+  const model = (body.model as string) || cfg.model
+  const url = `${cfg.baseUrl.replace(/\/$/, '')}/chat/completions`
+  const isStream = body.stream === true
+
+  try {
+    const upstream = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${cfg.apiKey}`,
+      },
+      body: JSON.stringify({ ...body, model }),
+      signal: AbortSignal.timeout(120_000),
+    })
+
+    if (!upstream.ok) {
+      const errText = await upstream.text().catch(() => '')
+      return Response.json(
+        { error: `Upstream ${upstream.status}: ${errText.slice(0, 500)}` },
+        { status: upstream.status },
+      )
+    }
+
+    if (isStream && upstream.body) {
+      return new Response(upstream.body, {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive',
+        },
+      })
+    }
+
+    const data = await upstream.json()
+    return Response.json(data)
+  } catch (err) {
+    return Response.json(
+      { error: err instanceof Error ? err.message : String(err) },
+      { status: 502 },
+    )
+  }
+}

src/server/api/models.ts

@@ -316,7 +316,7 @@ export async function handleModelsApi(
 
 // ─── Handlers ─────────────────────────────────────────────────────────────────
 
-async function readCliAuthProvider(): Promise<{
+export async function readCliAuthProvider(): Promise<{
   authProvider?: 'anthropic' | 'openai' | 'openrouter' | 'local' | 'opencode' | 'nvidia'
 } | null> {
   try {

src/server/router.ts

@@ -28,6 +28,7 @@ import { handleOpenTargetsApi } from './api/open-targets.js'
 import { handleMemoryApi } from './api/memory.js'
 import { handleDesktopUiApi } from './api/desktop-ui.js'
 import { handleCliAuthApi } from './api/cli-auth.js'
+import { handleCliProxyApi } from './api/cli-proxy.js'
 
 export async function handleApiRequest(req: Request, url: URL): Promise<Response> {
   const path = url.pathname
@@ -123,6 +124,9 @@ export async function handleApiRequest(req: Request, url: URL): Promise<Response
     case 'cli-auth':
       return handleCliAuthApi(req, url, segments)
 
+    case 'cli-proxy':
+      return handleCliProxyApi(req, url, segments)
+
     case 'filesystem':
       return handleFilesystemRoute(url.pathname, url)