Feature: Add local OpenAI-compatible model discovery to /model

src/commands/model/model.test.tsx

@@ -0,0 +1,43 @@
+import { afterEach, expect, mock, test } from 'bun:test'
+
+const originalEnv = {
+  CLAUDE_CODE_USE_OPENAI: process.env.CLAUDE_CODE_USE_OPENAI,
+  OPENAI_BASE_URL: process.env.OPENAI_BASE_URL,
+  OPENAI_MODEL: process.env.OPENAI_MODEL,
+}
+
+afterEach(() => {
+  mock.restore()
+  process.env.CLAUDE_CODE_USE_OPENAI = originalEnv.CLAUDE_CODE_USE_OPENAI
+  process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
+  process.env.OPENAI_MODEL = originalEnv.OPENAI_MODEL
+})
+
+test('opens the model picker without awaiting local model discovery refresh', async () => {
+  process.env.CLAUDE_CODE_USE_OPENAI = '1'
+  process.env.OPENAI_BASE_URL = 'http://127.0.0.1:8080/v1'
+  process.env.OPENAI_MODEL = 'qwen2.5-coder-7b-instruct'
+
+  let resolveDiscovery: (() => void) | undefined
+  const discoverOpenAICompatibleModelOptions = mock(
+    () =>
+      new Promise<void>(resolve => {
+        resolveDiscovery = resolve
+      }),
+  )
+
+  mock.module('../../utils/model/openaiModelDiscovery.js', () => ({
+    discoverOpenAICompatibleModelOptions,
+  }))
+
+  const { call } = await import('./model.js')
+  const result = await Promise.race([
+    call(() => {}, {} as never, ''),
+    new Promise(resolve => setTimeout(() => resolve('timeout'), 50)),
+  ])
+
+  resolveDiscovery?.()
+
+  expect(result).not.toBe('timeout')
+  expect(discoverOpenAICompatibleModelOptions).toHaveBeenCalledTimes(1)
+})

src/commands/model/model.tsx

@@ -4,6 +4,7 @@ import * as React from 'react';
 import type { CommandResultDisplay } from '../../commands.js';
 import { ModelPicker } from '../../components/ModelPicker.js';
 import { COMMON_HELP_ARGS, COMMON_INFO_ARGS } from '../../constants/xml.js';
+import { fetchBootstrapData } from '../../services/api/bootstrap.js';
 import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
 import { useAppState, useSetAppState } from '../../state/AppState.js';
 import type { LocalJSXCommandCall } from '../../types/command.js';
@@ -19,6 +20,7 @@ import { getActiveOpenAIModelOptionsCache, setActiveOpenAIModelOptionsCache } fr
 import { getDefaultMainLoopModelSetting, isOpus1mMergeEnabled, renderDefaultModelSetting } from '../../utils/model/model.js';
 import { isModelAllowed } from '../../utils/model/modelAllowlist.js';
 import { validateModel } from '../../utils/model/validateModel.js';
+import { getAdditionalModelOptionsCacheScope } from '../../services/api/providerConfig.js';
 function ModelPickerWrapper(t0) {
   const $ = _c(17);
   const {
@@ -319,7 +321,9 @@ export const call: LocalJSXCommandCall = async (onDone, _context, args) => {
     });
     return <SetModelAndClose args={args} onDone={onDone} />;
   }
-  await refreshOpenAIModelOptionsCache();
+  if (getAdditionalModelOptionsCacheScope()?.startsWith('openai:')) {
+    void refreshOpenAIModelOptionsCache();
+  }
   return <ModelPickerWrapper onDone={onDone} />;
 };
 function renderModelLabel(model: string | null): string {

src/commands/provider/provider.test.tsx

@@ -197,6 +197,21 @@ test('buildProfileSaveMessage maps provider fields without echoing secrets', ()
   expect(message).not.toContain('sk-secret-12345678')
 })
 
+test('buildProfileSaveMessage labels local openai-compatible profiles consistently', () => {
+  const message = buildProfileSaveMessage(
+    'openai',
+    {
+      OPENAI_MODEL: 'gpt-5.4',
+      OPENAI_BASE_URL: 'http://127.0.0.1:8080/v1',
+    },
+    'D:/codings/Opensource/openclaude/.openclaude-profile.json',
+  )
+
+  expect(message).toContain('Saved Local OpenAI-compatible profile.')
+  expect(message).toContain('Model: gpt-5.4')
+  expect(message).toContain('Endpoint: http://127.0.0.1:8080/v1')
+})
+
 test('buildProfileSaveMessage describes Gemini access token / ADC mode clearly', () => {
   const message = buildProfileSaveMessage(
     'gemini',
@@ -230,6 +245,36 @@ test('buildCurrentProviderSummary redacts poisoned model and endpoint values', (
   expect(summary.endpointLabel).toBe('sk-...5678')
 })
 
+test('buildCurrentProviderSummary labels generic local openai-compatible providers', () => {
+  const summary = buildCurrentProviderSummary({
+    processEnv: {
+      CLAUDE_CODE_USE_OPENAI: '1',
+      OPENAI_MODEL: 'qwen2.5-coder-7b-instruct',
+      OPENAI_BASE_URL: 'http://127.0.0.1:8080/v1',
+    },
+    persisted: null,
+  })
+
+  expect(summary.providerLabel).toBe('Local OpenAI-compatible')
+  expect(summary.modelLabel).toBe('qwen2.5-coder-7b-instruct')
+  expect(summary.endpointLabel).toBe('http://127.0.0.1:8080/v1')
+})
+
+test('buildCurrentProviderSummary does not relabel local gpt-5.4 providers as Codex', () => {
+  const summary = buildCurrentProviderSummary({
+    processEnv: {
+      CLAUDE_CODE_USE_OPENAI: '1',
+      OPENAI_MODEL: 'gpt-5.4',
+      OPENAI_BASE_URL: 'http://127.0.0.1:8080/v1',
+    },
+    persisted: null,
+  })
+
+  expect(summary.providerLabel).toBe('Local OpenAI-compatible')
+  expect(summary.modelLabel).toBe('gpt-5.4')
+  expect(summary.endpointLabel).toBe('http://127.0.0.1:8080/v1')
+})
+
 test('getProviderWizardDefaults ignores poisoned current provider values', () => {
   const defaults = getProviderWizardDefaults({
     OPENAI_API_KEY: 'sk-secret-12345678',

src/commands/provider/provider.tsx

@@ -15,6 +15,7 @@ import { Box, Text } from '../../ink.js'
 import {
   DEFAULT_CODEX_BASE_URL,
   DEFAULT_OPENAI_BASE_URL,
+  isLocalProviderUrl,
   resolveCodexApiCredentials,
   resolveProviderRequest,
 } from '../../services/api/providerConfig.js'
@@ -52,7 +53,11 @@ import {
   recommendOllamaModel,
   type RecommendationGoal,
 } from '../../utils/providerRecommendation.js'
-import { hasLocalOllama, listOllamaModels } from '../../utils/providerDiscovery.js'
+import {
+  getLocalOpenAICompatibleProviderLabel,
+  hasLocalOllama,
+  listOllamaModels,
+} from '../../utils/providerDiscovery.js'
 
 type ProviderChoice = 'auto' | ProviderProfile | 'clear'
 
@@ -182,10 +187,8 @@ export function buildCurrentProviderSummary(options?: {
     let providerLabel = 'OpenAI-compatible'
     if (request.transport === 'codex_responses') {
       providerLabel = 'Codex'
-    } else if (request.baseUrl.includes('localhost:11434')) {
-      providerLabel = 'Ollama'
-    } else if (request.baseUrl.includes('localhost:1234')) {
-      providerLabel = 'LM Studio'
+    } else if (isLocalProviderUrl(request.baseUrl)) {
+      providerLabel = getLocalOpenAICompatibleProviderLabel(request.baseUrl)
     }
 
     return {
@@ -272,16 +275,20 @@ function buildSavedProfileSummary(
         ),
       }
     case 'openai':
-    default:
+    default: {
+      const baseUrl = env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL
+
       return {
-        providerLabel: 'OpenAI-compatible',
+        providerLabel: isLocalProviderUrl(baseUrl)
+          ? getLocalOpenAICompatibleProviderLabel(baseUrl)
+          : 'OpenAI-compatible',
         modelLabel: getSafeDisplayValue(
           env.OPENAI_MODEL ?? 'gpt-4o',
           process.env,
           env,
         ),
         endpointLabel: getSafeDisplayValue(
-          env.OPENAI_BASE_URL ?? DEFAULT_OPENAI_BASE_URL,
+          baseUrl,
           process.env,
           env,
         ),
@@ -290,6 +297,7 @@ function buildSavedProfileSummary(
             ? 'configured'
             : undefined,
       }
+    }
   }
 }
 

src/components/StartupScreen.ts

@@ -5,6 +5,9 @@
  * Addresses: https://github.com/Gitlawb/openclaude/issues/55
  */
 
+import { isLocalProviderUrl } from '../services/api/providerConfig.js'
+import { getLocalOpenAICompatibleProviderLabel } from '../utils/providerDiscovery.js'
+
 declare const MACRO: { VERSION: string; DISPLAY_VERSION?: string }
 
 const ESC = '\x1b['
@@ -99,18 +102,16 @@ function detectProvider(): { name: string; model: string; baseUrl: string; isLoc
   if (useOpenAI) {
     const rawModel = process.env.OPENAI_MODEL || 'gpt-4o'
     const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1'
-    const isLocal = /localhost|127\.0\.0\.1|0\.0\.0\.0/.test(baseUrl)
+    const isLocal = isLocalProviderUrl(baseUrl)
     let name = 'OpenAI'
     if (/deepseek/i.test(baseUrl) || /deepseek/i.test(rawModel))       name = 'DeepSeek'
     else if (/openrouter/i.test(baseUrl))                             name = 'OpenRouter'
     else if (/together/i.test(baseUrl))                               name = 'Together AI'
     else if (/groq/i.test(baseUrl))                                   name = 'Groq'
     else if (/mistral/i.test(baseUrl) || /mistral/i.test(rawModel))     name = 'Mistral'
     else if (/azure/i.test(baseUrl))                                  name = 'Azure OpenAI'
-    else if (/localhost:11434/i.test(baseUrl))                        name = 'Ollama'
-    else if (/localhost:1234/i.test(baseUrl))                         name = 'LM Studio'
     else if (/llama/i.test(rawModel))                                    name = 'Meta Llama'
-    else if (isLocal)                                                  name = 'Local'
+    else if (isLocal)                                                  name = getLocalOpenAICompatibleProviderLabel(baseUrl)
 
     // Resolve model alias to actual model name + reasoning effort
     let displayModel = rawModel

src/services/api/bootstrap.ts

@@ -14,7 +14,16 @@ import { lazySchema } from '../../utils/lazySchema.js'
 import { logError } from '../../utils/log.js'
 import { getAPIProvider } from '../../utils/model/providers.js'
 import { isEssentialTrafficOnly } from '../../utils/privacyLevel.js'
+import type { ModelOption } from '../../utils/model/modelOptions.js'
+import {
+  getLocalOpenAICompatibleProviderLabel,
+  listOpenAICompatibleModels,
+} from '../../utils/providerDiscovery.js'
 import { getClaudeCodeUserAgent } from '../../utils/userAgent.js'
+import {
+  getAdditionalModelOptionsCacheScope,
+  resolveProviderRequest,
+} from './providerConfig.js'
 
 const bootstrapResponseSchema = lazySchema(() =>
   z.object({
@@ -39,6 +48,12 @@ const bootstrapResponseSchema = lazySchema(() =>
 
 type BootstrapResponse = z.infer<ReturnType<typeof bootstrapResponseSchema>>
 
+type BootstrapCachePayload = {
+  clientData: Record<string, unknown> | null
+  additionalModelOptions: ModelOption[]
+  additionalModelOptionsScope: string
+}
+
 async function fetchBootstrapAPI(): Promise<BootstrapResponse | null> {
   if (isEssentialTrafficOnly()) {
     logForDebugging('[Bootstrap] Skipped: Nonessential traffic disabled')
@@ -108,22 +123,70 @@ async function fetchBootstrapAPI(): Promise<BootstrapResponse | null> {
   }
 }
 
+async function fetchLocalOpenAIModelOptions(): Promise<BootstrapCachePayload | null> {
+  const scope = getAdditionalModelOptionsCacheScope()
+  if (!scope?.startsWith('openai:')) {
+    return null
+  }
+
+  const { baseUrl } = resolveProviderRequest()
+  const models = await listOpenAICompatibleModels({
+    baseUrl,
+    apiKey: process.env.OPENAI_API_KEY,
+  })
+
+  if (models === null) {
+    logForDebugging('[Bootstrap] Local OpenAI model discovery failed')
+    return null
+  }
+
+  const providerLabel = getLocalOpenAICompatibleProviderLabel(baseUrl)
+
+  return {
+    clientData: getGlobalConfig().clientDataCache ?? null,
+    additionalModelOptionsScope: scope,
+    additionalModelOptions: models.map(model => ({
+      value: model,
+      label: model,
+      description: `Detected from ${providerLabel}`,
+    })),
+  }
+}
+
 /**
  * Fetch bootstrap data from the API and persist to disk cache.
  */
 export async function fetchBootstrapData(): Promise<void> {
   try {
-    const response = await fetchBootstrapAPI()
-    if (!response) return
+    const scope = getAdditionalModelOptionsCacheScope()
+    let payload: BootstrapCachePayload | null = null
+
+    if (scope === 'firstParty') {
+      const response = await fetchBootstrapAPI()
+      if (!response) return
+
+      payload = {
+        clientData: response.client_data ?? null,
+        additionalModelOptions: response.additional_model_options ?? [],
+        additionalModelOptionsScope: scope,
+      }
+    } else if (scope?.startsWith('openai:')) {
+      payload = await fetchLocalOpenAIModelOptions()
+      if (!payload) return
+    } else {
+      logForDebugging('[Bootstrap] Skipped: no additional model source')
+      return
+    }
 
-    const clientData = response.client_data ?? null
-    const additionalModelOptions = response.additional_model_options ?? []
+    const { clientData, additionalModelOptions, additionalModelOptionsScope } =
+      payload
 
     // Only persist if data actually changed — avoids a config write on every startup.
     const config = getGlobalConfig()
     if (
       isEqual(config.clientDataCache, clientData) &&
-      isEqual(config.additionalModelOptionsCache, additionalModelOptions)
+      isEqual(config.additionalModelOptionsCache, additionalModelOptions) &&
+      config.additionalModelOptionsCacheScope === additionalModelOptionsScope
     ) {
       logForDebugging('[Bootstrap] Cache unchanged, skipping write')
       return
@@ -134,6 +197,7 @@ export async function fetchBootstrapData(): Promise<void> {
       ...current,
       clientDataCache: clientData,
       additionalModelOptionsCache: additionalModelOptions,
+      additionalModelOptionsCacheScope: additionalModelOptionsScope,
     }))
   } catch (error) {
     logError(error)

src/services/api/codexShim.test.ts

@@ -14,12 +14,19 @@ import {
 } from './providerConfig.js'
 
 const tempDirs: string[] = []
+const originalEnv = {
+  OPENAI_BASE_URL: process.env.OPENAI_BASE_URL,
+  OPENAI_API_BASE: process.env.OPENAI_API_BASE,
+}
 
 afterEach(() => {
   while (tempDirs.length > 0) {
     const dir = tempDirs.pop()
     if (dir) rmSync(dir, { recursive: true, force: true })
   }
+
+  process.env.OPENAI_BASE_URL = originalEnv.OPENAI_BASE_URL
+  process.env.OPENAI_API_BASE = originalEnv.OPENAI_API_BASE
 })
 
 function createTempAuthJson(payload: Record<string, unknown>): string {
@@ -62,12 +69,26 @@ describe('Codex provider config', () => {
   })
 
   test('resolves codexplan alias to Codex transport with reasoning', () => {
+    delete process.env.OPENAI_BASE_URL
+    delete process.env.OPENAI_API_BASE
+
     const resolved = resolveProviderRequest({ model: 'codexplan' })
     expect(resolved.transport).toBe('codex_responses')
     expect(resolved.resolvedModel).toBe('gpt-5.4')
     expect(resolved.reasoning).toEqual({ effort: 'high' })
   })
 
+  test('does not force Codex transport when a local non-Codex base URL is explicit', () => {
+    const resolved = resolveProviderRequest({
+      model: 'codexplan',
+      baseUrl: 'http://127.0.0.1:8080/v1',
+    })
+
+    expect(resolved.transport).toBe('chat_completions')
+    expect(resolved.baseUrl).toBe('http://127.0.0.1:8080/v1')
+    expect(resolved.resolvedModel).toBe('gpt-5.4')
+  })
+
   test('resolves codexplan to Codex transport even when OPENAI_BASE_URL is the string "undefined"', () => {
     // On Windows, env vars can leak as the literal string "undefined" instead of
     // the JS value undefined when not properly unset (issue #336).