mumucc 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mumucc",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Open-source AI coding assistant CLI with multi-model support (Anthropic, OpenAI/GPT, DeepSeek, GLM, Ollama, etc.), MCP integration, agent swarms, and out-of-the-box developer experience.",
   "type": "module",
   "license": "MIT",

package/shims/globals.ts

@@ -4,7 +4,7 @@
  */
 
 ;(globalThis as any).MACRO = {
-  VERSION: '0.1.6-mumucc',
+  VERSION: '0.1.8-mumucc',
   VERSION_CHANGELOG: '{}',
   BUILD_TIME: new Date().toISOString(),
   PACKAGE_URL: 'https://github.com/mumuxsy/mumucc',

package/src/commands/login/CustomProviderLogin.tsx

@@ -4,22 +4,24 @@
  * Allows users to configure any OpenAI-compatible API endpoint by providing:
  * 1. Provider name (for identification)
  * 2. Base URL (e.g., https://api.openai.com/v1)
- * 3. API Key
- * 4. API Format (Anthropic or OpenAI)
- * 5. Model ID(s)
+ * 3. API Format (Anthropic or OpenAI)
+ * 4. API Key
+ * 5. Model selection (auto-fetch from API + manual input)
  */
 import * as React from 'react'
 import { Box, Text } from '../../ink.js'
 import { Dialog } from '../../components/design-system/Dialog.js'
 import TextInput from '../../components/TextInput.js'
 import { Select } from '../../components/CustomSelect/index.js'
+import { ProviderModelSelector } from '../../components/ProviderModelSelector.js'
 import {
   saveProviderToSettings,
   type ThirdPartyProviderConfig,
+  type ThirdPartyModelConfig,
   type ApiFormat,
 } from '../../utils/model/thirdPartyProviders.js'
 
-type Step = 'name' | 'url' | 'format' | 'api-key' | 'models' | 'saving' | 'done'
+type Step = 'name' | 'url' | 'format' | 'api-key' | 'select-models' | 'saving' | 'done'
 
 interface CustomProviderLoginProps {
   onDone: (success: boolean, message: string) => void
@@ -33,14 +35,12 @@ export function CustomProviderLogin({
   const [baseUrl, setBaseUrl] = React.useState('')
   const [apiFormat, setApiFormat] = React.useState<ApiFormat>('openai')
   const [apiKey, setApiKey] = React.useState('')
-  const [modelsInput, setModelsInput] = React.useState('')
   const [error, setError] = React.useState<string | null>(null)
 
   // Cursor offset states for TextInput
   const [nameCursor, setNameCursor] = React.useState(0)
   const [urlCursor, setUrlCursor] = React.useState(0)
   const [keyCursor, setKeyCursor] = React.useState(0)
-  const [modelsCursor, setModelsCursor] = React.useState(0)
 
   const handleCancel = React.useCallback(() => {
     onDone(false, 'Custom provider setup cancelled')
@@ -85,25 +85,13 @@ export function CustomProviderLogin({
     // Allow empty key for local providers (Ollama, LM Studio)
     setError(null)
     setApiKey(trimmed)
-    setStep('models')
+    setStep('select-models')
   }, [])
 
-  const handleModelsSubmit = React.useCallback(
-    (value: string) => {
-      const trimmed = value.trim()
-      if (!trimmed) {
-        setError('At least one model ID is required')
-        return
-      }
-
+  const handleModelsSelected = React.useCallback(
+    (models: ThirdPartyModelConfig[]) => {
       setStep('saving')
 
-      // Parse model IDs from comma-separated input
-      const modelIds = trimmed
-        .split(',')
-        .map(m => m.trim())
-        .filter(Boolean)
-
       // Generate a safe provider ID from the name
       const providerId = providerName
         .toLowerCase()
@@ -116,28 +104,25 @@ export function CustomProviderLogin({
         baseUrl: baseUrl,
         apiFormat: apiFormat,
         apiKey: apiKey || undefined,
-        models: modelIds.map(id => ({
-          id,
-          displayName: id,
-        })),
+        models: models,
       }
 
       const result = saveProviderToSettings(providerConfig)
       if (result.error) {
         setError(`Failed to save: ${result.error.message}`)
-        setStep('models')
+        setStep('select-models')
         return
       }
 
       setStep('done')
-      const modelNames = modelIds.join(', ')
+      const modelNames = models.map(m => m.id).join(', ')
       onDone(
         true,
         `Custom provider "${providerName}" configured!\n` +
         `  URL: ${baseUrl}\n` +
         `  Format: ${apiFormat}\n` +
         `  Models: ${modelNames}\n` +
-        `  Use with: /model ${providerId}:${modelIds[0]}`,
+        `  Use with: /model ${providerId}:${models[0]?.id ?? 'model-id'}`,
       )
     },
     [providerName, baseUrl, apiFormat, apiKey, onDone],
@@ -238,6 +223,7 @@ export function CustomProviderLogin({
           <Text>Format: {apiFormat}</Text>
           <Text> </Text>
           <Text>Enter your API key (leave empty for local models):</Text>
+          <Text dimColor>  After this step, available models will be fetched automatically.</Text>
           <Text> </Text>
           {error && <Text color="red">{error}</Text>}
           <TextInput
@@ -257,32 +243,16 @@ export function CustomProviderLogin({
     )
   }
 
-  if (step === 'models') {
+  if (step === 'select-models') {
     return (
-      <Dialog title={dialogTitle} onCancel={handleCancel} color="permission">
-        <Box flexDirection="column">
-          <Text bold>Provider: {providerName}</Text>
-          <Text>URL: {baseUrl}</Text>
-          <Text>Format: {apiFormat}</Text>
-          <Text>Key: {apiKey ? '***' : '(none)'}</Text>
-          <Text> </Text>
-          <Text>Enter model ID(s), comma-separated:</Text>
-          <Text dimColor>  (e.g., "gpt-4o, gpt-4o-mini" or "deepseek-chat")</Text>
-          <Text> </Text>
-          {error && <Text color="red">{error}</Text>}
-          <TextInput
-            value={modelsInput}
-            onChange={setModelsInput}
-            onSubmit={handleModelsSubmit}
-            placeholder="model-id-1, model-id-2"
-            columns={80}
-            cursorOffset={modelsCursor}
-            onChangeCursorOffset={setModelsCursor}
-            focus={true}
-            showCursor={true}
-          />
-        </Box>
-      </Dialog>
+      <ProviderModelSelector
+        providerName={providerName}
+        baseUrl={baseUrl}
+        apiKey={apiKey}
+        apiFormat={apiFormat}
+        onDone={handleModelsSelected}
+        onCancel={handleCancel}
+      />
     )
   }
 

package/src/commands/login/ThirdPartyLogin.tsx

@@ -1,21 +1,23 @@
 /**
  * Interactive login flow for built-in third-party Anthropic-compatible providers.
  *
- * Flow: API key input → Validate & save to settings.
+ * Flow: API key input → Auto-fetch models → Interactive model selection → Save.
  * The provider is pre-selected by the LoginRouter in login.tsx.
  */
 import * as React from 'react'
 import { Box, Text } from '../../ink.js'
 import { Dialog } from '../../components/design-system/Dialog.js'
 import TextInput from '../../components/TextInput.js'
+import { ProviderModelSelector } from '../../components/ProviderModelSelector.js'
 import {
   BUILTIN_PROVIDERS,
   saveProviderToSettings,
   getResolvedProvider,
   type ThirdPartyProviderConfig,
+  type ThirdPartyModelConfig,
 } from '../../utils/model/thirdPartyProviders.js'
 
-type Step = 'enter-api-key' | 'saving' | 'done'
+type Step = 'enter-api-key' | 'select-models' | 'saving' | 'done'
 
 interface ThirdPartyLoginProps {
   /** Provider ID pre-selected from the login router */
@@ -33,9 +35,9 @@ export function ThirdPartyLogin({
   )
 
   const [step, setStep] = React.useState<Step>(() => {
-    // If provider already has a valid key, skip to done immediately
+    // If provider already has a valid key, skip to model selection
     if (provider && getResolvedProvider(provider.id)) {
-      return 'done'
+      return 'select-models'
     }
     return 'enter-api-key'
   })
@@ -43,14 +45,15 @@ export function ThirdPartyLogin({
   const [apiKey, setApiKey] = React.useState('')
   const [cursorOffset, setCursorOffset] = React.useState(0)
   const [error, setError] = React.useState<string | null>(null)
+  const [savedApiKey, setSavedApiKey] = React.useState<string>('')
 
-  // Handle the "already configured" case on mount
+  // Resolve existing API key for already-configured providers
   React.useEffect(() => {
-    if (step === 'done' && provider) {
-      onDone(
-        true,
-        `${provider.name} already configured (API key found). Models: ${provider.models.map(m => m.id).join(', ')}`,
-      )
+    if (step === 'select-models' && provider) {
+      const resolved = getResolvedProvider(provider.id)
+      if (resolved) {
+        setSavedApiKey(resolved.resolvedApiKey)
+      }
     }
   }, []) // eslint-disable-line react-hooks/exhaustive-deps
 
@@ -63,29 +66,40 @@ export function ThirdPartyLogin({
       }
       if (!provider) return
 
+      setSavedApiKey(trimmedKey)
+      setStep('select-models')
+    },
+    [provider],
+  )
+
+  const handleModelsSelected = React.useCallback(
+    (models: ThirdPartyModelConfig[]) => {
+      if (!provider) return
+
       setStep('saving')
 
-      // Save provider with the API key to user settings
+      // Save provider with API key + selected models
       const providerConfig: ThirdPartyProviderConfig = {
         ...provider,
-        apiKey: trimmedKey,
+        apiKey: savedApiKey || apiKey.trim(),
+        models: models.length > 0 ? models : provider.models,
       }
 
       const result = saveProviderToSettings(providerConfig)
       if (result.error) {
         setError(`Failed to save: ${result.error.message}`)
-        setStep('enter-api-key')
+        setStep('select-models')
         return
       }
 
       setStep('done')
-      const modelNames = provider.models.map(m => m.id).join(', ')
+      const modelNames = providerConfig.models.map(m => m.id).join(', ')
       onDone(
         true,
         `${provider.name} configured successfully! Available models: ${modelNames}`,
       )
     },
-    [provider, onDone],
+    [provider, savedApiKey, apiKey, onDone],
   )
 
   const handleCancel = React.useCallback(() => {
@@ -107,9 +121,11 @@ export function ThirdPartyLogin({
         <Box flexDirection="column">
           <Text>Endpoint: {provider.baseUrl}</Text>
           <Text>Format: {provider.apiFormat === 'openai' ? 'OpenAI Chat Completions' : 'Anthropic Messages'}</Text>
-          <Text>
-            Models:{' '}
-            {provider.models.map(m => m.id).join(', ')}
+          <Text dimColor>
+            Default models: {provider.models.map(m => m.id).join(', ')}
+          </Text>
+          <Text dimColor>
+            (After entering API key, you can select models from the provider)
           </Text>
           <Text> </Text>
           {error && (
@@ -133,6 +149,20 @@ export function ThirdPartyLogin({
     )
   }
 
+  if (step === 'select-models') {
+    return (
+      <ProviderModelSelector
+        providerName={provider.name}
+        baseUrl={provider.baseUrl}
+        apiKey={savedApiKey || apiKey.trim()}
+        apiFormat={provider.apiFormat ?? 'anthropic'}
+        presetModels={provider.models}
+        onDone={handleModelsSelected}
+        onCancel={handleCancel}
+      />
+    )
+  }
+
   if (step === 'saving') {
     return (
       <Dialog

package/src/components/ProviderModelSelector.tsx

@@ -0,0 +1,321 @@
+/**
+ * Interactive model selector component for third-party provider login flows.
+ *
+ * Features:
+ * - Auto-fetch available models from provider's API endpoint
+ * - Search/filter models by typing keywords
+ * - Multi-select models with checkboxes (Space to toggle, Enter to confirm)
+ * - Manual input for additional model IDs not in the list
+ *
+ * Used by ThirdPartyLogin and CustomProviderLogin after API key configuration.
+ */
+import * as React from 'react'
+import { Box, Text } from '../ink.js'
+import { Dialog } from './design-system/Dialog.js'
+import TextInput from './TextInput.js'
+import { SelectMulti } from './CustomSelect/index.js'
+import type { OptionWithDescription } from './CustomSelect/select.js'
+import {
+  fetchProviderModels,
+  filterModels,
+  type FetchedModel,
+} from '../utils/model/fetchModels.js'
+import type { ApiFormat, ThirdPartyModelConfig } from '../utils/model/thirdPartyProviders.js'
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface ModelSelectorProps {
+  /** Provider display name */
+  providerName: string
+  /** Provider's base URL */
+  baseUrl: string
+  /** API key for fetching models */
+  apiKey: string
+  /** API format */
+  apiFormat: ApiFormat
+  /** Pre-configured models (from BUILTIN_PROVIDERS) */
+  presetModels?: ThirdPartyModelConfig[]
+  /** Callback when model selection is complete */
+  onDone: (models: ThirdPartyModelConfig[]) => void
+  /** Callback when user cancels */
+  onCancel: () => void
+}
+
+type Step = 'fetching' | 'select' | 'manual-input' | 'done'
+
+// ─── Component ───────────────────────────────────────────────────────────────
+
+export function ProviderModelSelector({
+  providerName,
+  baseUrl,
+  apiKey,
+  apiFormat,
+  presetModels,
+  onDone,
+  onCancel,
+}: ModelSelectorProps): React.ReactNode {
+  const [step, setStep] = React.useState<Step>('fetching')
+  const [fetchedModels, setFetchedModels] = React.useState<FetchedModel[]>([])
+  const [fetchError, setFetchError] = React.useState<string | null>(null)
+  const [searchQuery, setSearchQuery] = React.useState('')
+  const [searchCursor, setSearchCursor] = React.useState(0)
+  const [selectedModelIds, setSelectedModelIds] = React.useState<string[]>([])
+  const [manualInput, setManualInput] = React.useState('')
+  const [manualCursor, setManualCursor] = React.useState(0)
+
+  // Auto-fetch models on mount
+  React.useEffect(() => {
+    let cancelled = false
+
+    const doFetch = async () => {
+      const result = await fetchProviderModels(baseUrl, apiKey, apiFormat)
+
+      if (cancelled) return
+
+      if (result.models.length > 0) {
+        setFetchedModels(result.models)
+
+        // Pre-select preset models if they match
+        if (presetModels && presetModels.length > 0) {
+          const presetIds = new Set(presetModels.map(m => m.id))
+          const matched = result.models
+            .filter(m => presetIds.has(m.id))
+            .map(m => m.id)
+          setSelectedModelIds(matched)
+        }
+      } else if (result.error) {
+        setFetchError(result.error)
+      }
+
+      setStep('select')
+    }
+
+    doFetch()
+    return () => { cancelled = true }
+  }, []) // eslint-disable-line react-hooks/exhaustive-deps
+
+  // Merge fetched models with preset models (presets that weren't fetched)
+  const allModels = React.useMemo(() => {
+    const fetchedIds = new Set(fetchedModels.map(m => m.id))
+    const merged = [...fetchedModels]
+
+    // Add preset models not found in fetched list
+    if (presetModels) {
+      for (const pm of presetModels) {
+        if (!fetchedIds.has(pm.id)) {
+          merged.push({
+            id: pm.id,
+            displayName: pm.displayName || pm.id,
+          })
+        }
+      }
+    }
+
+    return merged
+  }, [fetchedModels, presetModels])
+
+  // Filter models by search query
+  const filteredModels = React.useMemo(
+    () => filterModels(allModels, searchQuery),
+    [allModels, searchQuery],
+  )
+
+  // Build options for SelectMulti
+  const selectOptions: OptionWithDescription<string>[] = React.useMemo(
+    () =>
+      filteredModels.map(m => ({
+        label: m.displayName || m.id,
+        value: m.id,
+        description: m.id !== m.displayName ? m.id : undefined,
+      })),
+    [filteredModels],
+  )
+
+  // Handle search input submit — switch to manual input mode
+  const handleSearchSubmit = React.useCallback(() => {
+    // If user presses Enter in search, treat it as wanting to go to manual input
+    if (searchQuery.trim() && filteredModels.length === 0) {
+      setManualInput(searchQuery)
+      setStep('manual-input')
+    }
+  }, [searchQuery, filteredModels])
+
+  // Handle multi-select submit
+  const handleSelectSubmit = React.useCallback(
+    (values: string[]) => {
+      setSelectedModelIds(values)
+      // After selection, ask if user wants to add manual models
+      setStep('manual-input')
+    },
+    [],
+  )
+
+  // Handle manual input submit — finalize model list
+  const handleManualSubmit = React.useCallback(
+    (value: string) => {
+      const trimmed = value.trim()
+      const manualIds = trimmed
+        ? trimmed.split(',').map(m => m.trim()).filter(Boolean)
+        : []
+
+      // Combine selected + manual models
+      const allIds = new Set([...selectedModelIds, ...manualIds])
+
+      if (allIds.size === 0) {
+        // If nothing selected and no manual input, use presets or require at least one
+        if (presetModels && presetModels.length > 0) {
+          onDone(presetModels)
+          return
+        }
+        // Try again
+        setStep('select')
+        return
+      }
+
+      // Build final model configs
+      const models: ThirdPartyModelConfig[] = []
+      for (const id of allIds) {
+        const fetched = allModels.find(m => m.id === id)
+        models.push({
+          id,
+          displayName: fetched?.displayName || id,
+        })
+      }
+
+      onDone(models)
+    },
+    [selectedModelIds, allModels, presetModels, onDone],
+  )
+
+  // Skip manual step — finalize with current selection
+  const handleSkipManual = React.useCallback(() => {
+    if (selectedModelIds.length === 0 && presetModels && presetModels.length > 0) {
+      onDone(presetModels)
+      return
+    }
+
+    const models: ThirdPartyModelConfig[] = selectedModelIds.map(id => {
+      const fetched = allModels.find(m => m.id === id)
+      return {
+        id,
+        displayName: fetched?.displayName || id,
+      }
+    })
+    onDone(models.length > 0 ? models : (presetModels ?? []))
+  }, [selectedModelIds, allModels, presetModels, onDone])
+
+  // ─── Render ────────────────────────────────────────────────────────────────
+
+  if (step === 'fetching') {
+    return (
+      <Dialog title={`${providerName} - Fetching Models`} onCancel={onCancel} color="permission">
+        <Box flexDirection="column">
+          <Text>Fetching available models from {baseUrl}...</Text>
+          <Text dimColor>This may take a few seconds.</Text>
+        </Box>
+      </Dialog>
+    )
+  }
+
+  if (step === 'select') {
+    const hasModels = selectOptions.length > 0
+
+    return (
+      <Dialog
+        title={`${providerName} - Select Models`}
+        onCancel={onCancel}
+        color="permission"
+      >
+        <Box flexDirection="column">
+          {fetchError && (
+            <Text color="yellow">Note: {fetchError}</Text>
+          )}
+
+          {/* Search filter */}
+          <Box>
+            <Text>Search: </Text>
+            <TextInput
+              value={searchQuery}
+              onChange={setSearchQuery}
+              onSubmit={handleSearchSubmit}
+              placeholder="Type to filter models... (Enter to add manually)"
+              columns={60}
+              cursorOffset={searchCursor}
+              onChangeCursorOffset={setSearchCursor}
+              focus={!hasModels}
+              showCursor={true}
+            />
+          </Box>
+
+          <Text dimColor>
+            {hasModels
+              ? `Found ${allModels.length} models. Space=toggle, Enter=confirm selected.`
+              : 'No models found. Type model ID and press Enter to add manually.'}
+          </Text>
+
+          {hasModels && (
+            <Box flexDirection="column" marginTop={1}>
+              <SelectMulti
+                options={selectOptions}
+                defaultValue={selectedModelIds}
+                visibleOptionCount={10}
+                submitButtonText="Confirm Selection"
+                onSubmit={handleSelectSubmit}
+                onCancel={onCancel}
+                hideIndexes={false}
+              />
+            </Box>
+          )}
+
+          {!hasModels && (
+            <Box marginTop={1}>
+              <Text dimColor>
+                Press Escape to cancel, or type model IDs and press Enter.
+              </Text>
+            </Box>
+          )}
+        </Box>
+      </Dialog>
+    )
+  }
+
+  if (step === 'manual-input') {
+    return (
+      <Dialog
+        title={`${providerName} - Add Extra Models`}
+        onCancel={handleSkipManual}
+        color="permission"
+      >
+        <Box flexDirection="column">
+          {selectedModelIds.length > 0 && (
+            <>
+              <Text bold>Selected ({selectedModelIds.length}):</Text>
+              <Text color="green">
+                {selectedModelIds.join(', ')}
+              </Text>
+              <Text> </Text>
+            </>
+          )}
+          <Text>Add extra model IDs (comma-separated), or press Enter to finish:</Text>
+          <Text dimColor>
+            For models not in the list, e.g.: custom-model-v1, another-model
+          </Text>
+          <Text> </Text>
+          <TextInput
+            value={manualInput}
+            onChange={setManualInput}
+            onSubmit={handleManualSubmit}
+            placeholder="(press Enter to skip)"
+            columns={80}
+            cursorOffset={manualCursor}
+            onChangeCursorOffset={setManualCursor}
+            focus={true}
+            showCursor={true}
+          />
+        </Box>
+      </Dialog>
+    )
+  }
+
+  return null
+}

package/src/utils/model/fetchModels.ts

@@ -0,0 +1,363 @@
+/**
+ * Dynamic model discovery from provider API endpoints.
+ *
+ * Supports fetching available models from:
+ * - OpenAI-compatible `/v1/models` endpoints (OpenAI, DeepSeek, Ollama, etc.)
+ * - Anthropic-compatible endpoints (custom model listing)
+ *
+ * Used by login flows to auto-discover models after API key configuration.
+ */
+
+import { logForDebugging } from '../debug.js'
+import type { ApiFormat } from './thirdPartyProviders.js'
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface FetchedModel {
+  /** Model ID as recognized by the provider's API */
+  id: string
+  /** Human-readable name (from the API or derived from ID) */
+  displayName: string
+  /** Owner/organization (if available) */
+  ownedBy?: string
+  /** Creation timestamp (if available) */
+  created?: number
+}
+
+export interface FetchModelsResult {
+  /** Successfully fetched models */
+  models: FetchedModel[]
+  /** Error message if fetch failed (models may still have partial results) */
+  error?: string
+}
+
+// ─── Model ID formatting ────────────────────────────────────────────────────
+
+/**
+ * Derive a human-readable display name from a model ID.
+ * Examples:
+ *   "gpt-4o-mini" → "GPT 4o Mini"
+ *   "deepseek-chat" → "Deepseek Chat"
+ *   "meta-llama/Llama-3.3-70B" → "Llama 3.3 70B"
+ */
+function formatModelDisplayName(modelId: string): string {
+  // Strip org prefix (e.g., "meta-llama/Llama-3.3-70B" → "Llama-3.3-70B")
+  const baseName = modelId.includes('/') ? modelId.split('/').pop()! : modelId
+  return baseName
+    .replace(/[-_]/g, ' ')
+    .replace(/\b\w/g, c => c.toUpperCase())
+    .trim()
+}
+
+// ─── Known chat model patterns ──────────────────────────────────────────────
+
+/**
+ * Filter patterns for identifying chat/completion models vs embedding/moderation/etc.
+ * Models matching these patterns are considered usable for chat completions.
+ */
+const CHAT_MODEL_PATTERNS = [
+  /gpt-/i,
+  /o[1-9]/i,
+  /claude/i,
+  /deepseek/i,
+  /llama/i,
+  /qwen/i,
+  /gemini/i,
+  /mixtral/i,
+  /mistral/i,
+  /glm/i,
+  /minimax/i,
+  /kimi/i,
+  /yi-/i,
+  /command/i,
+  /phi-/i,
+  /codestral/i,
+  /dbrx/i,
+  /chat/i,
+  /instruct/i,
+  /turbo/i,
+  /preview/i,
+  /coding/i,
+]
+
+/**
+ * Patterns for models we should exclude (embeddings, moderation, tts, etc.)
+ */
+const EXCLUDE_PATTERNS = [
+  /^text-embedding/i,
+  /^text-moderation/i,
+  /^text-search/i,
+  /^tts-/i,
+  /^whisper/i,
+  /^dall-e/i,
+  /^davinci/i,
+  /^babbage/i,
+  /^ada$/i,
+  /^curie$/i,
+  /-embed/i,
+  /-embedding/i,
+  /^embedding/i,
+]
+
+/**
+ * Check if a model ID likely represents a chat/completion model.
+ */
+function isChatModel(modelId: string): boolean {
+  // First check exclusions
+  if (EXCLUDE_PATTERNS.some(p => p.test(modelId))) return false
+  // Then check inclusions — if none match, still include it (could be a custom model)
+  // Only filter out if we're confident it's not a chat model
+  return true
+}
+
+// ─── Fetch implementations ──────────────────────────────────────────────────
+
+/**
+ * Fetch models from an OpenAI-compatible `/v1/models` endpoint.
+ */
+async function fetchOpenAIModels(
+  baseUrl: string,
+  apiKey: string,
+  timeoutMs = 10000,
+): Promise<FetchModelsResult> {
+  // Normalize base URL
+  const url = baseUrl.replace(/\/+$/, '')
+  const modelsUrl = `${url}/models`
+
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+
+    const headers: Record<string, string> = {
+      'Accept': 'application/json',
+    }
+    if (apiKey) {
+      headers['Authorization'] = `Bearer ${apiKey}`
+    }
+
+    const response = await fetch(modelsUrl, {
+      method: 'GET',
+      headers,
+      signal: controller.signal,
+    })
+    clearTimeout(timer)
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => '')
+      return {
+        models: [],
+        error: `HTTP ${response.status}: ${text.slice(0, 200)}`,
+      }
+    }
+
+    const data = await response.json() as {
+      data?: Array<{ id: string; owned_by?: string; created?: number }>
+      object?: string
+      models?: Array<{ name?: string; model?: string; details?: unknown }>
+    }
+
+    let models: FetchedModel[] = []
+
+    // Standard OpenAI format: { data: [{ id, owned_by, created }] }
+    if (data.data && Array.isArray(data.data)) {
+      models = data.data
+        .filter(m => m.id && isChatModel(m.id))
+        .map(m => ({
+          id: m.id,
+          displayName: formatModelDisplayName(m.id),
+          ownedBy: m.owned_by,
+          created: m.created,
+        }))
+    }
+    // Ollama format: { models: [{ name, model, details }] }
+    else if (data.models && Array.isArray(data.models)) {
+      models = data.models
+        .filter(m => m.name || m.model)
+        .map(m => {
+          const id = (m.model || m.name)!
+          return {
+            id,
+            displayName: formatModelDisplayName(id),
+          }
+        })
+    }
+
+    // Sort by name for better UX
+    models.sort((a, b) => a.id.localeCompare(b.id))
+
+    logForDebugging(`[FetchModels] Fetched ${models.length} models from ${modelsUrl}`)
+    return { models }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e)
+    logForDebugging(`[FetchModels] Failed to fetch from ${modelsUrl}: ${msg}`)
+    return {
+      models: [],
+      error: msg.includes('abort')
+        ? `Request timed out after ${timeoutMs / 1000}s`
+        : `Fetch failed: ${msg}`,
+    }
+  }
+}
+
+/**
+ * Fetch models from an Anthropic-compatible endpoint.
+ * Most Anthropic-compatible providers don't have a standard models listing endpoint,
+ * so this is best-effort. We try `/v1/models` first, then fall back.
+ */
+async function fetchAnthropicModels(
+  baseUrl: string,
+  apiKey: string,
+  timeoutMs = 10000,
+): Promise<FetchModelsResult> {
+  // Try the standard endpoint first (some providers support it)
+  const url = baseUrl.replace(/\/+$/, '')
+
+  // Try /models endpoint
+  for (const endpoint of ['/models', '/v1/models']) {
+    try {
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), timeoutMs)
+
+      const response = await fetch(`${url}${endpoint}`, {
+        method: 'GET',
+        headers: {
+          'Accept': 'application/json',
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        signal: controller.signal,
+      })
+      clearTimeout(timer)
+
+      if (response.ok) {
+        const data = await response.json() as {
+          data?: Array<{ id: string; display_name?: string; type?: string }>
+        }
+        if (data.data && Array.isArray(data.data)) {
+          const models = data.data
+            .filter(m => m.id && m.type !== 'embedding')
+            .map(m => ({
+              id: m.id,
+              displayName: m.display_name || formatModelDisplayName(m.id),
+            }))
+          if (models.length > 0) {
+            logForDebugging(`[FetchModels] Fetched ${models.length} Anthropic models from ${url}${endpoint}`)
+            return { models }
+          }
+        }
+      }
+    } catch {
+      // Try next endpoint
+    }
+  }
+
+  return {
+    models: [],
+    error: 'This provider does not support model listing. You can add models manually.',
+  }
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Fetch available models from a provider's API endpoint.
+ *
+ * @param baseUrl - The provider's base URL
+ * @param apiKey - API key for authentication
+ * @param apiFormat - API format ('openai' or 'anthropic')
+ * @param timeoutMs - Request timeout in milliseconds (default: 10s)
+ */
+export async function fetchProviderModels(
+  baseUrl: string,
+  apiKey: string,
+  apiFormat: ApiFormat = 'openai',
+  timeoutMs = 10000,
+): Promise<FetchModelsResult> {
+  if (!baseUrl) {
+    return { models: [], error: 'No base URL provided' }
+  }
+
+  logForDebugging(`[FetchModels] Fetching models from ${baseUrl} (format: ${apiFormat})`)
+
+  if (apiFormat === 'openai') {
+    // For OpenAI format, also try Ollama's native endpoint
+    const result = await fetchOpenAIModels(baseUrl, apiKey, timeoutMs)
+
+    // If standard /models failed and URL looks like Ollama, try /api/tags
+    if (result.models.length === 0 && baseUrl.includes('localhost')) {
+      const ollamaResult = await fetchOllamaModels(baseUrl, timeoutMs)
+      if (ollamaResult.models.length > 0) {
+        return ollamaResult
+      }
+    }
+
+    return result
+  }
+
+  return fetchAnthropicModels(baseUrl, apiKey, timeoutMs)
+}
+
+/**
+ * Fetch models from Ollama's native `/api/tags` endpoint.
+ */
+async function fetchOllamaModels(
+  baseUrl: string,
+  timeoutMs = 10000,
+): Promise<FetchModelsResult> {
+  // Ollama's native API is on port 11434, extract host
+  const url = new URL(baseUrl)
+  const ollamaUrl = `${url.protocol}//${url.hostname}:11434/api/tags`
+
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeoutMs)
+
+    const response = await fetch(ollamaUrl, {
+      method: 'GET',
+      headers: { 'Accept': 'application/json' },
+      signal: controller.signal,
+    })
+    clearTimeout(timer)
+
+    if (!response.ok) {
+      return { models: [], error: `Ollama API returned ${response.status}` }
+    }
+
+    const data = await response.json() as {
+      models?: Array<{ name: string; model?: string; size?: number; details?: unknown }>
+    }
+
+    if (!data.models || !Array.isArray(data.models)) {
+      return { models: [], error: 'Unexpected Ollama response format' }
+    }
+
+    const models = data.models.map(m => ({
+      id: m.name,
+      displayName: formatModelDisplayName(m.name),
+    }))
+
+    logForDebugging(`[FetchModels] Fetched ${models.length} models from Ollama`)
+    return { models }
+  } catch (e) {
+    return {
+      models: [],
+      error: `Ollama fetch failed: ${e instanceof Error ? e.message : String(e)}`,
+    }
+  }
+}
+
+/**
+ * Filter models by a search query (fuzzy matching on ID and display name).
+ */
+export function filterModels(
+  models: FetchedModel[],
+  query: string,
+): FetchedModel[] {
+  if (!query.trim()) return models
+
+  const terms = query.toLowerCase().split(/\s+/)
+  return models.filter(m => {
+    const searchable = `${m.id} ${m.displayName}`.toLowerCase()
+    return terms.every(term => searchable.includes(term))
+  })
+}

package/src/utils/model/modelOptions.ts

@@ -1,6 +1,7 @@
 // biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
 import { getInitialMainLoopModel } from '../../bootstrap/state.js'
 import {
+  getAnthropicApiKey,
   isClaudeAISubscriber,
   isMaxSubscriber,
   isTeamPremiumSubscriber,
@@ -270,6 +271,18 @@ function getOpusPlanOption(): ModelOption {
 // @[MODEL LAUNCH]: Update the model picker lists below to include/reorder options for the new model.
 // Each user tier (ant, Max/Team Premium, Pro/Team Standard/Enterprise, PAYG 1P, PAYG 3P) has its own list.
 function getModelOptionsBase(fastMode = false): ModelOption[] {
+  // If no Anthropic auth is configured (no API key, no OAuth token),
+  // skip Anthropic models entirely — user only sees third-party models
+  // from providers they've configured via /login.
+  const hasAnthropicAuth =
+    !!getAnthropicApiKey() ||
+    !!process.env.CLAUDE_CODE_USE_BEDROCK ||
+    !!process.env.CLAUDE_CODE_USE_VERTEX ||
+    !!process.env.CLAUDE_CODE_USE_FOUNDRY
+  if (!hasAnthropicAuth) {
+    return []
+  }
+
   if (process.env.USER_TYPE === 'ant') {
     // Build options from antModels config
     const antModelOptions: ModelOption[] = getAntModels().map(m => ({

package/src/utils/model/thirdPartyProviders.ts

@@ -245,6 +245,11 @@ export function getAllThirdPartyModels(): Array<{
   }> = []
 
   for (const provider of providers) {
+    // Only show models from providers that have a configured API key.
+    // This filters /model to only display models the user can actually use.
+    const resolved = getResolvedProvider(provider.id)
+    if (!resolved) continue
+
     for (const model of provider.models) {
       models.push({
         qualifiedId: `${provider.id}${PROVIDER_MODEL_SEPARATOR}${model.id}`,