ethagent 2.1.1 → 2.3.0

package/src/models/ModelPicker.tsx

@@ -25,8 +25,11 @@ import {
   type GgufMachineFit,
 } from './modelRecommendation.js'
 import { hasKey, rmKey, setKey } from '../storage/secrets.js'
+import { OpenAIOAuthService } from '../auth/openaiOAuth/index.js'
+import { hasOpenAIOAuthCredentials, rmOpenAIOAuthCredentials } from '../auth/openaiOAuth/credentials.js'
+import { openExternalUrl } from '../utils/openExternal.js'
 import { defaultModelFor, type EthagentConfig, type ProviderId } from '../storage/config.js'
-import { clearModelCatalogCache, discoverProviderModels, type ModelCatalogResult } from './catalog.js'
+import { clearModelCatalogCache, discoverProviderModels, isOpenAIOAuthAllowedModel, OPENAI_OAUTH_DEFAULT_MODEL, type ModelCatalogResult } from './catalog.js'
 import { contextWindowInfo } from '../runtime/compaction.js'
 import {
   createHfDownloadPlan,
@@ -56,6 +59,7 @@ import {
   LOCAL_MODEL_LINK_HINT,
   MODEL_PICKER_CLOUD_PROVIDERS,
   orderModelsForContextFit,
+  type CloudCredentialKind,
   type CloudProviderId,
   type ModelPickerContextFit,
   type ModelPickerOptionsData,
@@ -89,6 +93,8 @@ type State =
   | { kind: 'catalog'; provider: CloudProviderId; data: LoadedData }
   | { kind: 'keyEntry'; provider: CloudProviderId; action: 'set' | 'edit'; data: LoadedData; submitting: boolean; error?: string }
   | { kind: 'keyManage'; provider: CloudProviderId; data: LoadedData; submitting: boolean; error?: string }
+  | { kind: 'oauthManage'; data: LoadedData; submitting: boolean; error?: string }
+  | { kind: 'oauthLogin'; data: LoadedData; phase: 'waiting' | 'exchanging' | 'error'; url?: string; message?: string }
   | { kind: 'hfInput'; data: LoadedData; error?: string }
   | { kind: 'hfLoading'; data: LoadedData; input: string }
   | { kind: 'hfFilePick'; data: LoadedData; input: string; repo: HuggingFaceRepoInfo; files: HuggingFaceSibling[] }
@@ -119,18 +125,29 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({
 }) => {
   const [state, setState] = useState<State>({ kind: 'loading' })
   const hfAbortRef = useRef<AbortController | null>(null)
+  const oauthServiceRef = useRef<OpenAIOAuthService | null>(null)
 
   useEffect(() => {
     let cancelled = false
     void (async () => {
-      const [llamaCpp, hfModels, machineSpec, keyEntries] = await Promise.all([
+      const [llamaCpp, hfModels, machineSpec, keyEntries, openaiOauth] = await Promise.all([
         probeLlamaCpp(),
         loadHfPickerModels(),
         detectSpec(),
         Promise.all(MODEL_PICKER_CLOUD_PROVIDERS.map(async p => [p, await hasKey(p)] as const)),
+        hasOpenAIOAuthCredentials(),
       ])
       if (cancelled) return
-      const cloudKeys = Object.fromEntries(keyEntries) as Partial<Record<ProviderId, boolean>>
+      const rawCloudKeys = Object.fromEntries(keyEntries) as Partial<Record<ProviderId, boolean>>
+      const cloudKeys: Partial<Record<ProviderId, boolean>> = {
+        ...rawCloudKeys,
+        openai: rawCloudKeys.openai === true || openaiOauth,
+      }
+      const cloudCredentialKinds: Partial<Record<ProviderId, CloudCredentialKind>> = {}
+      if (openaiOauth) cloudCredentialKinds.openai = 'oauth'
+      else if (rawCloudKeys.openai === true) cloudCredentialKinds.openai = 'apikey'
+      if (rawCloudKeys.anthropic === true) cloudCredentialKinds.anthropic = 'apikey'
+      if (rawCloudKeys.gemini === true) cloudCredentialKinds.gemini = 'apikey'
       const catalogEntries = await Promise.all(
         MODEL_PICKER_CLOUD_PROVIDERS
           .filter(provider => cloudKeys[provider])
@@ -144,6 +161,7 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({
         machineSpec,
         cloudKeys,
         cloudCatalogs,
+        cloudCredentialKinds,
       }
       if (featuredHfRepo) {
         const installedFeatured = await findInstalledHfModelForInput(featuredHfRepo)
@@ -163,6 +181,8 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({
 
   useEffect(() => () => {
     hfAbortRef.current?.abort()
+    oauthServiceRef.current?.cleanup()
+    oauthServiceRef.current = null
   }, [])
 
   if (state.kind === 'loading') {
@@ -569,7 +589,45 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({
                 setState({ kind: 'list', data: state.data })
                 return
               }
-              void deleteKey(state, currentConfig, setState)
+              void deleteKey(state, currentConfig, setState, onPick, currentProvider)
+            }}
+            onCancel={() => setState({ kind: 'list', data: state.data })}
+          />
+        )}
+        {error ? <Text color={theme.accentError}>{error}</Text> : null}
+      </Surface>
+    )
+  }
+
+  if (state.kind === 'oauthManage') {
+    const { submitting, error } = state
+    return (
+      <Surface
+        title="ChatGPT Sign-in"
+        subtitle="Manage your ChatGPT sign-in."
+        footer="enter select · esc back"
+      >
+        {submitting ? (
+          <Spinner label="signing out..." />
+        ) : (
+          <Select
+            options={[
+              { value: 'hdr:account', label: 'Account', disabled: true, role: 'section', bold: true },
+              { value: 'signin', label: 'Sign in Again', indent: 2 },
+              { value: 'signout', label: 'Sign Out', indent: 2 },
+              { value: 'hdr:nav', label: 'Navigation', disabled: true, role: 'section', bold: true },
+              { value: 'cancel', label: 'Back', indent: 2 },
+            ]}
+            onSubmit={(value) => {
+              if (value === 'signin') {
+                void startOpenAIOAuthFlow(state.data, currentConfig, setState, oauthServiceRef, onPick)
+                return
+              }
+              if (value === 'cancel') {
+                setState({ kind: 'list', data: state.data })
+                return
+              }
+              void signOutOAuth(state, currentConfig, setState, onPick, currentProvider)
             }}
             onCancel={() => setState({ kind: 'list', data: state.data })}
           />
@@ -579,6 +637,70 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({
     )
   }
 
+  if (state.kind === 'oauthLogin') {
+    if (state.phase === 'error') {
+      return (
+        <Surface
+          title="OpenAI Sign-in Failed"
+          subtitle={state.message ?? 'Sign-in did not complete.'}
+          tone="error"
+          footer="enter select · esc back"
+        >
+          <Select<'retry' | 'apikey' | 'back'>
+            options={[
+              { value: 'retry', label: 'Try Again' },
+              { value: 'apikey', label: 'Add API Key Instead' },
+              { value: 'back', label: 'Back To Picker' },
+            ]}
+            onSubmit={choice => {
+              if (choice === 'retry') void startOpenAIOAuthFlow(state.data, currentConfig, setState, oauthServiceRef, onPick)
+              else if (choice === 'apikey') setState({ kind: 'keyEntry', provider: 'openai', action: 'set', data: state.data, submitting: false })
+              else setState({ kind: 'list', data: state.data })
+            }}
+            onCancel={() => setState({ kind: 'list', data: state.data })}
+          />
+        </Surface>
+      )
+    }
+    if (state.phase === 'exchanging') {
+      return (
+        <Surface title="Finishing OpenAI Sign-in" subtitle="Exchanging credentials with auth.openai.com.">
+          <Spinner label="completing sign-in..." />
+        </Surface>
+      )
+    }
+    return (
+      <Surface
+        title="Sign in with ChatGPT"
+        subtitle="Opened your browser to auth.openai.com. Approve to continue."
+        footer="esc cancel"
+      >
+        <Spinner label="waiting for browser sign-in..." />
+        {state.url ? (
+          <Box flexDirection="column" marginTop={1}>
+            <Text color={theme.dim}>If the browser did not open, visit:</Text>
+            <Text color={theme.dim}>{state.url}</Text>
+          </Box>
+        ) : null}
+        <Box marginTop={1}>
+          <Select<'cancel'>
+            options={[{ value: 'cancel', label: 'Cancel Sign-in' }]}
+            onSubmit={() => {
+              oauthServiceRef.current?.cleanup()
+              oauthServiceRef.current = null
+              setState({ kind: 'list', data: state.data })
+            }}
+            onCancel={() => {
+              oauthServiceRef.current?.cleanup()
+              oauthServiceRef.current = null
+              setState({ kind: 'list', data: state.data })
+            }}
+          />
+        </Box>
+      </Surface>
+    )
+  }
+
   if (state.kind === 'catalog') {
     const catalog = state.data.cloudCatalogs[state.provider]
     const options = buildCatalogOptions(state.provider, catalog, currentProvider, currentModel, contextFit)
@@ -648,7 +770,7 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({
           options={options}
           initialIndex={initialIndex === -1 ? 0 : initialIndex}
           maxVisible={12}
-          onSubmit={(value) => handleSubmit(value, state, setState, onPick, onCancel)}
+          onSubmit={(value) => handleSubmit(value, state, setState, onPick, onCancel, currentConfig, oauthServiceRef)}
           onCancel={() => setState({ kind: 'list', data: state.data })}
         />
       </Surface>
@@ -669,7 +791,7 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({
         options={options}
         initialIndex={initialIndex === -1 ? 0 : initialIndex}
         maxVisible={10}
-        onSubmit={(value) => handleSubmit(value, state, setState, onPick, onCancel)}
+        onSubmit={(value) => handleSubmit(value, state, setState, onPick, onCancel, currentConfig, oauthServiceRef)}
         onCancel={onCancel}
       />
     </Surface>
@@ -682,6 +804,8 @@ function handleSubmit(
   setState: (s: State) => void,
   onPick: (sel: ModelPickerSelection) => void,
   onCancel: () => void,
+  currentConfig: EthagentConfig,
+  oauthServiceRef: React.MutableRefObject<OpenAIOAuthService | null>,
 ): void {
   if (value.startsWith('hdr:')) return
   if (value === 'cancel') {
@@ -727,12 +851,20 @@ function handleSubmit(
     const parsed = parseKeyValue(value)
     if (!parsed) return
     if (parsed.action === 'manage') {
+      if (parsed.provider === 'openai' && state.data.cloudCredentialKinds?.openai === 'oauth') {
+        setState({ kind: 'oauthManage', data: state.data, submitting: false })
+        return
+      }
       setState({ kind: 'keyManage', provider: parsed.provider, data: state.data, submitting: false })
       return
     }
     setState({ kind: 'keyEntry', provider: parsed.provider, action: parsed.action, data: state.data, submitting: false })
     return
   }
+  if (value === 'oauth:openai') {
+    void startOpenAIOAuthFlow(state.data, currentConfig, setState, oauthServiceRef, onPick)
+    return
+  }
   if (value.startsWith('catalog:')) {
     const provider = value.slice('catalog:'.length)
     if (isCloudProvider(provider)) setState({ kind: 'catalog', provider, data: state.data })
@@ -908,36 +1040,144 @@ async function submitKey(
   }
 }
 
+async function startOpenAIOAuthFlow(
+  data: LoadedData,
+  currentConfig: EthagentConfig,
+  setState: (s: State) => void,
+  serviceRef: React.MutableRefObject<OpenAIOAuthService | null>,
+  onPick: (sel: ModelPickerSelection) => void,
+): Promise<void> {
+  serviceRef.current?.cleanup()
+  const service = new OpenAIOAuthService()
+  serviceRef.current = service
+  setState({ kind: 'oauthLogin', data, phase: 'waiting' })
+  try {
+    const result = await service.start(authUrl => {
+      openExternalUrl(authUrl)
+      setState({ kind: 'oauthLogin', data, phase: 'waiting', url: authUrl })
+    })
+    if (serviceRef.current !== service) return
+    setState({ kind: 'oauthLogin', data, phase: 'exchanging' })
+    if (result.kind === 'apikey') {
+      if (typeof result.apiKey !== 'string' || result.apiKey.length === 0) {
+        throw new Error(`OAuth result was apikey kind but apiKey is ${typeof result.apiKey}; refusing to store.`)
+      }
+      try {
+        await setKey('openai', result.apiKey)
+      } catch (err) {
+        throw new Error(`Storing the OpenAI API key failed: ${err instanceof Error ? err.message : String(err)}`)
+      }
+    }
+    let refreshed: LoadedData
+    try {
+      refreshed = await refreshProviderKeyState(data, currentConfig, 'openai')
+    } catch (err) {
+      throw new Error(`Refreshing the OpenAI provider state failed: ${err instanceof Error ? err.message : String(err)}`)
+    }
+    if (serviceRef.current !== service) return
+    serviceRef.current = null
+    if (result.kind === 'oauth-only' && !isOpenAIOAuthAllowedModel(currentConfig.model)) {
+      onPick({ kind: 'cloud', provider: 'openai', model: OPENAI_OAUTH_DEFAULT_MODEL, keyJustSet: true })
+      return
+    }
+    setState({ kind: 'list', data: refreshed })
+  } catch (err: unknown) {
+    if (serviceRef.current !== service) return
+    serviceRef.current = null
+    const message = err instanceof Error ? err.message : String(err)
+    if (message === 'OpenAI sign-in was cancelled.') {
+      setState({ kind: 'list', data })
+      return
+    }
+    setState({ kind: 'oauthLogin', data, phase: 'error', message })
+  }
+}
+
 async function deleteKey(
   state: Extract<State, { kind: 'keyManage' }>,
   currentConfig: EthagentConfig,
   setState: (s: State) => void,
+  onPick: (sel: ModelPickerSelection) => void,
+  currentProvider: ProviderId,
 ): Promise<void> {
   setState({ ...state, submitting: true, error: undefined })
   try {
     await rmKey(state.provider)
+    if (state.provider === 'openai') await rmOpenAIOAuthCredentials()
     const data = await refreshProviderKeyState(state.data, currentConfig, state.provider)
+    if (currentProvider === state.provider) {
+      const fallback = pickFallbackSelection(data, state.provider)
+      if (fallback) {
+        onPick(fallback)
+        return
+      }
+    }
+    setState({ kind: 'list', data })
+  } catch (err: unknown) {
+    setState({ ...state, submitting: false, error: (err as Error).message })
+  }
+}
+
+async function signOutOAuth(
+  state: Extract<State, { kind: 'oauthManage' }>,
+  currentConfig: EthagentConfig,
+  setState: (s: State) => void,
+  onPick: (sel: ModelPickerSelection) => void,
+  currentProvider: ProviderId,
+): Promise<void> {
+  setState({ ...state, submitting: true, error: undefined })
+  try {
+    await rmKey('openai')
+    await rmOpenAIOAuthCredentials()
+    const data = await refreshProviderKeyState(state.data, currentConfig, 'openai')
+    if (currentProvider === 'openai') {
+      const fallback = pickFallbackSelection(data, 'openai')
+      if (fallback) {
+        onPick(fallback)
+        return
+      }
+    }
     setState({ kind: 'list', data })
   } catch (err: unknown) {
     setState({ ...state, submitting: false, error: (err as Error).message })
   }
 }
 
+function pickFallbackSelection(data: LoadedData, removed: ProviderId): ModelPickerSelection | null {
+  for (const provider of MODEL_PICKER_CLOUD_PROVIDERS) {
+    if (provider === removed) continue
+    if (data.cloudKeys[provider] !== true) continue
+    const catalogModel = data.cloudCatalogs[provider]?.entries[0]?.id
+    const model = catalogModel ?? defaultModelFor(provider)
+    return { kind: 'cloud', provider, model, keyJustSet: false }
+  }
+  if (data.hfModels.length > 0) {
+    return { kind: 'llamacpp', model: data.hfModels[0]!.id }
+  }
+  return null
+}
+
 async function refreshProviderKeyState(
   data: LoadedData,
   currentConfig: EthagentConfig,
   provider: CloudProviderId,
 ): Promise<LoadedData> {
   clearModelCatalogCache()
-  const keySet = await hasKey(provider)
+  const apiKeySet = await hasKey(provider)
+  const oauthSet = provider === 'openai' ? await hasOpenAIOAuthCredentials() : false
+  const keySet = apiKeySet || oauthSet
   const cloudKeys = { ...data.cloudKeys, [provider]: keySet }
+  const cloudCredentialKinds: Partial<Record<ProviderId, CloudCredentialKind>> = { ...(data.cloudCredentialKinds ?? {}) }
+  if (oauthSet) cloudCredentialKinds[provider] = 'oauth'
+  else if (apiKeySet) cloudCredentialKinds[provider] = 'apikey'
+  else delete cloudCredentialKinds[provider]
   const cloudCatalogs = { ...data.cloudCatalogs }
   if (keySet) {
     cloudCatalogs[provider] = await discoverProviderModels(configForProvider(currentConfig, provider))
   } else {
     delete cloudCatalogs[provider]
   }
-  return { ...data, cloudKeys, cloudCatalogs }
+  return { ...data, cloudKeys, cloudCatalogs, cloudCredentialKinds }
 }
 
 function configForProvider(config: EthagentConfig, provider: CloudProviderId): EthagentConfig {

package/src/models/catalog.ts

@@ -1,6 +1,16 @@
 import { defaultModelFor, type EthagentConfig, type ProviderId } from '../storage/config.js'
 import { getKey } from '../storage/secrets.js'
 import { loadLocalHfModels } from './huggingface.js'
+import { hasOpenAIOAuthCredentials } from '../auth/openaiOAuth/credentials.js'
+import { providerDisplayName } from './providerDisplay.js'
+
+const OPENAI_OAUTH_MODEL_IDS = ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.2'] as const
+
+export const OPENAI_OAUTH_DEFAULT_MODEL = 'gpt-5.4'
+
+export function isOpenAIOAuthAllowedModel(model: string): boolean {
+  return (OPENAI_OAUTH_MODEL_IDS as readonly string[]).includes(model)
+}
 
 export type ModelCatalogSource = 'installed' | 'discovered' | 'fallback'
 
@@ -72,7 +82,12 @@ export async function discoverProviderModels(
 
   const loadKey = deps.loadKey ?? getKey
   const apiKey = await loadKey(provider)
-  if (!apiKey) return fallbackResult(config, `missing ${provider} API key`)
+  if (!apiKey) {
+    if (provider === 'openai' && await hasOpenAIOAuthCredentials()) {
+      return openAIOAuthCatalog()
+    }
+    return fallbackResult(config, `missing ${providerDisplayName(provider)} API key`)
+  }
 
   const baseUrl = provider === 'openai' ? openAIBaseUrlFor(config) : ''
   const key = cacheKey(provider, baseUrl, true)
@@ -98,6 +113,19 @@ export async function discoverProviderModels(
   }
 }
 
+function openAIOAuthCatalog(): ModelCatalogResult {
+  return {
+    provider: 'openai',
+    status: 'ok',
+    entries: OPENAI_OAUTH_MODEL_IDS.map(id => ({
+      provider: 'openai' as ProviderId,
+      id,
+      label: id,
+      source: 'discovered' as const,
+    })),
+  }
+}
+
 function fallbackResult(config: EthagentConfig, error?: string): ModelCatalogResult {
   const provider = config.provider
   return {

package/src/models/modelPickerOptions.ts

@@ -7,21 +7,14 @@ import { type SelectOption } from '../ui/Select.js'
 import { formatLocalHfModelDisplayName, formatModelDisplayName } from './modelDisplay.js'
 import { localModelId, quantizationFromFilename } from './huggingface.js'
 import type { UncensoredCatalogEntry } from './uncensoredCatalog.js'
+import { cloudProviderDisplayName, providerDisplayName, type CloudProviderId } from './providerDisplay.js'
 
-export type CloudProviderId = Exclude<ProviderId, 'llamacpp'>
+export { cloudProviderDisplayName, providerDisplayName, type CloudProviderId }
 
 export const MODEL_PICKER_CLOUD_PROVIDERS: CloudProviderId[] = ['openai', 'anthropic', 'gemini']
 export const LOCAL_MODEL_LINK_HINT = 'Paste a GGUF link'
 export const LOCAL_MODEL_LINK_EXAMPLE = 'e.g. https://huggingface.co/Qwen/Qwen3-8B-GGUF'
 
-export function cloudProviderDisplayName(provider: CloudProviderId): string {
-  switch (provider) {
-    case 'openai': return 'OpenAI'
-    case 'anthropic': return 'Anthropic'
-    case 'gemini': return 'Gemini'
-  }
-}
-
 export type LocalHfPickerModel = {
   id: string
   displayName: string
@@ -32,6 +25,8 @@ export type LocalHfPickerModel = {
   status: 'ready' | 'incomplete'
 }
 
+export type CloudCredentialKind = 'apikey' | 'oauth'
+
 export type ModelPickerOptionsData = {
   llamaCpp: {
     binaryPresent: boolean
@@ -42,6 +37,7 @@ export type ModelPickerOptionsData = {
   machineSpec?: SpecSnapshot
   cloudKeys: Partial<Record<ProviderId, boolean>>
   cloudCatalogs: Partial<Record<ProviderId, ModelCatalogResult>>
+  cloudCredentialKinds?: Partial<Record<ProviderId, CloudCredentialKind>>
 }
 
 export type ModelPickerContextFit = {
@@ -78,6 +74,9 @@ export function buildModelPickerOptions(
     options.push(groupOption(`hdr:cloud:${provider}`, cloudProviderDisplayName(provider)))
     const keySet = data.cloudKeys[provider] === true
     if (!keySet) {
+      if (provider === 'openai') {
+        options.push(utilityOption('oauth:openai', 'Sign in with ChatGPT', 'Use your ChatGPT subscription'))
+      }
       options.push(utilityOption(`key:set:${provider}`, 'Add API Key'))
       continue
     }
@@ -105,7 +104,10 @@ export function buildModelPickerOptions(
       ))
     }
     options.push(utilityOption(`catalog:${provider}`, 'Full Catalog'))
-    options.push(utilityOption(`key:manage:${provider}`, 'Manage API Key'))
+    const manageLabel = provider === 'openai' && data.cloudCredentialKinds?.openai === 'oauth'
+      ? 'Manage ChatGPT Sign-in'
+      : 'Manage API Key'
+    options.push(utilityOption(`key:manage:${provider}`, manageLabel))
   }
 
   options.push(sectionOption('hdr:exit', 'Exit'))

package/src/models/providerDisplay.ts

@@ -0,0 +1,16 @@
+import type { ProviderId } from '../storage/config.js'
+
+export type CloudProviderId = Exclude<ProviderId, 'llamacpp'>
+
+export function cloudProviderDisplayName(provider: CloudProviderId): string {
+  switch (provider) {
+    case 'openai': return 'OpenAI'
+    case 'anthropic': return 'Anthropic'
+    case 'gemini': return 'Gemini'
+  }
+}
+
+export function providerDisplayName(provider: ProviderId): string {
+  if (provider === 'llamacpp') return 'llama.cpp'
+  return cloudProviderDisplayName(provider)
+}

package/src/providers/errors.ts

@@ -1,6 +1,7 @@
 import type { ProviderId } from '../storage/config.js'
 import { ProviderError } from './contracts.js'
 import { formatGeminiRateLimitMessage } from './gemini.js'
+import { providerDisplayName } from '../models/providerDisplay.js'
 
 type ErrorBody =
   | string
@@ -30,19 +31,20 @@ export async function providerErrorFromResponse(
     && /API[_ ]?key( not valid| not found|_invalid)|invalid api key/i.test(detail)
   ) {
     return new ProviderError(
-      'gemini: API key rejected — verify your key at https://aistudio.google.com/app/apikey, then run /key gemini to set it again',
+      'Gemini: API key rejected — verify your key at https://aistudio.google.com/app/apikey, then run /key gemini to set it again',
     )
   }
 
   if (provider !== 'llamacpp') {
+    const name = providerDisplayName(provider)
     if (response.status === 401 || response.status === 403) {
-      return new ProviderError(`auth failed: check your ${provider} key (/doctor to verify)`)
+      return new ProviderError(`auth failed: check your ${name} key (/doctor to verify)`)
     }
     if (response.status === 429) {
-      return new ProviderError(detail || `${provider} rate limit exceeded`, { transient: true })
+      return new ProviderError(detail || `${name} rate limit exceeded`, { transient: true })
     }
     if (response.status >= 500) {
-      return new ProviderError(detail || `${provider} server error (${response.status})`, { transient: true })
+      return new ProviderError(detail || `${name} server error (${response.status})`, { transient: true })
     }
   }
 

package/src/providers/openai-chat.ts

@@ -5,6 +5,7 @@ import { providerErrorFromResponse } from './errors.js'
 import { fetchWithRetryStreamEvents } from './retry.js'
 import { iterSseFrames } from './sse.js'
 import { messageTextContent } from '../utils/messages.js'
+import { providerDisplayName } from '../models/providerDisplay.js'
 
 export type OpenAIToolDefinition = {
   type: 'function'
@@ -369,7 +370,7 @@ function providerNetworkErrorMessage(
 ): string {
   const message = (err as Error).message || fallback
   if (provider !== 'llamacpp') return message
-  return `${provider} request failed at ${baseUrl}: ${message}`
+  return `${providerDisplayName(provider)} request failed at ${baseUrl}: ${message}`
 }
 
 class ContentThinkingParser {