fix: fetch active opencode model

src/components/OpenCodeLoginFlow.tsx

@@ -12,14 +12,11 @@ type OpenCodeLoginFlowProps = {
 
 type LoginMode = 'menu' | 'free_models' | 'api_key'
 
-const FREE_MODELS = [
-  { label: 'Big Pickle (推荐)', value: 'big-pickle', description: '旗舰模型，限时免费，适合复杂任务' },
-  { label: 'GPT 5 Nano', value: 'gpt-5-nano', description: '永久免费，轻量快速，隐私安全' },
-  { label: 'MiniMax M2.5 Free', value: 'minimax-m2.5-free', description: '限时免费，编码推理强' },
-  { label: 'GLM 4.7 Free', value: 'glm-4.7-free', description: '限时免费，智谱开源模型' },
-  { label: 'Kimi K2.5 Free', value: 'kimi-k2.5-free', description: '限时免费，月之暗面模型' },
-  { label: 'Nemotron 3 Super Free', value: 'nemotron-3-super-free', description: '限时免费，NVIDIA 模型，100万上下文' },
-]
+type OpencodeModel = {
+  label: string
+  value: string
+  description: string
+}
 
 export function OpenCodeLoginFlow({
   onDone,
@@ -27,12 +24,14 @@ export function OpenCodeLoginFlow({
 }: OpenCodeLoginFlowProps): React.ReactNode {
   const [mode, setMode] = useState<LoginMode>('menu')
   const [isBusy, setIsBusy] = useState(false)
+  const [isLoadingModels, setIsLoadingModels] = useState(false)
   const [status, setStatus] = useState<string | null>(null)
   const [inputValue, setInputValue] = useState('')
   const [cursorOffset, setCursorOffset] = useState(0)
-  const [selectedModel, setSelectedModel] = useState('big-pickle')
+  const [selectedModel, setSelectedModel] = useState('')
   const [existingApiKey, setExistingApiKey] = useState<string | null>(null)
   const [existingModelName, setExistingModelName] = useState<string | null>(null)
+  const [availableModels, setAvailableModels] = useState<OpencodeModel[]>([])
 
   useEffect(() => {
     const key = getOpenCodeApiKey()
@@ -46,6 +45,52 @@ export function OpenCodeLoginFlow({
     }
   }, [])
 
+  const fetchModels = async () => {
+    setIsLoadingModels(true)
+    try {
+      // Use native https module for better reliability in bundled environment
+      const https = await import('https')
+      const data = await new Promise<string>((resolve, reject) => {
+        const req = https.get('https://opencode.ai/zen/v1/models', {
+          headers: {
+            'User-Agent': 'claude-code/2.1.88',
+          },
+          timeout: 15000,
+        }, res => {
+          let body = ''
+          res.on('data', chunk => { body += chunk })
+          res.on('end', () => resolve(body))
+          res.on('error', reject)
+        })
+        req.on('error', reject)
+        req.on('timeout', () => {
+          req.destroy()
+          reject(new Error('Request timed out'))
+        })
+      })
+
+      const parsed = JSON.parse(data) as { data?: Array<{ id: string }> }
+      if (Array.isArray(parsed.data) && parsed.data.length > 0) {
+        const models = parsed.data.map(m => ({
+          label: m.id,
+          value: m.id,
+          description: m.id.endsWith('-free') ? '限时免费模型' : 'OpenCode Zen 模型',
+        }))
+        setAvailableModels(models)
+        if (!selectedModel && models.length > 0) {
+          setSelectedModel(models[0].value)
+        }
+      } else {
+        setStatus('API returned empty model list')
+      }
+    } catch (err) {
+      console.error('OpenCode models fetch error:', err)
+      setStatus(`Failed to fetch models: ${err instanceof Error ? err.message : 'Unknown error'}`)
+    } finally {
+      setIsLoadingModels(false)
+    }
+  }
+
   const menuOptions = [
     {
       label: (
@@ -81,16 +126,23 @@ export function OpenCodeLoginFlow({
 
     if (value === 'free_models') {
       setMode('free_models')
+      // Fetch models when entering free models mode
+      if (availableModels.length === 0) {
+        await fetchModels()
+      }
       return
     }
   }
 
-  async function handleFreeModelSelect(): Promise<void> {
+  async function handleFreeModelSelect(modelValue?: string): Promise<void> {
+    const modelToSave = modelValue || selectedModel
+    if (!modelToSave) return
+    
     setIsBusy(true)
     setStatus(null)
     try {
       // 免费模型不需要 API Key，直接保存模型名称
-      await saveOpenCodeApiKey('', selectedModel)
+      await saveOpenCodeApiKey('', modelToSave)
       onDone()
     } catch (error) {
       setStatus(error instanceof Error ? error.message : String(error))
@@ -131,19 +183,39 @@ export function OpenCodeLoginFlow({
   }
 
   if (mode === 'free_models') {
+    if (isLoadingModels) {
+      return (
+        <Box flexDirection="column" gap={1}>
+          <Text>Loading available models...</Text>
+        </Box>
+      )
+    }
+
+    if (availableModels.length === 0) {
+      return (
+        <Box flexDirection="column" gap={1}>
+          <Text bold={true}>No models available</Text>
+          <Text dimColor={true}>
+            {status || 'Failed to fetch models from OpenCode Zen API.'}
+          </Text>
+          <Box flexDirection="row" gap={2} marginTop={1}>
+            <Text color="subtle">Esc to go back</Text>
+          </Box>
+        </Box>
+      )
+    }
+
     return (
       <Box flexDirection="column" gap={1}>
         <Text bold={true}>
           {startingMessage ?? 'Select a free model from OpenCode Zen.'}
         </Text>
         <Text dimColor={true}>
-          Free models are limited-time offers except GPT 5 Nano (permanently free).
-          {'\n'}
-          No API key needed — just start coding!
+          Free models are available from OpenCode Zen API.
         </Text>
         <Text>Select model:</Text>
         <Select
-          options={FREE_MODELS.map(model => ({
+          options={availableModels.map(model => ({
             label: (
               <Text>
                 {model.label}{' '}
@@ -155,8 +227,8 @@ export function OpenCodeLoginFlow({
           }))}
           onChange={value => {
             setSelectedModel(value)
-            // 选择后直接提交
-            void handleFreeModelSelect()
+            // 选择后自动提交，直接传递 value 避免闭包问题
+            void handleFreeModelSelect(value)
           }}
         />
         <Box flexDirection="row" gap={2} marginTop={1}>
@@ -222,12 +294,12 @@ export function OpenCodeLoginFlow({
     <Box flexDirection="column" gap={1}>
       <Text bold={true}>
         {startingMessage ??
-          'Better-Clawd can use OpenCode Zen free models or with a standard OpenCode Zen API key.'}
+          'Better-Clawd can use OpenCode Zen free models or with a Zen API key.'}
       </Text>
       <Text dimColor={true}>
         OpenCode Zen provides free models out of the box — no API key required.
         {'\n'}
-        Free models include Big Pickle, GPT 5 Nano, and more.
+        Free models are fetched from the API dynamically.
       </Text>
       {status ? <Text color="error">{status}</Text> : null}
       <Box>

src/components/SearchableModelPicker.tsx

@@ -65,28 +65,25 @@ export function SearchableModelPicker({
   }
 }, [isFastMode, authVersion])
 
-  // Poll for OpenRouter models when cache is empty
+  // Poll for OpenRouter/OpenCode models when cache is empty
   React.useEffect(() => {
     let mounted = true
     let pollTimer: NodeJS.Timeout | null = null
 
-    async function checkOpenRouterCache() {
+    async function checkProviderCache() {
       try {
         const { getAPIProvider } = await import('../utils/model/providers.js')
         const provider = getAPIProvider()
 
         if (provider === 'openrouter' && modelOptions.length === 0) {
-          // Check cache every 500ms
           pollTimer = setInterval(async () => {
             if (!mounted) {
               if (pollTimer) clearInterval(pollTimer)
               return
             }
-
             try {
               const { hasOpenRouterModelsCache } = await import('../utils/model/openRouterModels.js')
               if (hasOpenRouterModelsCache()) {
-                // Cache is now populated, trigger re-render
                 if (mounted) {
                   setAppState(prev => ({ ...prev, authVersion: prev.authVersion + 1 }))
                 }
@@ -97,8 +94,34 @@ export function SearchableModelPicker({
               if (pollTimer) clearInterval(pollTimer)
             }
           }, 500)
+          setTimeout(() => {
+            if (pollTimer && mounted) {
+              clearInterval(pollTimer)
+              pollTimer = null
+            }
+          }, 10000)
+        }
 
-          // Stop polling after 10 seconds
+        if (provider === 'opencode' && modelOptions.length <= 1) {
+          pollTimer = setInterval(async () => {
+            if (!mounted) {
+              if (pollTimer) clearInterval(pollTimer)
+              return
+            }
+            try {
+              const { getCachedOpencodeModels } = await import('../services/api/opencodeClient.js')
+              const models = getCachedOpencodeModels()
+              if (models && models.length > 0) {
+                if (mounted) {
+                  setAppState(prev => ({ ...prev, authVersion: prev.authVersion + 1 }))
+                }
+                if (pollTimer) clearInterval(pollTimer)
+              }
+            } catch (error) {
+              console.error('Error checking OpenCode cache:', error)
+              if (pollTimer) clearInterval(pollTimer)
+            }
+          }, 500)
           setTimeout(() => {
             if (pollTimer && mounted) {
               clearInterval(pollTimer)
@@ -111,7 +134,7 @@ export function SearchableModelPicker({
       }
     }
 
-    checkOpenRouterCache()
+    checkProviderCache()
 
     return () => {
       mounted = false

src/services/api/client.ts

@@ -149,6 +149,8 @@ export async function getAnthropicClient({
   const provider = getAPIProvider()
   let opencodeFetchOverride: ClientOptions['fetch'] | undefined
   if (provider === 'opencode' && model) {
+    // Fetch models in background
+    import('./opencodeClient.js').then(m => m.fetchOpencodeModels())
     opencodeFetchOverride = createOpenCodeFetchOverride(model)
   }
 

src/services/api/opencodeClient.ts

@@ -1,13 +1,173 @@
 import { getOpenCodeApiKey, getOpenCodeModelName } from '../../utils/auth.js'
 import {
-  convertAnthropicMessagesToOpenAI,
   convertAnthropicToolsToOpenAI,
   convertOpenAIStreamToAnthropic,
   type AnthropicMessage,
+  type AnthropicContentBlock,
 } from './copilotClient.js'
 
 const OPENCODE_BASE_URL = 'https://opencode.ai/zen/v1'
 
+let cachedModels: Array<{ id: string; name?: string }> | null = null
+let fetchPromise: Promise<void> | null = null
+
+export async function fetchOpencodeModels(): Promise<void> {
+  if (cachedModels || fetchPromise) return
+  
+  fetchPromise = (async () => {
+    try {
+      const https = await import('https')
+      const data = await new Promise<string>((resolve, reject) => {
+        const apiKey = getOpenCodeApiKey()
+        const headers: Record<string, string> = {
+          'User-Agent': 'claude-code/2.1.88',
+        }
+        if (apiKey) {
+          headers.Authorization = `Bearer ${apiKey}`
+        }
+        const req = https.get(`${OPENCODE_BASE_URL}/models`, {
+          headers,
+          timeout: 15000,
+        }, res => {
+          let body = ''
+          res.on('data', chunk => { body += chunk })
+          res.on('end', () => resolve(body))
+          res.on('error', reject)
+        })
+        req.on('error', reject)
+        req.on('timeout', () => {
+          req.destroy()
+          reject(new Error('Request timed out'))
+        })
+      })
+
+      const parsed = JSON.parse(data) as { data?: Array<{ id: string; name?: string }> }
+      if (Array.isArray(parsed.data)) {
+        cachedModels = parsed.data.map(m => ({ id: m.id, name: m.name || m.id }))
+      }
+    } catch {
+      // Ignore errors
+    } finally {
+      fetchPromise = null
+    }
+  })()
+  
+  await fetchPromise
+}
+
+export function getCachedOpencodeModels(): Array<{ id: string; name?: string }> {
+  return cachedModels || []
+}
+
+type OpenAIMessage = {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content: string | Array<{ type: string; text?: string; image_url?: { url: string } }> | null
+  tool_calls?: Array<{
+    id: string
+    type: 'function'
+    function: { name: string; arguments: string }
+  }>
+  tool_call_id?: string
+  reasoning_content?: string
+}
+
+function convertAnthropicMessagesToOpenAI(
+  messages: AnthropicMessage[],
+  systemPrompt?: string,
+): OpenAIMessage[] {
+  const result: OpenAIMessage[] = []
+
+  if (systemPrompt) {
+    result.push({ role: 'system', content: systemPrompt })
+  }
+
+  for (const msg of messages) {
+    if (typeof msg.content === 'string') {
+      result.push({ role: msg.role, content: msg.content })
+      continue
+    }
+
+    if (msg.role === 'user') {
+      const parts: Array<{ type: string; text?: string; image_url?: { url: string } }> = []
+      const toolResults: OpenAIMessage[] = []
+
+      for (const block of msg.content) {
+        if (block.type === 'text') {
+          parts.push({ type: 'text', text: (block as { type: 'text'; text: string }).text })
+        } else if (block.type === 'image') {
+          const imgBlock = block as { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
+          parts.push({
+            type: 'image_url',
+            image_url: { url: `data:${imgBlock.source.media_type};base64,${imgBlock.source.data}` },
+          })
+        } else if (block.type === 'tool_result') {
+          const trBlock = block as { type: 'tool_result'; tool_use_id: string; content: string | Array<{ type: string; text?: string }> }
+          let content = ''
+          if (typeof trBlock.content === 'string') {
+            content = trBlock.content
+          } else if (Array.isArray(trBlock.content)) {
+            content = trBlock.content
+              .filter(c => c.type === 'text')
+              .map(c => c.text || '')
+              .join('\n')
+          }
+          toolResults.push({
+            role: 'tool',
+            content,
+            tool_call_id: trBlock.tool_use_id,
+          })
+        }
+      }
+
+      if (toolResults.length > 0) {
+        result.push(...toolResults)
+        if (parts.length > 0) {
+          result.push({ role: 'user', content: parts.length === 1 && parts[0].type === 'text' ? parts[0].text! : parts })
+        }
+      } else if (parts.length > 0) {
+        result.push({ role: 'user', content: parts.length === 1 && parts[0].type === 'text' ? parts[0].text! : parts })
+      }
+    } else if (msg.role === 'assistant') {
+      const textParts: string[] = []
+      const toolCalls: Array<{ id: string; type: 'function'; function: { name: string; arguments: string } }> = []
+      let reasoningContent: string | undefined
+
+      for (const block of msg.content) {
+        if (block.type === 'text') {
+          textParts.push((block as { type: 'text'; text: string }).text)
+        } else if (block.type === 'tool_use') {
+          const tuBlock = block as { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
+          toolCalls.push({
+            id: tuBlock.id,
+            type: 'function',
+            function: {
+              name: tuBlock.name,
+              arguments: JSON.stringify(tuBlock.input),
+            },
+          })
+        } else if (block.type === 'thinking') {
+          const thinkingBlock = block as { type: 'thinking'; thinking: string }
+          reasoningContent = thinkingBlock.thinking
+        }
+      }
+
+      const assistantMsg: OpenAIMessage = {
+        role: 'assistant',
+        content: textParts.join('\n') || null,
+      }
+      if (reasoningContent) {
+        assistantMsg.reasoning_content = reasoningContent
+      }
+      if (toolCalls.length > 0) {
+        assistantMsg.tool_calls = toolCalls
+      }
+      result.push(assistantMsg)
+    }
+  }
+
+  return result
+}
+
 function normalizeBaseUrl(url: string): string {
   return url.replace(/\/$/, '')
 }
@@ -119,6 +279,7 @@ export function createOpenCodeFetchOverride(
           message: {
             role: string
             content: string | null
+            reasoning_content?: string
             tool_calls?: Array<{
               id: string
               function: { name: string; arguments: string }
@@ -138,6 +299,10 @@ export function createOpenCodeFetchOverride(
         input?: unknown
       }> = []
 
+      if (choice?.message?.reasoning_content) {
+        anthropicContent.push({ type: 'thinking', thinking: choice.message.reasoning_content })
+      }
+
       if (choice?.message?.content) {
         anthropicContent.push({ type: 'text', text: choice.message.content })
       }
@@ -176,7 +341,7 @@ export function createOpenCodeFetchOverride(
       return openaiResponse
     }
 
-    const transformStream = convertOpenAIStreamToAnthropic(openaiResponse.body, modelName)
+    const transformStream = convertOpenAIStreamToAnthropicWithReasoning(openaiResponse.body, modelName)
 
     return new Response(transformStream, {
       status: 200,
@@ -188,3 +353,180 @@ export function createOpenCodeFetchOverride(
     })
   }
 }
+
+function convertOpenAIStreamToAnthropicWithReasoning(
+  openaiStream: ReadableStream,
+  model: string,
+): ReadableStream<Uint8Array> {
+  const encoder = new TextEncoder()
+  const decoder = new TextDecoder()
+
+  let messageId = `msg_${Date.now()}`
+  let contentIndex = 0
+  let hasStartedContent = false
+  let hasReasoningBlock = false
+  let currentToolCallIndex = -1
+  const toolCalls: Map<number, { id: string; name: string; arguments: string }> = new Map()
+  let totalOutputTokens = 0
+
+  return new ReadableStream({
+    async start(controller) {
+      const reader = openaiStream.getReader()
+      let buffer = ''
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+
+          buffer += decoder.decode(value, { stream: true })
+
+          const lines = buffer.split('\n')
+          buffer = lines.pop() || ''
+
+          for (const line of lines) {
+            if (!line.startsWith('data: ')) continue
+            const data = line.slice(6).trim()
+            if (data === '[DONE]') {
+              if (hasStartedContent) {
+                controller.enqueue(encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex - 1}}\n\n`))
+              }
+              for (const [idx, tc] of toolCalls) {
+                controller.enqueue(
+                  encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex + idx}}\n\n`),
+                )
+              }
+              controller.enqueue(
+                encoder.encode(
+                  `event: message_delta\ndata: {"delta":{"stop_reason":"${toolCalls.size > 0 ? 'tool_use' : 'end_turn'}"},"usage":{"output_tokens":${totalOutputTokens}}}\n\n`,
+                ),
+              )
+              controller.enqueue(encoder.encode('event: message_stop\ndata: {}\n\n'))
+              return
+            }
+
+            let chunk: {
+              choices?: Array<{
+                delta?: {
+                  content?: string | null
+                  reasoning_content?: string | null
+                  tool_calls?: Array<{
+                    index: number
+                    id?: string
+                    function?: { name?: string; arguments?: string }
+                  }>
+                  role?: string
+                }
+                finish_reason?: string | null
+              }>
+              usage?: { completion_tokens?: number; prompt_tokens?: number; total_tokens?: number }
+            }
+
+            try {
+              chunk = JSON.parse(data)
+            } catch {
+              continue
+            }
+
+            if (chunk.usage?.completion_tokens) {
+              totalOutputTokens = chunk.usage.completion_tokens
+            }
+
+            const choice = chunk.choices?.[0]
+            if (!choice?.delta) continue
+
+            const delta = choice.delta
+
+            if (delta.reasoning_content != null && delta.reasoning_content !== '') {
+              if (!hasReasoningBlock) {
+                hasReasoningBlock = true
+                controller.enqueue(
+                  encoder.encode(
+                    `event: content_block_start\ndata: {"index":${contentIndex},"content_block":{"type":"thinking","thinking":""}}\n\n`,
+                  ),
+                )
+              }
+              controller.enqueue(
+                encoder.encode(
+                  `event: content_block_delta\ndata: {"index":${contentIndex},"delta":{"type":"thinking_delta","thinking":"${JSON.stringify(delta.reasoning_content).slice(1, -1)}"}}\n\n`,
+                ),
+              )
+            }
+
+            if (delta.content != null && delta.content !== '') {
+              if (!hasStartedContent) {
+                hasStartedContent = true
+                if (hasReasoningBlock) {
+                  controller.enqueue(
+                    encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex}}\n\n`),
+                  )
+                  contentIndex++
+                }
+                controller.enqueue(
+                  encoder.encode(
+                    `event: content_block_start\ndata: {"index":${contentIndex},"content_block":{"type":"text","text":""}}\n\n`,
+                  ),
+                )
+              }
+              controller.enqueue(
+                encoder.encode(
+                  `event: content_block_delta\ndata: {"index":${contentIndex},"delta":{"type":"text_delta","text":"${JSON.stringify(delta.content).slice(1, -1)}"}}\n\n`,
+                ),
+              )
+            }
+
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (tc.id) {
+                  if (hasStartedContent && currentToolCallIndex === -1) {
+                    controller.enqueue(
+                      encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex}}\n\n`),
+                    )
+                    contentIndex++
+                    hasStartedContent = false
+                  }
+                  currentToolCallIndex = tc.index
+                  toolCalls.set(tc.index, {
+                    id: tc.id,
+                    name: tc.function?.name || '',
+                    arguments: tc.function?.arguments || '',
+                  })
+                  const toolBlockIndex =
+                    hasStartedContent ? contentIndex + 1 + tc.index : contentIndex + tc.index
+                  controller.enqueue(
+                    encoder.encode(
+                      `event: content_block_start\ndata: {"index":${toolBlockIndex},"content_block":{"type":"text","text":""}}\n\n`,
+                    ),
+                  )
+                } else if (tc.function?.arguments) {
+                  const existing = toolCalls.get(tc.index)
+                  if (existing) {
+                    existing.arguments += tc.function.arguments
+                  }
+                }
+              }
+            }
+
+            if (choice.finish_reason) {
+              if (hasStartedContent) {
+                controller.enqueue(
+                  encoder.encode(`event: content_block_stop\ndata: {"index":${contentIndex}}\n\n`),
+                )
+              }
+              controller.enqueue(
+                encoder.encode(
+                  `event: message_delta\ndata: {"delta":{"stop_reason":"${choice.finish_reason === 'tool_calls' ? 'tool_use' : 'end_turn'}"},"usage":{"output_tokens":${totalOutputTokens}}}\n\n`,
+                ),
+              )
+              controller.enqueue(encoder.encode('event: message_stop\ndata: {}\n\n'))
+              return
+            }
+          }
+        }
+      } finally {
+        reader.releaseLock()
+        controller.close()
+      }
+    },
+  })
+}

src/utils/auth.ts

@@ -449,7 +449,26 @@ export function getOpenCodeApiKey(): null | string {
 
 export function getOpenCodeModelName(): null | string {
   const config = getGlobalConfig()
-  return config.openCodeModelName || null
+  if (config.authProvider === 'opencode' && config.openCodeModelName) {
+    return config.openCodeModelName
+  }
+  // Fallback: read config file directly in case getGlobalConfig() is stale
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { readFileSync } = require('fs') as typeof import('fs')
+    const { getGlobalClaudeFile } = require('./env.js') as typeof import('./env.js')
+    const raw = readFileSync(getGlobalClaudeFile(), 'utf8')
+    const fileConfig = JSON.parse(raw) as {
+      authProvider?: string
+      openCodeModelName?: string
+    }
+    if (fileConfig.authProvider === 'opencode' && fileConfig.openCodeModelName) {
+      return fileConfig.openCodeModelName
+    }
+  } catch {
+    // Ignore errors
+  }
+  return null
 }
 
 export async function saveLocalModelConfig(baseUrl: string, modelName: string): Promise<void> {

src/utils/model/model.ts

@@ -250,10 +250,9 @@ export function getDefaultMainLoopModelSetting(): ModelName | ModelAlias {
   }
 
   // Check if using OpenCode Zen provider
+  // Always check config file directly since provider cache may be stale
   let isOpenCodeProvider = apiProvider === 'opencode'
-
-  // If getAPIProvider() returns null, check the config file directly
-  if (!isOpenCodeProvider && apiProvider === null) {
+  if (!isOpenCodeProvider) {
     try {
       // eslint-disable-next-line @typescript-eslint/no-require-imports
       const { readFileSync } = require('fs') as typeof import('fs')

src/utils/model/modelOptions.ts

@@ -4,6 +4,7 @@ import {
   isClaudeAISubscriber,
   isMaxSubscriber,
   isTeamPremiumSubscriber,
+  getOpenCodeModelName,
 } from '../auth.js'
 import { getModelStrings } from './modelStrings.js'
 import {
@@ -489,6 +490,30 @@ function getModelOptionsBase(fastMode = false): ModelOption[] {
     return [getDefaultOptionForUser(fastMode)]
   }
 
+  // OpenCode Zen: Fetch models dynamically from API
+  if (getAPIProvider() === 'opencode') {
+    const defaultOpt = getDefaultOptionForUser(fastMode)
+    try {
+      const { getCachedOpencodeModels } = require('../../services/api/opencodeClient.js')
+      const models = getCachedOpencodeModels()
+      if (models && Array.isArray(models) && models.length > 0) {
+        return [
+          defaultOpt,
+          ...models.map(m => ({
+            value: m.id,
+            label: m.name || m.id,
+            description: 'OpenCode Zen Model',
+          })),
+        ]
+      }
+    } catch {
+      // Ignore errors
+    }
+    
+    // Return only default if models are not yet fetched
+    return [defaultOpt]
+  }
+
   // OpenRouter API: Show all available models from OpenRouter
   if (getAPIProvider() === 'openrouter') {
     // Trigger background fetch of OpenRouter models (non-blocking)