diff --git a/.nvimlog b/.nvimlog
new file mode 100644
index 00000000..37fc1df7
--- /dev/null
+++ b/.nvimlog
@@ -0,0 +1 @@
+WRN 2026-04-29T11:21:24.001 ?.14533    server_start:199: Failed to start server: operation not permitted: /var/folders/1g/3yj40ngn5b33fs9gg0wzvms00000gn/T/nvim.apple/gwHDxl/nvim.14533.0
diff --git a/src/cli/handlers/auth.ts b/src/cli/handlers/auth.ts
index c4cba5d0..96c98b81 100644
--- a/src/cli/handlers/auth.ts
+++ b/src/cli/handlers/auth.ts
@@ -20,13 +20,19 @@ import {
 import { getOauthProfileFromOauthToken } from '../../services/oauth/getOauthProfile.js'
 import { OAuthService } from '../../services/oauth/index.js'
 import type { OAuthTokens } from '../../services/oauth/types.js'
+import { OpenAIOAuthService } from '../../services/openaiAuth/index.js'
+import { getOpenAIOAuthTokens } from '../../services/openaiAuth/storage.js'
+import type { OpenAIOAuthTokens } from '../../services/openaiAuth/types.js'
 import {
+  clearStoredClaudeAIOAuthTokens,
   clearOAuthTokenCache,
   getAnthropicApiKeyWithSource,
   getAuthTokenSource,
+  getOpenAIAuthOverrideWarning,
   getOauthAccountInfo,
   getSubscriptionType,
   isUsing3PServices,
+  removeApiKey,
   saveOAuthTokensIfNeeded,
   validateForceLoginOrg,
 } from '../../utils/auth.js'
@@ -109,17 +115,75 @@ export async function installOAuthTokens(tokens: OAuthTokens): Promise<void> {
   await clearAuthRelatedCaches()
 }
 
+export async function installOpenAIOAuthTokens(
+  tokens: OpenAIOAuthTokens,
+): Promise<string | null> {
+  await removeApiKey()
+  const clearClaudeOauth = clearStoredClaudeAIOAuthTokens()
+  if (!clearClaudeOauth.success) {
+    throw new Error(
+      clearClaudeOauth.warning ?? 'Failed to disable existing Claude auth state',
+    )
+  }
+
+  saveGlobalConfig(current => ({
+    ...current,
+    oauthAccount: undefined,
+  }))
+
+  if (!tokens.refreshToken) {
+    throw new Error('OpenAI OAuth tokens are incomplete.')
+  }
+
+  await clearAuthRelatedCaches()
+  return getOpenAIAuthOverrideWarning()
+}
+
 export async function authLogin({
   email,
   sso,
   console: useConsole,
   claudeai,
+  openai,
 }: {
   email?: string
   sso?: boolean
   console?: boolean
   claudeai?: boolean
+  openai?: boolean
 }): Promise<void> {
+  if (openai) {
+    if (email || sso || useConsole || claudeai) {
+      process.stderr.write(
+        'Error: --openai cannot be combined with --email, --sso, --console, or --claudeai.\n',
+      )
+      process.exit(1)
+    }
+
+    const openaiOAuthService = new OpenAIOAuthService()
+
+    try {
+      const tokens = await openaiOAuthService.startOAuthFlow(async url => {
+        process.stdout.write('Opening browser to sign in to OpenAI…\n')
+        process.stdout.write(`If the browser did not open, visit: ${url}\n`)
+      })
+
+      const warning = await installOpenAIOAuthTokens(tokens)
+
+      process.stdout.write('OpenAI login successful.\n')
+      if (warning) {
+        process.stdout.write(`${warning}\n`)
+      }
+      process.exit(0)
+    } catch (err) {
+      logError(err)
+      process.stderr.write(`OpenAI login failed: ${errorMessage(err)}\n`)
+      process.exit(1)
+    } finally {
+      openaiOAuthService.cleanup()
+    }
+  }
+
   if (useConsole && claudeai) {
     process.stderr.write(
       'Error: --console and --claudeai cannot be used together.\n',
@@ -232,7 +296,52 @@ export async function authLogin({
 export async function authStatus(opts: {
   json?: boolean
   text?: boolean
+  openai?: boolean
 }): Promise<void> {
+  if (opts.openai) {
+    const openaiTokens = getOpenAIOAuthTokens()
+    const loggedIn =
+      !!openaiTokens &&
+      openaiTokens.refreshToken.length > 0 &&
+      openaiTokens.expiresAt > 0
+
+    if (opts.text) {
+      if (!loggedIn) {
+        process.stdout.write(
+          'Not logged in to OpenAI. Run claude auth login --openai to authenticate.\n',
+        )
+      } else {
+        process.stdout.write('Provider: openai\n')
+        if (openaiTokens.email) {
+          process.stdout.write(`Email: ${openaiTokens.email}\n`)
+        }
+        if (openaiTokens.accountId) {
+          process.stdout.write(`Account ID: ${openaiTokens.accountId}\n`)
+        }
+        process.stdout.write(
+          `Expires At: ${new Date(openaiTokens.expiresAt).toISOString()}\n`,
+        )
+      }
+    } else {
+      process.stdout.write(
+        jsonStringify(
+          {
+            loggedIn,
+            authMethod: loggedIn ? 'openai_oauth' : 'none',
+            provider: 'openai',
+            email: openaiTokens?.email ?? null,
+            accountId: openaiTokens?.accountId ?? null,
+            expiresAt: openaiTokens?.expiresAt ?? null,
+          },
+          null,
+          2,
+        ) + '\n',
+      )
+    }
+
+    process.exit(loggedIn ? 0 : 1)
+  }
+
   const { source: authTokenSource, hasToken } = getAuthTokenSource()
   const { source: apiKeySource } = getAnthropicApiKeyWithSource()
   const hasApiKeyEnvVar =
@@ -240,12 +349,25 @@ export async function authStatus(opts: {
   const oauthAccount = getOauthAccountInfo()
   const subscriptionType = getSubscriptionType()
   const using3P = isUsing3PServices()
+  const openaiTokens = getOpenAIOAuthTokens()
+  const usingOpenAI =
+    !!openaiTokens?.refreshToken &&
+    !hasToken &&
+    apiKeySource === 'none' &&
+    !hasApiKeyEnvVar &&
+    !using3P
   const loggedIn =
-    hasToken || apiKeySource !== 'none' || hasApiKeyEnvVar || using3P
+    hasToken ||
+    apiKeySource !== 'none' ||
+    hasApiKeyEnvVar ||
+    using3P ||
+    usingOpenAI
 
   // Determine auth method
   let authMethod: string = 'none'
-  if (using3P) {
+  if (usingOpenAI) {
+    authMethod = 'openai_oauth'
+  } else if (using3P) {
     authMethod = 'third_party'
   } else if (authTokenSource === 'claude.ai') {
     authMethod = 'claude.ai'
@@ -311,6 +433,11 @@ export async function authStatus(opts: {
       output.orgId = oauthAccount?.organizationUuid ?? null
       output.orgName = oauthAccount?.organizationName ?? null
       output.subscriptionType = subscriptionType ?? null
+    } else if (authMethod === 'openai_oauth') {
+      output.provider = 'openai'
+      output.email = openaiTokens?.email ?? null
+      output.accountId = openaiTokens?.accountId ?? null
+      output.subscriptionType = 'ChatGPT Pro/Plus'
     }
 
     process.stdout.write(jsonStringify(output, null, 2) + '\n')
@@ -318,7 +445,18 @@ export async function authStatus(opts: {
   process.exit(loggedIn ? 0 : 1)
 }
 
-export async function authLogout(): Promise<void> {
+export async function authLogout(opts?: { openai?: boolean }): Promise<void> {
+  if (opts?.openai) {
+    const openaiOAuthService = new OpenAIOAuthService()
+    const success = openaiOAuthService.logout()
+    if (!success) {
+      process.stderr.write('Failed to log out from OpenAI.\n')
+      process.exit(1)
+    }
+    process.stdout.write('Successfully logged out from your OpenAI account.\n')
+    process.exit(0)
+  }
+
   try {
     await performLogout({ clearOnboarding: false })
   } catch {
diff --git a/src/commands/login/login.tsx b/src/commands/login/login.tsx
index b532534d..9247b440 100644
--- a/src/commands/login/login.tsx
+++ b/src/commands/login/login.tsx
@@ -5,8 +5,8 @@ import { resetCostState } from '../../bootstrap/state.js';
 import { clearTrustedDeviceToken, enrollTrustedDevice } from '../../bridge/trustedDevice.js';
 import type { LocalJSXCommandContext } from '../../commands.js';
 import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
-import { ConsoleOAuthFlow } from '../../components/ConsoleOAuthFlow.js';
 import { Dialog } from '../../components/design-system/Dialog.js';
+import { SlashLoginFlow } from '../../components/SlashLoginFlow.js';
 import { useMainLoopModel } from '../../hooks/useMainLoopModel.js';
 import { Text } from '../../ink.js';
 import { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js';
@@ -80,7 +80,7 @@ export function Login(props) {
   }
   let t2;
   if ($[6] !== props.startingMessage || $[7] !== t1) {
-    t2 = <ConsoleOAuthFlow onDone={t1} startingMessage={props.startingMessage} />;
+    t2 = <SlashLoginFlow onDone={t1} startingMessage={props.startingMessage} />;
     $[6] = props.startingMessage;
     $[7] = t1;
     $[8] = t2;
@@ -101,4 +101,4 @@ export function Login(props) {
 function _temp(exitState) {
   return exitState.pending ? <Text>Press {exitState.keyName} again to exit</Text> : <ConfigurableShortcutHint action="confirm:no" context="Confirmation" fallback="Esc" description="cancel" />;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","resetCostState","clearTrustedDeviceToken","enrollTrustedDevice","LocalJSXCommandContext","ConfigurableShortcutHint","ConsoleOAuthFlow","Dialog","useMainLoopModel","Text","refreshGrowthBookAfterAuthChange","refreshPolicyLimits","refreshRemoteManagedSettings","LocalJSXCommandOnDone","stripSignatureBlocks","checkAndDisableAutoModeIfNeeded","checkAndDisableBypassPermissionsIfNeeded","resetAutoModeGateCheck","resetBypassPermissionsCheck","resetUserCache","call","onDone","context","Promise","ReactNode","success","onChangeAPIKey","setMessages","appState","getAppState","toolPermissionContext","setAppState","fastMode","prev","authVersion","Login","props","$","_c","mainLoopModel","t0","t1","t2","startingMessage","t3","_temp","exitState","pending","keyName"],"sources":["login.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { resetCostState } from '../../bootstrap/state.js'\nimport {\n  clearTrustedDeviceToken,\n  enrollTrustedDevice,\n} from '../../bridge/trustedDevice.js'\nimport type { LocalJSXCommandContext } from '../../commands.js'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { ConsoleOAuthFlow } from '../../components/ConsoleOAuthFlow.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport { Text } from '../../ink.js'\nimport { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js'\nimport { refreshPolicyLimits } from '../../services/policyLimits/index.js'\nimport { refreshRemoteManagedSettings } from '../../services/remoteManagedSettings/index.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { stripSignatureBlocks } from '../../utils/messages.js'\nimport {\n  checkAndDisableAutoModeIfNeeded,\n  checkAndDisableBypassPermissionsIfNeeded,\n  resetAutoModeGateCheck,\n  resetBypassPermissionsCheck,\n} from '../../utils/permissions/bypassPermissionsKillswitch.js'\nimport { resetUserCache } from '../../utils/user.js'\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: LocalJSXCommandContext,\n): Promise<React.ReactNode> {\n  return (\n    <Login\n      onDone={async success => {\n        context.onChangeAPIKey()\n        // Signature-bearing blocks (thinking, connector_text) are bound to the API key —\n        // strip them so the new key doesn't reject stale signatures.\n        context.setMessages(stripSignatureBlocks)\n        if (success) {\n          // Post-login refresh logic. Keep in sync with onboarding in src/interactiveHelpers.tsx\n          // Reset cost state when switching accounts\n          resetCostState()\n          // Refresh remotely managed settings after login (non-blocking)\n          void refreshRemoteManagedSettings()\n          // Refresh policy limits after login (non-blocking)\n          void refreshPolicyLimits()\n          // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials\n          resetUserCache()\n          // Refresh GrowthBook after login to get updated feature flags (e.g., for claude.ai MCPs)\n          refreshGrowthBookAfterAuthChange()\n          // Clear any stale trusted device token from a previous account before\n          // re-enrolling — prevents sending the old token on bridge calls while\n          // the async enrollTrustedDevice() is in-flight.\n          clearTrustedDeviceToken()\n          // Enroll as a trusted device for Remote Control (10-min fresh-session window)\n          void enrollTrustedDevice()\n          // Reset killswitch gate checks and re-run with new org\n          resetBypassPermissionsCheck()\n          const appState = context.getAppState()\n          void checkAndDisableBypassPermissionsIfNeeded(\n            appState.toolPermissionContext,\n            context.setAppState,\n          )\n          if (feature('TRANSCRIPT_CLASSIFIER')) {\n            resetAutoModeGateCheck()\n            void checkAndDisableAutoModeIfNeeded(\n              appState.toolPermissionContext,\n              context.setAppState,\n              appState.fastMode,\n            )\n          }\n          // Increment authVersion to trigger re-fetching of auth-dependent data in hooks (e.g., MCP servers)\n          context.setAppState(prev => ({\n            ...prev,\n            authVersion: prev.authVersion + 1,\n          }))\n        }\n        onDone(success ? 'Login successful' : 'Login interrupted')\n      }}\n    />\n  )\n}\n\nexport function Login(props: {\n  onDone: (success: boolean, mainLoopModel: string) => void\n  startingMessage?: string\n}): React.ReactNode {\n  const mainLoopModel = useMainLoopModel()\n\n  return (\n    <Dialog\n      title=\"Login\"\n      onCancel={() => props.onDone(false, mainLoopModel)}\n      color=\"permission\"\n      inputGuide={exitState =>\n        exitState.pending ? (\n          <Text>Press {exitState.keyName} again to exit</Text>\n        ) : (\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        )\n      }\n    >\n      <ConsoleOAuthFlow\n        onDone={() => props.onDone(true, mainLoopModel)}\n        startingMessage={props.startingMessage}\n      />\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","resetCostState","clearTrustedDeviceToken","enrollTrustedDevice","LocalJSXCommandContext","ConfigurableShortcutHint","ConsoleOAuthFlow","Dialog","useMainLoopModel","Text","refreshGrowthBookAfterAuthChange","refreshPolicyLimits","refreshRemoteManagedSettings","LocalJSXCommandOnDone","stripSignatureBlocks","checkAndDisableAutoModeIfNeeded","checkAndDisableBypassPermissionsIfNeeded","resetAutoModeGateCheck","resetBypassPermissionsCheck","resetUserCache","call","onDone","context","Promise","ReactNode","success","onChangeAPIKey","setMessages","appState","getAppState","toolPermissionContext","setAppState","fastMode","prev","authVersion","Login","props","$","_c","mainLoopModel","t0","t1","t2","startingMessage","t3","_temp","exitState","pending","keyName"],"sources":["login.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { resetCostState } from '../../bootstrap/state.js'\nimport {\n  clearTrustedDeviceToken,\n  enrollTrustedDevice,\n} from '../../bridge/trustedDevice.js'\nimport type { LocalJSXCommandContext } from '../../commands.js'\nimport { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js'\nimport { ConsoleOAuthFlow } from '../../components/ConsoleOAuthFlow.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { useMainLoopModel } from '../../hooks/useMainLoopModel.js'\nimport { Text } from '../../ink.js'\nimport { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js'\nimport { refreshPolicyLimits } from '../../services/policyLimits/index.js'\nimport { refreshRemoteManagedSettings } from '../../services/remoteManagedSettings/index.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport { stripSignatureBlocks } from '../../utils/messages.js'\nimport {\n  checkAndDisableAutoModeIfNeeded,\n  checkAndDisableBypassPermissionsIfNeeded,\n  resetAutoModeGateCheck,\n  resetBypassPermissionsCheck,\n} from '../../utils/permissions/bypassPermissionsKillswitch.js'\nimport { resetUserCache } from '../../utils/user.js'\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: LocalJSXCommandContext,\n): Promise<React.ReactNode> {\n  return (\n    <Login\n      onDone={async success => {\n        context.onChangeAPIKey()\n        // Signature-bearing blocks (thinking, connector_text) are bound to the API key —\n        // strip them so the new key doesn't reject stale signatures.\n        context.setMessages(stripSignatureBlocks)\n        if (success) {\n          // Post-login refresh logic. Keep in sync with onboarding in src/interactiveHelpers.tsx\n          // Reset cost state when switching accounts\n          resetCostState()\n          // Refresh remotely managed settings after login (non-blocking)\n          void refreshRemoteManagedSettings()\n          // Refresh policy limits after login (non-blocking)\n          void refreshPolicyLimits()\n          // Clear user data cache BEFORE GrowthBook refresh so it picks up fresh credentials\n          resetUserCache()\n          // Refresh GrowthBook after login to get updated feature flags (e.g., for claude.ai MCPs)\n          refreshGrowthBookAfterAuthChange()\n          // Clear any stale trusted device token from a previous account before\n          // re-enrolling — prevents sending the old token on bridge calls while\n          // the async enrollTrustedDevice() is in-flight.\n          clearTrustedDeviceToken()\n          // Enroll as a trusted device for Remote Control (10-min fresh-session window)\n          void enrollTrustedDevice()\n          // Reset killswitch gate checks and re-run with new org\n          resetBypassPermissionsCheck()\n          const appState = context.getAppState()\n          void checkAndDisableBypassPermissionsIfNeeded(\n            appState.toolPermissionContext,\n            context.setAppState,\n          )\n          if (feature('TRANSCRIPT_CLASSIFIER')) {\n            resetAutoModeGateCheck()\n            void checkAndDisableAutoModeIfNeeded(\n              appState.toolPermissionContext,\n              context.setAppState,\n              appState.fastMode,\n            )\n          }\n          // Increment authVersion to trigger re-fetching of auth-dependent data in hooks (e.g., MCP servers)\n          context.setAppState(prev => ({\n            ...prev,\n            authVersion: prev.authVersion + 1,\n          }))\n        }\n        onDone(success ? 'Login successful' : 'Login interrupted')\n      }}\n    />\n  )\n}\n\nexport function Login(props: {\n  onDone: (success: boolean, mainLoopModel: string) => void\n  startingMessage?: string\n}): React.ReactNode {\n  const mainLoopModel = useMainLoopModel()\n\n  return (\n    <Dialog\n      title=\"Login\"\n      onCancel={() => props.onDone(false, mainLoopModel)}\n      color=\"permission\"\n      inputGuide={exitState =>\n        exitState.pending ? (\n          <Text>Press {exitState.keyName} again to exit</Text>\n        ) : (\n          <ConfigurableShortcutHint\n            action=\"confirm:no\"\n            context=\"Confirmation\"\n            fallback=\"Esc\"\n            description=\"cancel\"\n          />\n        )\n      }\n    >\n      <ConsoleOAuthFlow\n        onDone={() => props.onDone(true, mainLoopModel)}\n        startingMessage={props.startingMessage}\n      />\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}
diff --git a/src/components/OpenAILoginFlow.tsx b/src/components/OpenAILoginFlow.tsx
new file mode 100644
index 00000000..1ba11121
--- /dev/null
+++ b/src/components/OpenAILoginFlow.tsx
@@ -0,0 +1,124 @@
+import React, { useCallback, useEffect, useState } from 'react'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from 'src/services/analytics/index.js'
+import { installOpenAIOAuthTokens } from '../cli/handlers/auth.js'
+import { Box, Link, Text } from '../ink.js'
+import { useKeybinding } from '../keybindings/useKeybinding.js'
+import { OpenAIOAuthService } from '../services/openaiAuth/index.js'
+import { getOpenAIOAuthTokens } from '../services/openaiAuth/storage.js'
+import { logError } from '../utils/log.js'
+import { Spinner } from './Spinner.js'
+
+type Props = {
+  onDone(): void
+  startingMessage?: string
+}
+
+type OpenAILoginStatus =
+  | { state: 'ready_to_start' }
+  | { state: 'waiting_for_login'; url: string }
+  | { state: 'success'; warning?: string | null }
+  | { state: 'error'; message: string }
+
+export function OpenAILoginFlow({
+  onDone,
+  startingMessage,
+}: Props): React.ReactNode {
+  const [oauthService] = useState(() => new OpenAIOAuthService())
+  const [status, setStatus] = useState<OpenAILoginStatus>({
+    state: 'ready_to_start',
+  })
+
+  useKeybinding(
+    'confirm:yes',
+    () => {
+      logEvent('tengu_openai_oauth_success', {})
+      onDone()
+    },
+    {
+      context: 'Confirmation',
+      isActive: status.state === 'success',
+    },
+  )
+
+  const startOAuth = useCallback(async () => {
+    try {
+      logEvent('tengu_openai_oauth_flow_start', {})
+      const tokens = await oauthService.startOAuthFlow(async url => {
+        setStatus({ state: 'waiting_for_login', url })
+      })
+      const warning = await installOpenAIOAuthTokens(tokens)
+      setStatus({ state: 'success', warning })
+    } catch (error) {
+      logError(error)
+      setStatus({
+        state: 'error',
+        message: (error as Error).message,
+      })
+      logEvent('tengu_openai_oauth_error', {
+        error: (error as Error)
+          .message as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      })
+    }
+  }, [oauthService])
+
+  useEffect(() => {
+    if (status.state !== 'ready_to_start') {
+      return
+    }
+
+    void startOAuth()
+  }, [startOAuth, status.state])
+
+  useEffect(() => {
+    return () => {
+      oauthService.cleanup()
+    }
+  }, [oauthService])
+
+  const account = getOpenAIOAuthTokens()
+
+  return (
+    <Box flexDirection="column" gap={1}>
+      <Text bold>
+        {startingMessage ??
+          'Claude Code can also run through your ChatGPT subscription via OpenAI auth.'}
+      </Text>
+
+      {status.state === 'waiting_for_login' && (
+        <Box flexDirection="column" gap={1}>
+          <Box>
+            <Spinner />
+            <Text>Opening browser to sign in to OpenAI…</Text>
+          </Box>
+          <Text dimColor>Use the URL below if your browser did not open:</Text>
+          <Link url={status.url}>
+            <Text dimColor>{status.url}</Text>
+          </Link>
+        </Box>
+      )}
+
+      {status.state === 'success' && (
+        <Box flexDirection="column">
+          {account?.email ? (
+            <Text dimColor>
+              Logged in as <Text>{account.email}</Text>
+            </Text>
+          ) : null}
+          {status.warning ? (
+            <Text color="warning">{status.warning}</Text>
+          ) : null}
+          <Text color="success">
+            Login successful. Press <Text bold>Enter</Text> to continue…
+          </Text>
+        </Box>
+      )}
+
+      {status.state === 'error' && (
+        <Text color="error">OpenAI OAuth error: {status.message}</Text>
+      )}
+    </Box>
+  )
+}
diff --git a/src/components/SlashLoginFlow.tsx b/src/components/SlashLoginFlow.tsx
new file mode 100644
index 00000000..e14e4cb7
--- /dev/null
+++ b/src/components/SlashLoginFlow.tsx
@@ -0,0 +1,157 @@
+import React, { useMemo, useState } from 'react'
+import { Box, Link, Text } from '../ink.js'
+import { useKeybinding } from '../keybindings/useKeybinding.js'
+import { getSettings_DEPRECATED } from '../utils/settings/settings.js'
+import { ConsoleOAuthFlow } from './ConsoleOAuthFlow.js'
+import { Select } from './CustomSelect/select.js'
+import { OpenAILoginFlow } from './OpenAILoginFlow.js'
+
+type Props = {
+  onDone(): void
+  startingMessage?: string
+}
+
+type LoginSelection = 'claudeai' | 'console' | 'openai' | 'platform' | 'idle'
+
+function PlatformSetupFlow({
+  onBack,
+}: {
+  onBack(): void
+}): React.ReactNode {
+  useKeybinding(
+    'confirm:yes',
+    () => {
+      onBack()
+    },
+    {
+      context: 'Confirmation',
+      isActive: true,
+    },
+  )
+
+  return (
+    <Box flexDirection="column" gap={1} marginTop={1}>
+      <Text bold>Using 3rd-party platforms</Text>
+      <Text>
+        Claude Code supports Amazon Bedrock, Microsoft Foundry, and Vertex AI.
+        Set the required environment variables, then restart Claude Code.
+      </Text>
+      <Text>
+        If you are part of an enterprise organization, contact your
+        administrator for setup instructions.
+      </Text>
+      <Box flexDirection="column">
+        <Text bold>Documentation:</Text>
+        <Text>
+          · Amazon Bedrock:{' '}
+          <Link url="https://code.claude.com/docs/en/amazon-bedrock" />
+        </Text>
+        <Text>
+          · Microsoft Foundry:{' '}
+          <Link url="https://code.claude.com/docs/en/microsoft-foundry" />
+        </Text>
+        <Text>
+          · Vertex AI:{' '}
+          <Link url="https://code.claude.com/docs/en/google-vertex-ai" />
+        </Text>
+      </Box>
+      <Text dimColor>
+        Press <Text bold>Enter</Text> to go back to login options.
+      </Text>
+    </Box>
+  )
+}
+
+export function SlashLoginFlow({
+  onDone,
+  startingMessage,
+}: Props): React.ReactNode {
+  const settings = getSettings_DEPRECATED() || {}
+  const forceLoginMethod = settings.forceLoginMethod
+
+  const [selection, setSelection] = useState<LoginSelection>(() => {
+    if (forceLoginMethod === 'claudeai' || forceLoginMethod === 'console') {
+      return forceLoginMethod
+    }
+    return 'idle'
+  })
+
+  const options = useMemo(
+    () => [
+      {
+        label: (
+          <Text>
+            Claude account with subscription ·{' '}
+            <Text dimColor>Pro, Max, Team, or Enterprise</Text>
+            {'\n'}
+          </Text>
+        ),
+        value: 'claudeai' as const,
+      },
+      {
+        label: (
+          <Text>
+            Anthropic Console account ·{' '}
+            <Text dimColor>API usage billing</Text>
+            {'\n'}
+          </Text>
+        ),
+        value: 'console' as const,
+      },
+      {
+        label: (
+          <Text>
+            OpenAI account · <Text dimColor>ChatGPT Pro/Plus</Text>
+            {'\n'}
+          </Text>
+        ),
+        value: 'openai' as const,
+      },
+      {
+        label: (
+          <Text>
+            3rd-party platform ·{' '}
+            <Text dimColor>Amazon Bedrock, Microsoft Foundry, or Vertex AI</Text>
+            {'\n'}
+          </Text>
+        ),
+        value: 'platform' as const,
+      },
+    ],
+    [],
+  )
+
+  if (selection === 'claudeai' || selection === 'console') {
+    return (
+      <ConsoleOAuthFlow
+        onDone={onDone}
+        startingMessage={startingMessage}
+        forceLoginMethod={selection}
+      />
+    )
+  }
+
+  if (selection === 'openai') {
+    return <OpenAILoginFlow onDone={onDone} startingMessage={startingMessage} />
+  }
+
+  if (selection === 'platform') {
+    return <PlatformSetupFlow onBack={() => setSelection('idle')} />
+  }
+
+  return (
+    <Box flexDirection="column" gap={1} marginTop={1}>
+      <Text bold>
+        {startingMessage ??
+          'Claude Code can be used with your Claude subscription, Anthropic Console billing, or your ChatGPT subscription.'}
+      </Text>
+      <Text>Select login method:</Text>
+      <Box>
+        <Select
+          options={options}
+          onChange={value => setSelection(value as LoginSelection)}
+        />
+      </Box>
+    </Box>
+  )
+}
diff --git a/src/main.tsx b/src/main.tsx
index 554ca95a..b57451d7 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -4141,16 +4141,18 @@ async function run(): Promise<CommanderCommand> {
   // claude auth
 
   const auth = program.command('auth').description('Manage authentication').configureHelp(createSortedHelpConfig());
-  auth.command('login').description('Sign in to your Anthropic account').option('--email <email>', 'Pre-populate email address on the login page').option('--sso', 'Force SSO login flow').option('--console', 'Use Anthropic Console (API usage billing) instead of Claude subscription').option('--claudeai', 'Use Claude subscription (default)').action(async ({
+  auth.command('login').description('Sign in to your Anthropic or OpenAI account').option('--email <email>', 'Pre-populate email address on the login page').option('--sso', 'Force SSO login flow').option('--console', 'Use Anthropic Console (API usage billing) instead of Claude subscription').option('--claudeai', 'Use Claude subscription (default)').option('--openai', 'Use OpenAI ChatGPT/Codex OAuth login').action(async ({
     email,
     sso,
     console: useConsole,
-    claudeai
+    claudeai,
+    openai,
   }: {
     email?: string;
     sso?: boolean;
     console?: boolean;
     claudeai?: boolean;
+    openai?: boolean;
   }) => {
     const {
       authLogin
@@ -4159,23 +4161,27 @@ async function run(): Promise<CommanderCommand> {
       email,
       sso,
       console: useConsole,
-      claudeai
+      claudeai,
+      openai,
     });
   });
-  auth.command('status').description('Show authentication status').option('--json', 'Output as JSON (default)').option('--text', 'Output as human-readable text').action(async (opts: {
+  auth.command('status').description('Show authentication status').option('--json', 'Output as JSON (default)').option('--text', 'Output as human-readable text').option('--openai', 'Show OpenAI OAuth status').action(async (opts: {
     json?: boolean;
     text?: boolean;
+    openai?: boolean;
   }) => {
     const {
       authStatus
     } = await import('./cli/handlers/auth.js');
     await authStatus(opts);
   });
-  auth.command('logout').description('Log out from your Anthropic account').action(async () => {
+  auth.command('logout').description('Log out from your Anthropic or OpenAI account').option('--openai', 'Log out from OpenAI OAuth only').action(async (opts: {
+    openai?: boolean;
+  }) => {
     const {
       authLogout
     } = await import('./cli/handlers/auth.js');
-    await authLogout();
+    await authLogout(opts);
   });
 
   /**
diff --git a/src/server/__tests__/proxy-transform.test.ts b/src/server/__tests__/proxy-transform.test.ts
index c62cac38..caa66109 100644
--- a/src/server/__tests__/proxy-transform.test.ts
+++ b/src/server/__tests__/proxy-transform.test.ts
@@ -303,10 +303,33 @@ describe('anthropicToOpenaiResponses', () => {
     const result = anthropicToOpenaiResponses(req)
     expect(result.model).toBe('gpt-4o')
     expect(result.instructions).toBe('Be helpful')
+    expect(result.store).toBe(false)
+    expect(result.tools).toBeUndefined()
     expect(result.max_output_tokens).toBeUndefined()
     expect(result.input).toEqual([{ type: 'message', role: 'user', content: 'Hello' }])
   })
 
+  test('tools conversion uses top-level name', () => {
+    const req: AnthropicRequest = {
+      model: 'gpt-4o',
+      max_tokens: 100,
+      messages: [{ role: 'user', content: 'Hi' }],
+      tools: [{
+        name: 'get_weather',
+        description: 'Get weather',
+        input_schema: { type: 'object', properties: { city: { type: 'string' } } },
+      }],
+    }
+    const result = anthropicToOpenaiResponses(req)
+    expect(result.tools).toHaveLength(1)
+    expect(result.tools![0]).toEqual({
+      type: 'function',
+      name: 'get_weather',
+      description: 'Get weather',
+      parameters: { type: 'object', properties: { city: { type: 'string' } } },
+    })
+  })
+
   test('tool_use lifted to function_call', () => {
     const req: AnthropicRequest = {
       model: 'gpt-4o',
diff --git a/src/server/proxy/transform/anthropicToOpenaiResponses.ts b/src/server/proxy/transform/anthropicToOpenaiResponses.ts
index 2ba121c9..1a9e31d6 100644
--- a/src/server/proxy/transform/anthropicToOpenaiResponses.ts
+++ b/src/server/proxy/transform/anthropicToOpenaiResponses.ts
@@ -10,7 +10,6 @@ import type {
   AnthropicMessage,
   OpenAIResponsesRequest,
   OpenAIResponsesInputItem,
-  OpenAITool,
   OpenAIChatContentPart,
 } from './types.js'
 
@@ -29,6 +28,7 @@ export function anthropicToOpenaiResponses(body: AnthropicRequest): OpenAIRespon
     model: body.model,
     input,
     stream: body.stream,
+    store: false,
   }
 
   // system → instructions
@@ -51,13 +51,11 @@ export function anthropicToOpenaiResponses(body: AnthropicRequest): OpenAIRespon
   if (body.tools && body.tools.length > 0) {
     result.tools = body.tools
       .filter((t) => t.name !== 'BatchTool')
-      .map((t): OpenAITool => ({
+      .map((t) => ({
         type: 'function',
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: t.input_schema,
-        },
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema,
       }))
   }
 
diff --git a/src/server/proxy/transform/types.ts b/src/server/proxy/transform/types.ts
index 103da968..da40132a 100644
--- a/src/server/proxy/transform/types.ts
+++ b/src/server/proxy/transform/types.ts
@@ -110,11 +110,17 @@ export type OpenAIResponsesRequest = {
   model: string
   input: OpenAIResponsesInputItem[]
   instructions?: string
+  store?: boolean
   max_output_tokens?: number
   temperature?: number
   top_p?: number
   stream?: boolean
-  tools?: OpenAITool[]
+  tools?: Array<{
+    type: 'function'
+    name: string
+    description?: string
+    parameters?: Record<string, unknown>
+  }>
   tool_choice?: unknown
   reasoning?: { effort?: 'low' | 'medium' | 'high' }
 }
diff --git a/src/services/api/client.ts b/src/services/api/client.ts
index 8c1feb69..0d437105 100644
--- a/src/services/api/client.ts
+++ b/src/services/api/client.ts
@@ -22,6 +22,11 @@ import {
   getSessionId,
 } from '../../bootstrap/state.js'
 import { getOauthConfig } from '../../constants/oauth.js'
+import {
+  buildOpenAICodexFetch,
+  OPENAI_OAUTH_DUMMY_KEY,
+  shouldUseOpenAICodexAuth,
+} from '../openaiAuth/fetch.js'
 import { isDebugToStdErr, logForDebugging } from '../../utils/debug.js'
 import {
   getAWSRegion,
@@ -132,11 +137,19 @@ export async function getAnthropicClient({
   await checkAndRefreshOAuthTokenIfNeeded()
   logForDebugging('[API:auth] OAuth token check complete')
 
-  if (!isClaudeAISubscriber()) {
+  const usingOpenAICodex =
+    shouldUseOpenAICodexAuth() &&
+    !isClaudeAISubscriber() &&
+    !process.env.ANTHROPIC_AUTH_TOKEN &&
+    !(apiKey || getAnthropicApiKey())
+
+  if (!isClaudeAISubscriber() && !usingOpenAICodex) {
     await configureApiKeyHeaders(defaultHeaders, getIsNonInteractiveSession())
   }
 
-  const resolvedFetch = buildFetch(fetchOverride, source)
+  const resolvedFetch = usingOpenAICodex
+    ? buildOpenAICodexFetch(fetchOverride, source)
+    : buildFetch(fetchOverride, source)
 
   const ARGS = {
     defaultHeaders,
@@ -299,7 +312,11 @@ export async function getAnthropicClient({
 
   // Determine authentication method based on available tokens
   const clientConfig: ConstructorParameters<typeof Anthropic>[0] = {
-    apiKey: isClaudeAISubscriber() ? null : apiKey || getAnthropicApiKey(),
+    apiKey: isClaudeAISubscriber()
+      ? null
+      : usingOpenAICodex
+        ? OPENAI_OAUTH_DUMMY_KEY
+        : apiKey || getAnthropicApiKey(),
     authToken: isClaudeAISubscriber()
       ? getClaudeAIOAuthTokens()?.accessToken
       : undefined,
diff --git a/src/services/openaiAuth/client.ts b/src/services/openaiAuth/client.ts
new file mode 100644
index 00000000..23a0e7f0
--- /dev/null
+++ b/src/services/openaiAuth/client.ts
@@ -0,0 +1,141 @@
+import { generateCodeChallenge } from '../oauth/crypto.js'
+import type {
+  OpenAIJwtClaims,
+  OpenAIOAuthTokenResponse,
+  OpenAIOAuthTokens,
+} from './types.js'
+
+export const OPENAI_AUTH_ISSUER = 'https://auth.openai.com'
+export const OPENAI_CODEX_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann'
+export const OPENAI_CODEX_API_ENDPOINT =
+  'https://chatgpt.com/backend-api/codex/responses'
+export const OPENAI_CODEX_OAUTH_PORT = 1455
+export const OPENAI_CODEX_REDIRECT_PATH = '/auth/callback'
+
+const DEFAULT_TOKEN_LIFETIME_MS = 3600 * 1000
+
+export function buildOpenAIAuthorizeUrl(input: {
+  redirectUri: string
+  codeVerifier: string
+  state: string
+}): string {
+  const params = new URLSearchParams({
+    response_type: 'code',
+    client_id: OPENAI_CODEX_CLIENT_ID,
+    redirect_uri: input.redirectUri,
+    scope: 'openid profile email offline_access',
+    code_challenge: generateCodeChallenge(input.codeVerifier),
+    code_challenge_method: 'S256',
+    id_token_add_organizations: 'true',
+    codex_cli_simplified_flow: 'true',
+    state: input.state,
+    originator: 'opencode',
+  })
+
+  return `${OPENAI_AUTH_ISSUER}/oauth/authorize?${params.toString()}`
+}
+
+export async function exchangeOpenAICodeForTokens(input: {
+  code: string
+  redirectUri: string
+  codeVerifier: string
+}): Promise<OpenAIOAuthTokenResponse> {
+  const response = await fetch(`${OPENAI_AUTH_ISSUER}/oauth/token`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      grant_type: 'authorization_code',
+      code: input.code,
+      redirect_uri: input.redirectUri,
+      client_id: OPENAI_CODEX_CLIENT_ID,
+      code_verifier: input.codeVerifier,
+    }).toString(),
+  })
+
+  if (!response.ok) {
+    throw new Error(`OpenAI token exchange failed: ${response.status}`)
+  }
+
+  return (await response.json()) as OpenAIOAuthTokenResponse
+}
+
+export async function refreshOpenAITokens(
+  refreshToken: string,
+): Promise<OpenAIOAuthTokenResponse> {
+  const response = await fetch(`${OPENAI_AUTH_ISSUER}/oauth/token`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: OPENAI_CODEX_CLIENT_ID,
+    }).toString(),
+  })
+
+  if (!response.ok) {
+    throw new Error(`OpenAI token refresh failed: ${response.status}`)
+  }
+
+  return (await response.json()) as OpenAIOAuthTokenResponse
+}
+
+export function parseOpenAIJwtClaims(
+  token?: string,
+): OpenAIJwtClaims | undefined {
+  if (!token) return undefined
+  const parts = token.split('.')
+  if (parts.length !== 3) return undefined
+
+  try {
+    return JSON.parse(Buffer.from(parts[1]!, 'base64url').toString())
+  } catch {
+    return undefined
+  }
+}
+
+export function extractOpenAIAccountId(
+  claims?: OpenAIJwtClaims,
+): string | undefined {
+  if (!claims) return undefined
+
+  return (
+    claims.chatgpt_account_id ||
+    claims['https://api.openai.com/auth']?.chatgpt_account_id ||
+    claims.organizations?.[0]?.id
+  )
+}
+
+export function normalizeOpenAITokens(
+  response: OpenAIOAuthTokenResponse,
+): OpenAIOAuthTokens {
+  const claims =
+    parseOpenAIJwtClaims(response.id_token) ??
+    parseOpenAIJwtClaims(response.access_token)
+
+  return {
+    accessToken: response.access_token,
+    refreshToken: response.refresh_token,
+    expiresAt: Date.now() + (response.expires_in ?? 3600) * 1000,
+    idToken: response.id_token,
+    accountId: extractOpenAIAccountId(claims),
+    email: claims?.email,
+  }
+}
+
+export function isOpenAITokenExpired(expiresAt: number): boolean {
+  return expiresAt - Date.now() <= 5 * 60 * 1000
+}
+
+export function withRefreshedAccessToken(
+  existing: OpenAIOAuthTokens,
+  refreshed: OpenAIOAuthTokenResponse,
+): OpenAIOAuthTokens {
+  const next = normalizeOpenAITokens(refreshed)
+
+  return {
+    ...next,
+    accountId: next.accountId ?? existing.accountId,
+    email: next.email ?? existing.email,
+    idToken: next.idToken ?? existing.idToken,
+  }
+}
diff --git a/src/services/openaiAuth/fetch.ts b/src/services/openaiAuth/fetch.ts
new file mode 100644
index 00000000..51bfe53b
--- /dev/null
+++ b/src/services/openaiAuth/fetch.ts
@@ -0,0 +1,132 @@
+import type { ClientOptions } from '@anthropic-ai/sdk'
+import { randomUUID } from 'crypto'
+import { OPENAI_CODEX_API_ENDPOINT } from './client.js'
+import { ensureFreshOpenAITokens } from './index.js'
+import { resolveOpenAICodexModel } from './models.js'
+import { getOpenAIOAuthTokens } from './storage.js'
+import { anthropicToOpenaiResponses } from '../../server/proxy/transform/anthropicToOpenaiResponses.js'
+import { openaiResponsesToAnthropic } from '../../server/proxy/transform/openaiResponsesToAnthropic.js'
+import { openaiResponsesStreamToAnthropic } from '../../server/proxy/streaming/openaiResponsesStreamToAnthropic.js'
+import type { AnthropicRequest } from '../../server/proxy/transform/types.js'
+import { logForDebugging } from '../../utils/debug.js'
+
+export const OPENAI_OAUTH_DUMMY_KEY = 'openai-oauth-dummy-key'
+
+export function shouldUseOpenAICodexAuth(): boolean {
+  const openaiTokens = getOpenAIOAuthTokens()
+  return !!openaiTokens?.refreshToken
+}
+
+export function buildOpenAICodexFetch(
+  fetchOverride: ClientOptions['fetch'],
+  source: string | undefined,
+): ClientOptions['fetch'] {
+  const inner = fetchOverride ?? globalThis.fetch
+
+  return async (input, init) => {
+    const url = input instanceof Request ? new URL(input.url) : new URL(String(input))
+
+    if (!url.pathname.endsWith('/v1/messages')) {
+      return inner(input, init)
+    }
+
+    const originalBody = await readAnthropicBody(input, init)
+    const mappedModel = resolveOpenAICodexModel(originalBody.model)
+    const transformedBody = anthropicToOpenaiResponses({
+      ...originalBody,
+      model: mappedModel,
+    })
+
+    const tokens = await ensureFreshOpenAITokens()
+    if (!tokens) {
+      throw new Error(
+        'OpenAI OAuth token is missing or expired. Run claude auth login --openai again.',
+      )
+    }
+
+    const headers = new Headers()
+    headers.set('Content-Type', 'application/json')
+    headers.set('Authorization', `Bearer ${tokens.accessToken}`)
+    if (tokens.accountId) {
+      headers.set('ChatGPT-Account-Id', tokens.accountId)
+    }
+
+    logForDebugging(
+      `[API REQUEST] ${url.pathname} remapped_to=OpenAI/Codex model=${mappedModel} source=${source ?? 'unknown'} request_id=${randomUUID()}`,
+    )
+
+    const upstream = await inner(OPENAI_CODEX_API_ENDPOINT, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(transformedBody),
+      signal: init?.signal,
+    })
+
+    if (!upstream.ok) {
+      const errorText = await upstream.text().catch(() => '')
+      return Response.json(
+        {
+          type: 'error',
+          error: {
+            type: 'api_error',
+            message: `OpenAI upstream returned HTTP ${upstream.status}: ${errorText.slice(0, 500)}`,
+          },
+        },
+        { status: upstream.status },
+      )
+    }
+
+    if (transformedBody.stream) {
+      if (!upstream.body) {
+        return Response.json(
+          {
+            type: 'error',
+            error: {
+              type: 'api_error',
+              message: 'OpenAI upstream returned no body for stream',
+            },
+          },
+          { status: 502 },
+        )
+      }
+
+      return new Response(
+        openaiResponsesStreamToAnthropic(upstream.body, mappedModel),
+        {
+          status: 200,
+          headers: {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+          },
+        },
+      )
+    }
+
+    const responseBody = await upstream.json()
+    return Response.json(
+      openaiResponsesToAnthropic(responseBody, mappedModel),
+    )
+  }
+}
+
+async function readAnthropicBody(
+  input: RequestInfo | URL,
+  init?: RequestInit,
+): Promise<AnthropicRequest> {
+  const directBody = init?.body
+
+  if (typeof directBody === 'string') {
+    return JSON.parse(directBody) as AnthropicRequest
+  }
+
+  if (directBody instanceof Uint8Array || directBody instanceof ArrayBuffer) {
+    return JSON.parse(Buffer.from(directBody).toString('utf8')) as AnthropicRequest
+  }
+
+  if (input instanceof Request) {
+    return (await input.clone().json()) as AnthropicRequest
+  }
+
+  throw new Error('Unable to read Anthropic request body for OpenAI/Codex transformation')
+}
diff --git a/src/services/openaiAuth/index.ts b/src/services/openaiAuth/index.ts
new file mode 100644
index 00000000..647c1cd4
--- /dev/null
+++ b/src/services/openaiAuth/index.ts
@@ -0,0 +1,167 @@
+import { openBrowser } from '../../utils/browser.js'
+import { AuthCodeListener } from '../oauth/auth-code-listener.js'
+import { generateCodeVerifier, generateState } from '../oauth/crypto.js'
+import {
+  buildOpenAIAuthorizeUrl,
+  exchangeOpenAICodeForTokens,
+  isOpenAITokenExpired,
+  OPENAI_CODEX_OAUTH_PORT,
+  OPENAI_CODEX_REDIRECT_PATH,
+  refreshOpenAITokens,
+  normalizeOpenAITokens,
+  withRefreshedAccessToken,
+} from './client.js'
+import {
+  clearOpenAIOAuthTokenCache,
+  deleteOpenAIOAuthTokens,
+  getOpenAIOAuthTokensAsync,
+  saveOpenAIOAuthTokens,
+} from './storage.js'
+import type { OpenAIOAuthTokens } from './types.js'
+
+const HTML_SUCCESS = `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>cc-haha OpenAI Authorization Successful</title>
+    <style>
+      body { font-family: system-ui, -apple-system, sans-serif; display:flex; justify-content:center; align-items:center; height:100vh; margin:0; background:#131010; color:#f1ecec; }
+      .container { text-align:center; padding:2rem; }
+      p { color:#b7b1b1; }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1>Authorization Successful</h1>
+      <p>You can close this window and return to Claude Code Haha.</p>
+    </div>
+    <script>setTimeout(() => window.close(), 2000)</script>
+  </body>
+</html>`
+
+const HTML_ERROR = `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>cc-haha OpenAI Authorization Failed</title>
+  </head>
+  <body>
+    <h1>Authorization Failed</h1>
+    <p>You can close this window and return to Claude Code Haha.</p>
+  </body>
+</html>`
+
+export class OpenAIOAuthService {
+  private codeVerifier: string
+  private authCodeListener: AuthCodeListener | null = null
+  private port: number | null = null
+
+  constructor() {
+    this.codeVerifier = generateCodeVerifier()
+  }
+
+  async startOAuthFlow(
+    authURLHandler: (url: string) => Promise<void>,
+  ): Promise<OpenAIOAuthTokens> {
+    this.authCodeListener = new AuthCodeListener(OPENAI_CODEX_REDIRECT_PATH)
+    this.port = await this.authCodeListener.start(OPENAI_CODEX_OAUTH_PORT)
+
+    const state = generateState()
+    const redirectUri = `http://localhost:${this.port}${OPENAI_CODEX_REDIRECT_PATH}`
+    const authorizeUrl = buildOpenAIAuthorizeUrl({
+      redirectUri,
+      codeVerifier: this.codeVerifier,
+      state,
+    })
+
+    const authorizationCode = await new Promise<string>((resolve, reject) => {
+      this.authCodeListener
+        ?.waitForAuthorization(state, async () => {
+          await authURLHandler(authorizeUrl)
+          await openBrowser(authorizeUrl)
+        })
+        .then(resolve)
+        .catch(reject)
+    })
+
+    try {
+      const response = await exchangeOpenAICodeForTokens({
+        code: authorizationCode,
+        redirectUri,
+        codeVerifier: this.codeVerifier,
+      })
+
+      const tokens = normalizeOpenAITokens(response)
+      const storage = saveOpenAIOAuthTokens(tokens)
+      if (!storage.success) {
+        throw new Error(storage.warning ?? 'Failed to persist OpenAI OAuth tokens')
+      }
+
+      this.authCodeListener?.handleSuccessRedirect([], (res) => {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+        res.end(HTML_SUCCESS)
+      })
+
+      return tokens
+    } catch (error) {
+      this.authCodeListener?.handleSuccessRedirect([], (res) => {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+        res.end(HTML_ERROR)
+      })
+      throw error
+    } finally {
+      this.cleanup()
+    }
+  }
+
+  async ensureFreshTokens(): Promise<OpenAIOAuthTokens | null> {
+    clearOpenAIOAuthTokenCache()
+    const tokens = await getOpenAIOAuthTokensAsync()
+    if (!tokens) return null
+    if (!isOpenAITokenExpired(tokens.expiresAt)) return tokens
+
+    const refreshed = await refreshOpenAITokens(tokens.refreshToken)
+    const updated = withRefreshedAccessToken(tokens, refreshed)
+    const storage = saveOpenAIOAuthTokens(updated)
+    if (!storage.success) {
+      throw new Error(storage.warning ?? 'Failed to persist refreshed OpenAI tokens')
+    }
+
+    return updated
+  }
+
+  async ensureFreshAccessToken(): Promise<string | null> {
+  const tokens = await this.ensureFreshTokens()
+  return tokens?.accessToken ?? null
+  }
+
+  logout(): boolean {
+    clearOpenAIOAuthTokenCache()
+    return deleteOpenAIOAuthTokens()
+  }
+
+  cleanup(): void {
+    this.authCodeListener?.close()
+    this.authCodeListener = null
+    this.port = null
+  }
+}
+
+export async function ensureFreshOpenAITokens(): Promise<OpenAIOAuthTokens | null> {
+  clearOpenAIOAuthTokenCache()
+  const tokens = await getOpenAIOAuthTokensAsync()
+  if (!tokens) return null
+  if (!isOpenAITokenExpired(tokens.expiresAt)) return tokens
+
+  try {
+    const refreshed = await refreshOpenAITokens(tokens.refreshToken)
+    const updated = withRefreshedAccessToken(tokens, refreshed)
+    const storage = saveOpenAIOAuthTokens(updated)
+    if (!storage.success) {
+      throw new Error(storage.warning ?? 'Failed to persist refreshed OpenAI tokens')
+    }
+    return updated
+  } catch {
+    return null
+  }
+}
diff --git a/src/services/openaiAuth/models.test.ts b/src/services/openaiAuth/models.test.ts
new file mode 100644
index 00000000..2665dcf1
--- /dev/null
+++ b/src/services/openaiAuth/models.test.ts
@@ -0,0 +1,21 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  OPENAI_DEFAULT_MAIN_MODEL,
+  isOpenAIResponsesModel,
+  resolveOpenAICodexModel,
+} from './models.js'
+
+describe('openai auth model resolution', () => {
+  test('does not treat opus as an OpenAI Responses model', () => {
+    expect(isOpenAIResponsesModel('opus')).toBe(false)
+  })
+
+  test('accepts gpt and o-series models', () => {
+    expect(isOpenAIResponsesModel('gpt-5.4')).toBe(true)
+    expect(isOpenAIResponsesModel('o3-mini')).toBe(true)
+  })
+
+  test('maps opus aliases to the OpenAI default model', () => {
+    expect(resolveOpenAICodexModel('opus')).toBe(OPENAI_DEFAULT_MAIN_MODEL)
+  })
+})
diff --git a/src/services/openaiAuth/models.ts b/src/services/openaiAuth/models.ts
new file mode 100644
index 00000000..ca34e252
--- /dev/null
+++ b/src/services/openaiAuth/models.ts
@@ -0,0 +1,92 @@
+export const OPENAI_DEFAULT_MAIN_MODEL = 'gpt-5.3-codex'
+export const OPENAI_DEFAULT_SONNET_MODEL = 'gpt-5.4'
+export const OPENAI_DEFAULT_HAIKU_MODEL = 'gpt-5.4-mini'
+
+export type OpenAIModelCatalogEntry = {
+  value: string
+  label: string
+  description: string
+  descriptionForModel?: string
+}
+
+export const OPENAI_CODEX_MODEL_CATALOG: OpenAIModelCatalogEntry[] = [
+  {
+    value: OPENAI_DEFAULT_MAIN_MODEL,
+    label: 'GPT-5.3 Codex',
+    description: 'Best for coding and agentic work',
+    descriptionForModel: 'GPT-5.3 Codex - best for coding and agentic work',
+  },
+  {
+    value: OPENAI_DEFAULT_SONNET_MODEL,
+    label: 'GPT-5.4',
+    description: 'Strong general-purpose model',
+    descriptionForModel: 'GPT-5.4 - strong general-purpose model',
+  },
+  {
+    value: OPENAI_DEFAULT_HAIKU_MODEL,
+    label: 'GPT-5.4 Mini',
+    description: 'Fastest for quick tasks',
+    descriptionForModel: 'GPT-5.4 Mini - fastest for quick tasks',
+  },
+]
+
+export function isOpenAIResponsesModel(model: string): boolean {
+  const normalized = model.trim().toLowerCase()
+  return normalized.startsWith('gpt-') || /^o\d/.test(normalized)
+}
+
+export function resolveOpenAICodexModel(model: string): string {
+  if (process.env.OPENAI_CODEX_MODEL?.trim()) {
+    return process.env.OPENAI_CODEX_MODEL.trim()
+  }
+
+  const normalized = model.trim().toLowerCase()
+  if (isOpenAIResponsesModel(normalized)) {
+    return model
+  }
+
+  if (normalized.includes('haiku')) {
+    return (
+      process.env.OPENAI_CODEX_HAIKU_MODEL?.trim() ||
+      OPENAI_DEFAULT_HAIKU_MODEL
+    )
+  }
+
+  if (normalized.includes('sonnet')) {
+    return (
+      process.env.OPENAI_CODEX_SONNET_MODEL?.trim() ||
+      OPENAI_DEFAULT_SONNET_MODEL
+    )
+  }
+
+  if (normalized.includes('opus')) {
+    return (
+      process.env.OPENAI_CODEX_OPUS_MODEL?.trim() || OPENAI_DEFAULT_MAIN_MODEL
+    )
+  }
+
+  return OPENAI_DEFAULT_MAIN_MODEL
+}
+
+export function getOpenAIModelDisplayName(model: string): string | null {
+  switch (model.trim().toLowerCase()) {
+    case 'gpt-5.3-codex':
+      return 'GPT-5.3 Codex'
+    case 'gpt-5.4':
+      return 'GPT-5.4'
+    case 'gpt-5.4-mini':
+      return 'GPT-5.4 Mini'
+    case 'gpt-5.2':
+      return 'GPT-5.2'
+    case 'gpt-5.2-codex':
+      return 'GPT-5.2 Codex'
+    case 'gpt-5.1-codex':
+      return 'GPT-5.1 Codex'
+    case 'gpt-5.1-codex-max':
+      return 'GPT-5.1 Codex Max'
+    case 'gpt-5.1-codex-mini':
+      return 'GPT-5.1 Codex Mini'
+    default:
+      return null
+  }
+}
diff --git a/src/services/openaiAuth/storage.ts b/src/services/openaiAuth/storage.ts
new file mode 100644
index 00000000..93f9b0a6
--- /dev/null
+++ b/src/services/openaiAuth/storage.ts
@@ -0,0 +1,71 @@
+import memoize from 'lodash-es/memoize.js'
+import { getSecureStorage } from '../../utils/secureStorage/index.js'
+import { errorMessage } from '../../utils/errors.js'
+import { logError } from '../../utils/log.js'
+import type { OpenAIOAuthTokens } from './types.js'
+
+const STORAGE_KEY = 'openaiCodexOauth'
+
+type SecureStorageShape = Record<string, unknown> & {
+  openaiCodexOauth?: OpenAIOAuthTokens
+}
+
+export function saveOpenAIOAuthTokens(tokens: OpenAIOAuthTokens): {
+  success: boolean
+  warning?: string
+} {
+  try {
+    const storage = getSecureStorage()
+    const data = (storage.read() ?? {}) as SecureStorageShape
+    data[STORAGE_KEY] = tokens
+    const result = storage.update(data)
+    clearOpenAIOAuthTokenCache()
+    return result
+  } catch (error) {
+    logError(error)
+    return {
+      success: false,
+      warning: `Failed to save OpenAI OAuth tokens: ${errorMessage(error)}`,
+    }
+  }
+}
+
+export const getOpenAIOAuthTokens = memoize((): OpenAIOAuthTokens | null => {
+  try {
+    const storage = getSecureStorage()
+    const data = storage.read() as SecureStorageShape | null
+    return data?.openaiCodexOauth ?? null
+  } catch (error) {
+    logError(error)
+    return null
+  }
+})
+
+export async function getOpenAIOAuthTokensAsync(): Promise<OpenAIOAuthTokens | null> {
+  try {
+    const storage = getSecureStorage()
+    const data = (await storage.readAsync()) as SecureStorageShape | null
+    return data?.openaiCodexOauth ?? null
+  } catch (error) {
+    logError(error)
+    return null
+  }
+}
+
+export function clearOpenAIOAuthTokenCache(): void {
+  getOpenAIOAuthTokens.cache?.clear?.()
+}
+
+export function deleteOpenAIOAuthTokens(): boolean {
+  try {
+    const storage = getSecureStorage()
+    const data = (storage.read() ?? {}) as SecureStorageShape
+    delete data[STORAGE_KEY]
+    const result = storage.update(data)
+    clearOpenAIOAuthTokenCache()
+    return result.success
+  } catch (error) {
+    logError(error)
+    return false
+  }
+}
diff --git a/src/services/openaiAuth/types.ts b/src/services/openaiAuth/types.ts
new file mode 100644
index 00000000..6a2d9e5e
--- /dev/null
+++ b/src/services/openaiAuth/types.ts
@@ -0,0 +1,24 @@
+export type OpenAIOAuthTokenResponse = {
+  access_token: string
+  refresh_token: string
+  id_token?: string
+  expires_in?: number
+}
+
+export type OpenAIOAuthTokens = {
+  accessToken: string
+  refreshToken: string
+  expiresAt: number
+  idToken?: string
+  accountId?: string
+  email?: string
+}
+
+export type OpenAIJwtClaims = {
+  chatgpt_account_id?: string
+  organizations?: Array<{ id: string }>
+  email?: string
+  'https://api.openai.com/auth'?: {
+    chatgpt_account_id?: string
+  }
+}
diff --git a/src/utils/auth.ts b/src/utils/auth.ts
index 386d2f99..4e5806cc 100644
--- a/src/utils/auth.ts
+++ b/src/utils/auth.ts
@@ -19,6 +19,7 @@ import {
   getMockSubscriptionType,
   shouldUseMockSubscription,
 } from '../services/mockRateLimits.js'
+import { getOpenAIOAuthTokens } from '../services/openaiAuth/storage.js'
 import {
   isOAuthTokenExpired,
   refreshOAuthToken,
@@ -1183,6 +1184,27 @@ export async function removeApiKey(): Promise<void> {
   clearLegacyApiKeyPrefetch()
 }
 
+export function clearStoredClaudeAIOAuthTokens(): {
+  success: boolean
+  warning?: string
+} {
+  try {
+    const secureStorage = getSecureStorage()
+    const storageData = secureStorage.read() || {}
+
+    if ('claudeAiOauth' in storageData) {
+      delete storageData.claudeAiOauth
+    }
+
+    const result = secureStorage.update(storageData)
+    clearOAuthTokenCache()
+    return result
+  } catch (error) {
+    logError(error)
+    return { success: false, warning: 'Failed to clear stored Claude OAuth tokens' }
+  }
+}
+
 async function maybeRemoveApiKeyFromMacOSKeychain(): Promise<void> {
   try {
     await maybeRemoveApiKeyFromMacOSKeychainThrows()
@@ -1856,11 +1878,67 @@ export function isConsumerSubscriber(): boolean {
 }
 
 export type UserAccountInfo = {
+  provider?: 'anthropic' | 'openai'
   subscription?: string
   tokenSource?: string
   apiKeySource?: ApiKeySource
   organization?: string
   email?: string
+  accountId?: string
+}
+
+export function getOpenAISubscriptionName(): string {
+  return 'ChatGPT Pro/Plus'
+}
+
+export function getOpenAIAuthOverrideWarning(): string | null {
+  if (isUsing3PServices()) {
+    return 'OpenAI login is saved, but this shell is configured for a third-party provider.'
+  }
+
+  const { source: authTokenSource } = getAuthTokenSource()
+  if (authTokenSource !== 'none') {
+    return `OpenAI login is saved, but this shell is still using ${authTokenSource} for Anthropic-compatible auth.`
+  }
+
+  const { source: apiKeySource } = getAnthropicApiKeyWithSource({
+    skipRetrievingKeyFromApiKeyHelper: true,
+  })
+  if (apiKeySource !== 'none') {
+    return `OpenAI login is saved, but this shell is still using ${apiKeySource} for Anthropic-compatible auth.`
+  }
+
+  return null
+}
+
+export function isOpenAIAuthActive(): boolean {
+  return getOpenAIAccountInformationIfActive() !== undefined
+}
+
+function getOpenAIAccountInformationIfActive(input?: {
+  authTokenSource?: ReturnType<typeof getAuthTokenSource>['source']
+  apiKeySource?: ApiKeySource
+}): UserAccountInfo | undefined {
+  const openaiTokens = getOpenAIOAuthTokens()
+  if (!openaiTokens?.refreshToken || isUsing3PServices()) {
+    return undefined
+  }
+
+  const authTokenSource = input?.authTokenSource ?? getAuthTokenSource().source
+  const apiKeySource =
+    input?.apiKeySource ?? getAnthropicApiKeyWithSource().source
+
+  if (authTokenSource !== 'none' || apiKeySource !== 'none') {
+    return undefined
+  }
+
+  return {
+    provider: 'openai',
+    subscription: getOpenAISubscriptionName(),
+    tokenSource: 'OpenAI OAuth',
+    email: openaiTokens.email,
+    accountId: openaiTokens.accountId,
+  }
 }
 
 export function getAccountInformation() {
@@ -1870,7 +1948,17 @@ export function getAccountInformation() {
     return undefined
   }
   const { source: authTokenSource } = getAuthTokenSource()
+  const { key: apiKey, source: apiKeySource } = getAnthropicApiKeyWithSource()
+  const openAIAccountInfo = getOpenAIAccountInformationIfActive({
+    authTokenSource,
+    apiKeySource,
+  })
+  if (openAIAccountInfo) {
+    return openAIAccountInfo
+  }
+
   const accountInfo: UserAccountInfo = {}
+  accountInfo.provider = 'anthropic'
   if (
     authTokenSource === 'CLAUDE_CODE_OAUTH_TOKEN' ||
     authTokenSource === 'CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR'
@@ -1881,7 +1969,6 @@ export function getAccountInformation() {
   } else {
     accountInfo.tokenSource = authTokenSource
   }
-  const { key: apiKey, source: apiKeySource } = getAnthropicApiKeyWithSource()
   if (apiKey) {
     accountInfo.apiKeySource = apiKeySource
   }
diff --git a/src/utils/model/model.ts b/src/utils/model/model.ts
index 27821da1..b37fc1e7 100644
--- a/src/utils/model/model.ts
+++ b/src/utils/model/model.ts
@@ -10,6 +10,7 @@ import {
   getSubscriptionType,
   isClaudeAISubscriber,
   isMaxSubscriber,
+  isOpenAIAuthActive,
   isProSubscriber,
   isTeamPremiumSubscriber,
 } from '../auth.js'
@@ -27,6 +28,10 @@ import { getAPIProvider } from './providers.js'
 import { LIGHTNING_BOLT } from '../../constants/figures.js'
 import { isModelAllowed } from './modelAllowlist.js'
 import { type ModelAlias, isModelAlias } from './aliases.js'
+import {
+  getOpenAIModelDisplayName,
+  resolveOpenAICodexModel,
+} from '../../services/openaiAuth/models.js'
 import { capitalize } from '../stringUtils.js'
 
 export type ModelShortName = string
@@ -103,6 +108,9 @@ export function getBestModel(): ModelName {
 
 // @[MODEL LAUNCH]: Update the default Opus model (3P providers may lag so keep defaults unchanged).
 export function getDefaultOpusModel(): ModelName {
+  if (isOpenAIAuthActive()) {
+    return resolveOpenAICodexModel('opus')
+  }
   if (process.env.ANTHROPIC_DEFAULT_OPUS_MODEL) {
     return process.env.ANTHROPIC_DEFAULT_OPUS_MODEL
   }
@@ -117,6 +125,9 @@ export function getDefaultOpusModel(): ModelName {
 
 // @[MODEL LAUNCH]: Update the default Sonnet model (3P providers may lag so keep defaults unchanged).
 export function getDefaultSonnetModel(): ModelName {
+  if (isOpenAIAuthActive()) {
+    return resolveOpenAICodexModel('sonnet')
+  }
   if (process.env.ANTHROPIC_DEFAULT_SONNET_MODEL) {
     return process.env.ANTHROPIC_DEFAULT_SONNET_MODEL
   }
@@ -129,6 +140,9 @@ export function getDefaultSonnetModel(): ModelName {
 
 // @[MODEL LAUNCH]: Update the default Haiku model (3P providers may lag so keep defaults unchanged).
 export function getDefaultHaikuModel(): ModelName {
+  if (isOpenAIAuthActive()) {
+    return resolveOpenAICodexModel('haiku')
+  }
   if (process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL) {
     return process.env.ANTHROPIC_DEFAULT_HAIKU_MODEL
   }
@@ -188,6 +202,10 @@ export function getDefaultMainLoopModelSetting(): ModelName | ModelAlias {
     )
   }
 
+  if (isOpenAIAuthActive()) {
+    return resolveOpenAICodexModel('opus')
+  }
+
   // Max users get Opus as default
   if (isMaxSubscriber()) {
     return getDefaultOpusModel() + (isOpus1mMergeEnabled() ? '[1m]' : '')
@@ -290,6 +308,12 @@ export function getCanonicalName(fullModelName: ModelName): ModelShortName {
 export function getClaudeAiUserDefaultModelDescription(
   fastMode = false,
 ): string {
+  if (isOpenAIAuthActive()) {
+    const defaultModel = renderDefaultModelSetting(
+      getDefaultMainLoopModelSetting(),
+    )
+    return `${defaultModel} · OpenAI/Codex default`
+  }
   if (isMaxSubscriber() || isTeamPremiumSubscriber()) {
     if (isOpus1mMergeEnabled()) {
       return `Opus 4.7 with 1M context · Most capable for complex work${fastMode ? getOpus46PricingSuffix(true) : ''}`
@@ -351,6 +375,10 @@ export function renderModelSetting(setting: ModelName | ModelAlias): string {
  * if the model is not recognized as a public model.
  */
 export function getPublicModelDisplayName(model: ModelName): string | null {
+  const openAIModelName = getOpenAIModelDisplayName(model)
+  if (openAIModelName) {
+    return openAIModelName
+  }
   switch (model) {
     case getModelStrings().opus46:
       return 'Opus 4.7'
@@ -572,6 +600,10 @@ export function modelDisplayString(model: ModelSetting): string {
 
 // @[MODEL LAUNCH]: Add a marketing name mapping for the new model below.
 export function getMarketingNameForModel(modelId: string): string | undefined {
+  const openAIModelName = getOpenAIModelDisplayName(modelId)
+  if (openAIModelName) {
+    return openAIModelName
+  }
   if (getAPIProvider() === 'foundry') {
     // deployment ID is user-defined in Foundry, so it may have no relation to the actual model
     return undefined
diff --git a/src/utils/model/modelOptions.ts b/src/utils/model/modelOptions.ts
index f1996c9b..ce9d0871 100644
--- a/src/utils/model/modelOptions.ts
+++ b/src/utils/model/modelOptions.ts
@@ -3,6 +3,7 @@ import { getInitialMainLoopModel } from '../../bootstrap/state.js'
 import {
   isClaudeAISubscriber,
   isMaxSubscriber,
+  isOpenAIAuthActive,
   isTeamPremiumSubscriber,
 } from '../auth.js'
 import { getModelStrings } from './modelStrings.js'
@@ -32,6 +33,7 @@ import {
 } from './model.js'
 import { has1mContext } from '../context.js'
 import { getGlobalConfig } from '../config.js'
+import { OPENAI_CODEX_MODEL_CATALOG } from '../../services/openaiAuth/models.js'
 
 // @[MODEL LAUNCH]: Update all the available and default model option strings below.
 
@@ -55,6 +57,18 @@ export function getDefaultOptionForUser(fastMode = false): ModelOption {
     }
   }
 
+  if (isOpenAIAuthActive()) {
+    const currentModel = renderDefaultModelSetting(
+      getDefaultMainLoopModelSetting(),
+    )
+    return {
+      value: null,
+      label: 'Default (recommended)',
+      description: `Use the OpenAI/Codex default model (currently ${currentModel})`,
+      descriptionForModel: `OpenAI/Codex default model (currently ${currentModel})`,
+    }
+  }
+
   // Subscribers
   if (isClaudeAISubscriber()) {
     return {
@@ -295,6 +309,18 @@ function getAzureOpenAICodexOptions(): ModelOption[] {
   ]
 }
 
+function getOpenAIModelOptions(): ModelOption[] {
+  return [
+    getDefaultOptionForUser(),
+    ...OPENAI_CODEX_MODEL_CATALOG.map(model => ({
+      value: model.value,
+      label: model.label,
+      description: model.description,
+      descriptionForModel: model.descriptionForModel,
+    })),
+  ]
+}
+
 // @[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[] {
@@ -320,6 +346,10 @@ function getModelOptionsBase(fastMode = false): ModelOption[] {
     ]
   }
 
+  if (isOpenAIAuthActive()) {
+    return getOpenAIModelOptions()
+  }
+
   if (isClaudeAISubscriber()) {
     if (isMaxSubscriber() || isTeamPremiumSubscriber()) {
       // Max and Team Premium users: Opus is default, show Sonnet as alternative
diff --git a/src/utils/model/validateModel.ts b/src/utils/model/validateModel.ts
index c19f170b..a0c9c63c 100644
--- a/src/utils/model/validateModel.ts
+++ b/src/utils/model/validateModel.ts
@@ -3,6 +3,7 @@ import { MODEL_ALIASES } from './aliases.js'
 import { isModelAllowed } from './modelAllowlist.js'
 import { getAPIProvider } from './providers.js'
 import { sideQuery } from '../sideQuery.js'
+import { isOpenAIAuthActive } from '../auth.js'
 import {
   NotFoundError,
   APIError,
@@ -10,6 +11,7 @@ import {
   AuthenticationError,
 } from '@anthropic-ai/sdk'
 import { getModelStrings } from './modelStrings.js'
+import { isOpenAIResponsesModel } from '../../services/openaiAuth/models.js'
 
 // Cache valid models to avoid repeated API calls
 const validModelCache = new Map<string, boolean>()
@@ -109,6 +111,11 @@ export async function validateModel(
     return { valid: true }
   }
 
+  if (isOpenAIAuthActive() && isOpenAIResponsesModel(normalizedModel)) {
+    validModelCache.set(normalizedModel, true)
+    return { valid: true }
+  }
+
   // Check cache first
   if (validModelCache.has(normalizedModel)) {
     return { valid: true }
diff --git a/src/utils/status.tsx b/src/utils/status.tsx
index 2cc221b5..c271254f 100644
--- a/src/utils/status.tsx
+++ b/src/utils/status.tsx
@@ -203,10 +203,16 @@ export function buildAccountProperties(): Property[] {
     return [];
   }
   const properties: Property[] = [];
+  if (accountInfo.provider === 'openai') {
+    properties.push({
+      label: 'Provider',
+      value: 'OpenAI/Codex'
+    });
+  }
   if (accountInfo.subscription) {
     properties.push({
-      label: 'Login method',
-      value: `${accountInfo.subscription} Account`
+      label: accountInfo.provider === 'openai' ? 'Subscription' : 'Login method',
+      value: accountInfo.provider === 'openai' ? accountInfo.subscription : `${accountInfo.subscription} Account`
     });
   }
   if (accountInfo.tokenSource) {
@@ -235,6 +241,12 @@ export function buildAccountProperties(): Property[] {
       value: accountInfo.email
     });
   }
+  if (accountInfo.accountId && !process.env.IS_DEMO) {
+    properties.push({
+      label: 'Account ID',
+      value: accountInfo.accountId
+    });
+  }
   return properties;
 }
 export function buildAPIProviderProperties(): Property[] {
@@ -359,4 +371,4 @@ export function getModelDisplayLabel(mainLoopModel: string | null): string {
   }
   return modelLabel;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","figures","React","color","Text","MCPServerConnection","getAccountInformation","isClaudeAISubscriber","getLargeMemoryFiles","getMemoryFiles","MAX_MEMORY_CHARACTER_COUNT","getDoctorDiagnostic","getAWSRegion","getDefaultVertexRegion","isEnvTruthy","getDisplayPath","formatNumber","getIdeClientName","IDEExtensionInstallationStatus","isJetBrainsIde","toIDEDisplayName","getClaudeAiUserDefaultModelDescription","modelDisplayString","getAPIProvider","getMTLSConfig","checkInstall","getProxyUrl","SandboxManager","getSettingsWithAllErrors","getEnabledSettingSources","getSettingSourceDisplayNameCapitalized","getManagedFileSettingsPresence","getPolicySettingsOrigin","getSettingsForSource","ThemeName","Property","label","value","ReactNode","Array","Diagnostic","buildSandboxProperties","isSandboxed","isSandboxingEnabled","buildIDEProperties","mcpClients","ideInstallationStatus","theme","ideClient","find","client","name","ideName","ideType","pluginOrExtension","error","cross","installed","type","installedVersion","serverInfo","version","buildMcpProperties","clients","servers","filter","length","byState","connected","pending","needsAuth","failed","s","parts","push","join","buildMemoryDiagnostics","Promise","files","largeFiles","diagnostics","forEach","file","displayPath","path","content","buildSettingSourcesProperties","enabledSources","sourcesWithSettings","source","settings","Object","keys","sourceNames","map","origin","hasBase","hasDropIns","buildInstallationDiagnostics","installWarnings","warning","message","buildInstallationHealthDiagnostics","diagnostic","items","errors","validationErrors","invalidFiles","from","Set","fileList","warnings","issue","hasUpdatePermissions","buildAccountProperties","accountInfo","properties","subscription","tokenSource","apiKeySource","organization","process","env","IS_DEMO","email","buildAPIProviderProperties","apiProvider","providerLabel","bedrock","vertex","foundry","anthropicBaseUrl","ANTHROPIC_BASE_URL","bedrockBaseUrl","BEDROCK_BASE_URL","CLAUDE_CODE_SKIP_BEDROCK_AUTH","vertexBaseUrl","VERTEX_BASE_URL","gcpProject","ANTHROPIC_VERTEX_PROJECT_ID","CLAUDE_CODE_SKIP_VERTEX_AUTH","foundryBaseUrl","ANTHROPIC_FOUNDRY_BASE_URL","foundryResource","ANTHROPIC_FOUNDRY_RESOURCE","CLAUDE_CODE_SKIP_FOUNDRY_AUTH","proxyUrl","mtlsConfig","NODE_EXTRA_CA_CERTS","cert","CLAUDE_CODE_CLIENT_CERT","key","CLAUDE_CODE_CLIENT_KEY","getModelDisplayLabel","mainLoopModel","modelLabel","description","bold"],"sources":["status.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { color, Text } from '../ink.js'\nimport type { MCPServerConnection } from '../services/mcp/types.js'\nimport { getAccountInformation, isClaudeAISubscriber } from './auth.js'\nimport {\n  getLargeMemoryFiles,\n  getMemoryFiles,\n  MAX_MEMORY_CHARACTER_COUNT,\n} from './claudemd.js'\nimport { getDoctorDiagnostic } from './doctorDiagnostic.js'\nimport {\n  getAWSRegion,\n  getDefaultVertexRegion,\n  isEnvTruthy,\n} from './envUtils.js'\nimport { getDisplayPath } from './file.js'\nimport { formatNumber } from './format.js'\nimport {\n  getIdeClientName,\n  type IDEExtensionInstallationStatus,\n  isJetBrainsIde,\n  toIDEDisplayName,\n} from './ide.js'\nimport {\n  getClaudeAiUserDefaultModelDescription,\n  modelDisplayString,\n} from './model/model.js'\nimport { getAPIProvider } from './model/providers.js'\nimport { getMTLSConfig } from './mtls.js'\nimport { checkInstall } from './nativeInstaller/index.js'\nimport { getProxyUrl } from './proxy.js'\nimport { SandboxManager } from './sandbox/sandbox-adapter.js'\nimport { getSettingsWithAllErrors } from './settings/allErrors.js'\nimport {\n  getEnabledSettingSources,\n  getSettingSourceDisplayNameCapitalized,\n} from './settings/constants.js'\nimport {\n  getManagedFileSettingsPresence,\n  getPolicySettingsOrigin,\n  getSettingsForSource,\n} from './settings/settings.js'\nimport type { ThemeName } from './theme.js'\n\nexport type Property = {\n  label?: string\n  value: React.ReactNode | Array<string>\n}\n\nexport type Diagnostic = React.ReactNode\n\nexport function buildSandboxProperties(): Property[] {\n  if (\"external\" !== 'ant') {\n    return []\n  }\n\n  const isSandboxed = SandboxManager.isSandboxingEnabled()\n\n  return [\n    {\n      label: 'Bash Sandbox',\n      value: isSandboxed ? 'Enabled' : 'Disabled',\n    },\n  ]\n}\n\nexport function buildIDEProperties(\n  mcpClients: MCPServerConnection[],\n  ideInstallationStatus: IDEExtensionInstallationStatus | null = null,\n  theme: ThemeName,\n): Property[] {\n  const ideClient = mcpClients?.find(client => client.name === 'ide')\n\n  if (ideInstallationStatus) {\n    const ideName = toIDEDisplayName(ideInstallationStatus.ideType)\n    const pluginOrExtension = isJetBrainsIde(ideInstallationStatus.ideType)\n      ? 'plugin'\n      : 'extension'\n\n    if (ideInstallationStatus.error) {\n      return [\n        {\n          label: 'IDE',\n          value: (\n            <Text>\n              {color('error', theme)(figures.cross)} Error installing {ideName}{' '}\n              {pluginOrExtension}: {ideInstallationStatus.error}\n              {'\\n'}Please restart your IDE and try again.\n            </Text>\n          ),\n        },\n      ]\n    }\n\n    if (ideInstallationStatus.installed) {\n      if (ideClient && ideClient.type === 'connected') {\n        if (\n          ideInstallationStatus.installedVersion !==\n          ideClient.serverInfo?.version\n        ) {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion} (server version: ${ideClient.serverInfo?.version})`,\n            },\n          ]\n        } else {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion}`,\n            },\n          ]\n        }\n      } else {\n        return [\n          {\n            label: 'IDE',\n            value: `Installed ${ideName} ${pluginOrExtension}`,\n          },\n        ]\n      }\n    }\n  } else if (ideClient) {\n    const ideName = getIdeClientName(ideClient) ?? 'IDE'\n    if (ideClient.type === 'connected') {\n      return [\n        {\n          label: 'IDE',\n          value: `Connected to ${ideName} extension`,\n        },\n      ]\n    } else {\n      return [\n        {\n          label: 'IDE',\n          value: `${color('error', theme)(figures.cross)} Not connected to ${ideName}`,\n        },\n      ]\n    }\n  }\n\n  return []\n}\n\nexport function buildMcpProperties(\n  clients: MCPServerConnection[] = [],\n  theme: ThemeName,\n): Property[] {\n  const servers = clients.filter(client => client.name !== 'ide')\n  if (!servers.length) {\n    return []\n  }\n\n  // Summary instead of a full server list — 20+ servers wrapped onto many\n  // rows, dominating the Status pane. Show counts by state + /mcp hint.\n  const byState = { connected: 0, pending: 0, needsAuth: 0, failed: 0 }\n  for (const s of servers) {\n    if (s.type === 'connected') byState.connected++\n    else if (s.type === 'pending') byState.pending++\n    else if (s.type === 'needs-auth') byState.needsAuth++\n    else byState.failed++\n  }\n  const parts: string[] = []\n  if (byState.connected)\n    parts.push(color('success', theme)(`${byState.connected} connected`))\n  if (byState.needsAuth)\n    parts.push(color('warning', theme)(`${byState.needsAuth} need auth`))\n  if (byState.pending)\n    parts.push(color('inactive', theme)(`${byState.pending} pending`))\n  if (byState.failed)\n    parts.push(color('error', theme)(`${byState.failed} failed`))\n\n  return [\n    {\n      label: 'MCP servers',\n      value: `${parts.join(', ')} ${color('inactive', theme)('· /mcp')}`,\n    },\n  ]\n}\n\nexport async function buildMemoryDiagnostics(): Promise<Diagnostic[]> {\n  const files = await getMemoryFiles()\n  const largeFiles = getLargeMemoryFiles(files)\n\n  const diagnostics: Diagnostic[] = []\n\n  largeFiles.forEach(file => {\n    const displayPath = getDisplayPath(file.path)\n    diagnostics.push(\n      `Large ${displayPath} will impact performance (${formatNumber(file.content.length)} chars > ${formatNumber(MAX_MEMORY_CHARACTER_COUNT)})`,\n    )\n  })\n\n  return diagnostics\n}\n\nexport function buildSettingSourcesProperties(): Property[] {\n  const enabledSources = getEnabledSettingSources()\n\n  // Filter to only sources that actually have settings loaded\n  const sourcesWithSettings = enabledSources.filter(source => {\n    const settings = getSettingsForSource(source)\n    return settings !== null && Object.keys(settings).length > 0\n  })\n\n  // Map internal names to user-friendly names\n  // For policySettings, distinguish between remote and local (or skip if neither exists)\n  const sourceNames = sourcesWithSettings\n    .map(source => {\n      if (source === 'policySettings') {\n        const origin = getPolicySettingsOrigin()\n        if (origin === null) {\n          return null // Skip - no policy settings exist\n        }\n        switch (origin) {\n          case 'remote':\n            return 'Enterprise managed settings (remote)'\n          case 'plist':\n            return 'Enterprise managed settings (plist)'\n          case 'hklm':\n            return 'Enterprise managed settings (HKLM)'\n          case 'file': {\n            const { hasBase, hasDropIns } = getManagedFileSettingsPresence()\n            if (hasBase && hasDropIns) {\n              return 'Enterprise managed settings (file + drop-ins)'\n            }\n            if (hasDropIns) {\n              return 'Enterprise managed settings (drop-ins)'\n            }\n            return 'Enterprise managed settings (file)'\n          }\n          case 'hkcu':\n            return 'Enterprise managed settings (HKCU)'\n        }\n      }\n      return getSettingSourceDisplayNameCapitalized(source)\n    })\n    .filter((name): name is string => name !== null)\n\n  return [\n    {\n      label: 'Setting sources',\n      value: sourceNames,\n    },\n  ]\n}\n\nexport async function buildInstallationDiagnostics(): Promise<Diagnostic[]> {\n  const installWarnings = await checkInstall()\n  return installWarnings.map(warning => warning.message)\n}\n\nexport async function buildInstallationHealthDiagnostics(): Promise<\n  Diagnostic[]\n> {\n  const diagnostic = await getDoctorDiagnostic()\n  const items: Diagnostic[] = []\n\n  const { errors: validationErrors } = getSettingsWithAllErrors()\n  if (validationErrors.length > 0) {\n    const invalidFiles = Array.from(\n      new Set(validationErrors.map(error => error.file)),\n    )\n    const fileList = invalidFiles.join(', ')\n\n    items.push(\n      `Found invalid settings files: ${fileList}. They will be ignored.`,\n    )\n  }\n\n  // Add warnings from doctor diagnostic (includes leftover installations, config mismatches, etc.)\n  diagnostic.warnings.forEach(warning => {\n    items.push(warning.issue)\n  })\n\n  if (diagnostic.hasUpdatePermissions === false) {\n    items.push('No write permissions for auto-updates (requires sudo)')\n  }\n\n  return items\n}\n\nexport function buildAccountProperties(): Property[] {\n  const accountInfo = getAccountInformation()\n  if (!accountInfo) {\n    return []\n  }\n\n  const properties: Property[] = []\n\n  if (accountInfo.subscription) {\n    properties.push({\n      label: 'Login method',\n      value: `${accountInfo.subscription} Account`,\n    })\n  }\n\n  if (accountInfo.tokenSource) {\n    properties.push({\n      label: 'Auth token',\n      value: accountInfo.tokenSource,\n    })\n  }\n\n  if (accountInfo.apiKeySource) {\n    properties.push({\n      label: 'API key',\n      value: accountInfo.apiKeySource,\n    })\n  }\n\n  // Hide sensitive account info in demo mode\n  if (accountInfo.organization && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Organization',\n      value: accountInfo.organization,\n    })\n  }\n  if (accountInfo.email && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Email',\n      value: accountInfo.email,\n    })\n  }\n\n  return properties\n}\n\nexport function buildAPIProviderProperties(): Property[] {\n  const apiProvider = getAPIProvider()\n\n  const properties: Property[] = []\n\n  if (apiProvider !== 'firstParty') {\n    const providerLabel = {\n      bedrock: 'AWS Bedrock',\n      vertex: 'Google Vertex AI',\n      foundry: 'Microsoft Foundry',\n    }[apiProvider]\n\n    properties.push({\n      label: 'API provider',\n      value: providerLabel,\n    })\n  }\n\n  if (apiProvider === 'firstParty') {\n    const anthropicBaseUrl = process.env.ANTHROPIC_BASE_URL\n    if (anthropicBaseUrl) {\n      properties.push({\n        label: 'Anthropic base URL',\n        value: anthropicBaseUrl,\n      })\n    }\n  } else if (apiProvider === 'bedrock') {\n    const bedrockBaseUrl = process.env.BEDROCK_BASE_URL\n    if (bedrockBaseUrl) {\n      properties.push({\n        label: 'Bedrock base URL',\n        value: bedrockBaseUrl,\n      })\n    }\n\n    properties.push({\n      label: 'AWS region',\n      value: getAWSRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {\n      properties.push({\n        value: 'AWS auth skipped',\n      })\n    }\n  } else if (apiProvider === 'vertex') {\n    const vertexBaseUrl = process.env.VERTEX_BASE_URL\n    if (vertexBaseUrl) {\n      properties.push({\n        label: 'Vertex base URL',\n        value: vertexBaseUrl,\n      })\n    }\n\n    const gcpProject = process.env.ANTHROPIC_VERTEX_PROJECT_ID\n    if (gcpProject) {\n      properties.push({\n        label: 'GCP project',\n        value: gcpProject,\n      })\n    }\n\n    properties.push({\n      label: 'Default region',\n      value: getDefaultVertexRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {\n      properties.push({\n        value: 'GCP auth skipped',\n      })\n    }\n  } else if (apiProvider === 'foundry') {\n    const foundryBaseUrl = process.env.ANTHROPIC_FOUNDRY_BASE_URL\n    if (foundryBaseUrl) {\n      properties.push({\n        label: 'Microsoft Foundry base URL',\n        value: foundryBaseUrl,\n      })\n    }\n\n    const foundryResource = process.env.ANTHROPIC_FOUNDRY_RESOURCE\n    if (foundryResource) {\n      properties.push({\n        label: 'Microsoft Foundry resource',\n        value: foundryResource,\n      })\n    }\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_FOUNDRY_AUTH)) {\n      properties.push({\n        value: 'Microsoft Foundry auth skipped',\n      })\n    }\n  }\n\n  const proxyUrl = getProxyUrl()\n  if (proxyUrl) {\n    properties.push({\n      label: 'Proxy',\n      value: proxyUrl,\n    })\n  }\n\n  const mtlsConfig = getMTLSConfig()\n  if (process.env.NODE_EXTRA_CA_CERTS) {\n    properties.push({\n      label: 'Additional CA cert(s)',\n      value: process.env.NODE_EXTRA_CA_CERTS,\n    })\n  }\n  if (mtlsConfig) {\n    if (mtlsConfig.cert && process.env.CLAUDE_CODE_CLIENT_CERT) {\n      properties.push({\n        label: 'mTLS client cert',\n        value: process.env.CLAUDE_CODE_CLIENT_CERT,\n      })\n    }\n\n    if (mtlsConfig.key && process.env.CLAUDE_CODE_CLIENT_KEY) {\n      properties.push({\n        label: 'mTLS client key',\n        value: process.env.CLAUDE_CODE_CLIENT_KEY,\n      })\n    }\n  }\n\n  return properties\n}\n\nexport function getModelDisplayLabel(mainLoopModel: string | null): string {\n  let modelLabel = modelDisplayString(mainLoopModel)\n\n  if (mainLoopModel === null && isClaudeAISubscriber()) {\n    const description = getClaudeAiUserDefaultModelDescription()\n\n    modelLabel = `${chalk.bold('Default')} ${description}`\n  }\n\n  return modelLabel\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["chalk","figures","React","color","Text","MCPServerConnection","getAccountInformation","isClaudeAISubscriber","getLargeMemoryFiles","getMemoryFiles","MAX_MEMORY_CHARACTER_COUNT","getDoctorDiagnostic","getAWSRegion","getDefaultVertexRegion","isEnvTruthy","getDisplayPath","formatNumber","getIdeClientName","IDEExtensionInstallationStatus","isJetBrainsIde","toIDEDisplayName","getClaudeAiUserDefaultModelDescription","modelDisplayString","getAPIProvider","getMTLSConfig","checkInstall","getProxyUrl","SandboxManager","getSettingsWithAllErrors","getEnabledSettingSources","getSettingSourceDisplayNameCapitalized","getManagedFileSettingsPresence","getPolicySettingsOrigin","getSettingsForSource","ThemeName","Property","label","value","ReactNode","Array","Diagnostic","buildSandboxProperties","isSandboxed","isSandboxingEnabled","buildIDEProperties","mcpClients","ideInstallationStatus","theme","ideClient","find","client","name","ideName","ideType","pluginOrExtension","error","cross","installed","type","installedVersion","serverInfo","version","buildMcpProperties","clients","servers","filter","length","byState","connected","pending","needsAuth","failed","s","parts","push","join","buildMemoryDiagnostics","Promise","files","largeFiles","diagnostics","forEach","file","displayPath","path","content","buildSettingSourcesProperties","enabledSources","sourcesWithSettings","source","settings","Object","keys","sourceNames","map","origin","hasBase","hasDropIns","buildInstallationDiagnostics","installWarnings","warning","message","buildInstallationHealthDiagnostics","diagnostic","items","errors","validationErrors","invalidFiles","from","Set","fileList","warnings","issue","hasUpdatePermissions","buildAccountProperties","accountInfo","properties","subscription","tokenSource","apiKeySource","organization","process","env","IS_DEMO","email","buildAPIProviderProperties","apiProvider","providerLabel","bedrock","vertex","foundry","anthropicBaseUrl","ANTHROPIC_BASE_URL","bedrockBaseUrl","BEDROCK_BASE_URL","CLAUDE_CODE_SKIP_BEDROCK_AUTH","vertexBaseUrl","VERTEX_BASE_URL","gcpProject","ANTHROPIC_VERTEX_PROJECT_ID","CLAUDE_CODE_SKIP_VERTEX_AUTH","foundryBaseUrl","ANTHROPIC_FOUNDRY_BASE_URL","foundryResource","ANTHROPIC_FOUNDRY_RESOURCE","CLAUDE_CODE_SKIP_FOUNDRY_AUTH","proxyUrl","mtlsConfig","NODE_EXTRA_CA_CERTS","cert","CLAUDE_CODE_CLIENT_CERT","key","CLAUDE_CODE_CLIENT_KEY","getModelDisplayLabel","mainLoopModel","modelLabel","description","bold"],"sources":["status.tsx"],"sourcesContent":["import chalk from 'chalk'\nimport figures from 'figures'\nimport * as React from 'react'\nimport { color, Text } from '../ink.js'\nimport type { MCPServerConnection } from '../services/mcp/types.js'\nimport { getAccountInformation, isClaudeAISubscriber } from './auth.js'\nimport {\n  getLargeMemoryFiles,\n  getMemoryFiles,\n  MAX_MEMORY_CHARACTER_COUNT,\n} from './claudemd.js'\nimport { getDoctorDiagnostic } from './doctorDiagnostic.js'\nimport {\n  getAWSRegion,\n  getDefaultVertexRegion,\n  isEnvTruthy,\n} from './envUtils.js'\nimport { getDisplayPath } from './file.js'\nimport { formatNumber } from './format.js'\nimport {\n  getIdeClientName,\n  type IDEExtensionInstallationStatus,\n  isJetBrainsIde,\n  toIDEDisplayName,\n} from './ide.js'\nimport {\n  getClaudeAiUserDefaultModelDescription,\n  modelDisplayString,\n} from './model/model.js'\nimport { getAPIProvider } from './model/providers.js'\nimport { getMTLSConfig } from './mtls.js'\nimport { checkInstall } from './nativeInstaller/index.js'\nimport { getProxyUrl } from './proxy.js'\nimport { SandboxManager } from './sandbox/sandbox-adapter.js'\nimport { getSettingsWithAllErrors } from './settings/allErrors.js'\nimport {\n  getEnabledSettingSources,\n  getSettingSourceDisplayNameCapitalized,\n} from './settings/constants.js'\nimport {\n  getManagedFileSettingsPresence,\n  getPolicySettingsOrigin,\n  getSettingsForSource,\n} from './settings/settings.js'\nimport type { ThemeName } from './theme.js'\n\nexport type Property = {\n  label?: string\n  value: React.ReactNode | Array<string>\n}\n\nexport type Diagnostic = React.ReactNode\n\nexport function buildSandboxProperties(): Property[] {\n  if (\"external\" !== 'ant') {\n    return []\n  }\n\n  const isSandboxed = SandboxManager.isSandboxingEnabled()\n\n  return [\n    {\n      label: 'Bash Sandbox',\n      value: isSandboxed ? 'Enabled' : 'Disabled',\n    },\n  ]\n}\n\nexport function buildIDEProperties(\n  mcpClients: MCPServerConnection[],\n  ideInstallationStatus: IDEExtensionInstallationStatus | null = null,\n  theme: ThemeName,\n): Property[] {\n  const ideClient = mcpClients?.find(client => client.name === 'ide')\n\n  if (ideInstallationStatus) {\n    const ideName = toIDEDisplayName(ideInstallationStatus.ideType)\n    const pluginOrExtension = isJetBrainsIde(ideInstallationStatus.ideType)\n      ? 'plugin'\n      : 'extension'\n\n    if (ideInstallationStatus.error) {\n      return [\n        {\n          label: 'IDE',\n          value: (\n            <Text>\n              {color('error', theme)(figures.cross)} Error installing {ideName}{' '}\n              {pluginOrExtension}: {ideInstallationStatus.error}\n              {'\\n'}Please restart your IDE and try again.\n            </Text>\n          ),\n        },\n      ]\n    }\n\n    if (ideInstallationStatus.installed) {\n      if (ideClient && ideClient.type === 'connected') {\n        if (\n          ideInstallationStatus.installedVersion !==\n          ideClient.serverInfo?.version\n        ) {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion} (server version: ${ideClient.serverInfo?.version})`,\n            },\n          ]\n        } else {\n          return [\n            {\n              label: 'IDE',\n              value: `Connected to ${ideName} ${pluginOrExtension} version ${ideInstallationStatus.installedVersion}`,\n            },\n          ]\n        }\n      } else {\n        return [\n          {\n            label: 'IDE',\n            value: `Installed ${ideName} ${pluginOrExtension}`,\n          },\n        ]\n      }\n    }\n  } else if (ideClient) {\n    const ideName = getIdeClientName(ideClient) ?? 'IDE'\n    if (ideClient.type === 'connected') {\n      return [\n        {\n          label: 'IDE',\n          value: `Connected to ${ideName} extension`,\n        },\n      ]\n    } else {\n      return [\n        {\n          label: 'IDE',\n          value: `${color('error', theme)(figures.cross)} Not connected to ${ideName}`,\n        },\n      ]\n    }\n  }\n\n  return []\n}\n\nexport function buildMcpProperties(\n  clients: MCPServerConnection[] = [],\n  theme: ThemeName,\n): Property[] {\n  const servers = clients.filter(client => client.name !== 'ide')\n  if (!servers.length) {\n    return []\n  }\n\n  // Summary instead of a full server list — 20+ servers wrapped onto many\n  // rows, dominating the Status pane. Show counts by state + /mcp hint.\n  const byState = { connected: 0, pending: 0, needsAuth: 0, failed: 0 }\n  for (const s of servers) {\n    if (s.type === 'connected') byState.connected++\n    else if (s.type === 'pending') byState.pending++\n    else if (s.type === 'needs-auth') byState.needsAuth++\n    else byState.failed++\n  }\n  const parts: string[] = []\n  if (byState.connected)\n    parts.push(color('success', theme)(`${byState.connected} connected`))\n  if (byState.needsAuth)\n    parts.push(color('warning', theme)(`${byState.needsAuth} need auth`))\n  if (byState.pending)\n    parts.push(color('inactive', theme)(`${byState.pending} pending`))\n  if (byState.failed)\n    parts.push(color('error', theme)(`${byState.failed} failed`))\n\n  return [\n    {\n      label: 'MCP servers',\n      value: `${parts.join(', ')} ${color('inactive', theme)('· /mcp')}`,\n    },\n  ]\n}\n\nexport async function buildMemoryDiagnostics(): Promise<Diagnostic[]> {\n  const files = await getMemoryFiles()\n  const largeFiles = getLargeMemoryFiles(files)\n\n  const diagnostics: Diagnostic[] = []\n\n  largeFiles.forEach(file => {\n    const displayPath = getDisplayPath(file.path)\n    diagnostics.push(\n      `Large ${displayPath} will impact performance (${formatNumber(file.content.length)} chars > ${formatNumber(MAX_MEMORY_CHARACTER_COUNT)})`,\n    )\n  })\n\n  return diagnostics\n}\n\nexport function buildSettingSourcesProperties(): Property[] {\n  const enabledSources = getEnabledSettingSources()\n\n  // Filter to only sources that actually have settings loaded\n  const sourcesWithSettings = enabledSources.filter(source => {\n    const settings = getSettingsForSource(source)\n    return settings !== null && Object.keys(settings).length > 0\n  })\n\n  // Map internal names to user-friendly names\n  // For policySettings, distinguish between remote and local (or skip if neither exists)\n  const sourceNames = sourcesWithSettings\n    .map(source => {\n      if (source === 'policySettings') {\n        const origin = getPolicySettingsOrigin()\n        if (origin === null) {\n          return null // Skip - no policy settings exist\n        }\n        switch (origin) {\n          case 'remote':\n            return 'Enterprise managed settings (remote)'\n          case 'plist':\n            return 'Enterprise managed settings (plist)'\n          case 'hklm':\n            return 'Enterprise managed settings (HKLM)'\n          case 'file': {\n            const { hasBase, hasDropIns } = getManagedFileSettingsPresence()\n            if (hasBase && hasDropIns) {\n              return 'Enterprise managed settings (file + drop-ins)'\n            }\n            if (hasDropIns) {\n              return 'Enterprise managed settings (drop-ins)'\n            }\n            return 'Enterprise managed settings (file)'\n          }\n          case 'hkcu':\n            return 'Enterprise managed settings (HKCU)'\n        }\n      }\n      return getSettingSourceDisplayNameCapitalized(source)\n    })\n    .filter((name): name is string => name !== null)\n\n  return [\n    {\n      label: 'Setting sources',\n      value: sourceNames,\n    },\n  ]\n}\n\nexport async function buildInstallationDiagnostics(): Promise<Diagnostic[]> {\n  const installWarnings = await checkInstall()\n  return installWarnings.map(warning => warning.message)\n}\n\nexport async function buildInstallationHealthDiagnostics(): Promise<\n  Diagnostic[]\n> {\n  const diagnostic = await getDoctorDiagnostic()\n  const items: Diagnostic[] = []\n\n  const { errors: validationErrors } = getSettingsWithAllErrors()\n  if (validationErrors.length > 0) {\n    const invalidFiles = Array.from(\n      new Set(validationErrors.map(error => error.file)),\n    )\n    const fileList = invalidFiles.join(', ')\n\n    items.push(\n      `Found invalid settings files: ${fileList}. They will be ignored.`,\n    )\n  }\n\n  // Add warnings from doctor diagnostic (includes leftover installations, config mismatches, etc.)\n  diagnostic.warnings.forEach(warning => {\n    items.push(warning.issue)\n  })\n\n  if (diagnostic.hasUpdatePermissions === false) {\n    items.push('No write permissions for auto-updates (requires sudo)')\n  }\n\n  return items\n}\n\nexport function buildAccountProperties(): Property[] {\n  const accountInfo = getAccountInformation()\n  if (!accountInfo) {\n    return []\n  }\n\n  const properties: Property[] = []\n\n  if (accountInfo.subscription) {\n    properties.push({\n      label: 'Login method',\n      value: `${accountInfo.subscription} Account`,\n    })\n  }\n\n  if (accountInfo.tokenSource) {\n    properties.push({\n      label: 'Auth token',\n      value: accountInfo.tokenSource,\n    })\n  }\n\n  if (accountInfo.apiKeySource) {\n    properties.push({\n      label: 'API key',\n      value: accountInfo.apiKeySource,\n    })\n  }\n\n  // Hide sensitive account info in demo mode\n  if (accountInfo.organization && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Organization',\n      value: accountInfo.organization,\n    })\n  }\n  if (accountInfo.email && !process.env.IS_DEMO) {\n    properties.push({\n      label: 'Email',\n      value: accountInfo.email,\n    })\n  }\n\n  return properties\n}\n\nexport function buildAPIProviderProperties(): Property[] {\n  const apiProvider = getAPIProvider()\n\n  const properties: Property[] = []\n\n  if (apiProvider !== 'firstParty') {\n    const providerLabel = {\n      bedrock: 'AWS Bedrock',\n      vertex: 'Google Vertex AI',\n      foundry: 'Microsoft Foundry',\n    }[apiProvider]\n\n    properties.push({\n      label: 'API provider',\n      value: providerLabel,\n    })\n  }\n\n  if (apiProvider === 'firstParty') {\n    const anthropicBaseUrl = process.env.ANTHROPIC_BASE_URL\n    if (anthropicBaseUrl) {\n      properties.push({\n        label: 'Anthropic base URL',\n        value: anthropicBaseUrl,\n      })\n    }\n  } else if (apiProvider === 'bedrock') {\n    const bedrockBaseUrl = process.env.BEDROCK_BASE_URL\n    if (bedrockBaseUrl) {\n      properties.push({\n        label: 'Bedrock base URL',\n        value: bedrockBaseUrl,\n      })\n    }\n\n    properties.push({\n      label: 'AWS region',\n      value: getAWSRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_BEDROCK_AUTH)) {\n      properties.push({\n        value: 'AWS auth skipped',\n      })\n    }\n  } else if (apiProvider === 'vertex') {\n    const vertexBaseUrl = process.env.VERTEX_BASE_URL\n    if (vertexBaseUrl) {\n      properties.push({\n        label: 'Vertex base URL',\n        value: vertexBaseUrl,\n      })\n    }\n\n    const gcpProject = process.env.ANTHROPIC_VERTEX_PROJECT_ID\n    if (gcpProject) {\n      properties.push({\n        label: 'GCP project',\n        value: gcpProject,\n      })\n    }\n\n    properties.push({\n      label: 'Default region',\n      value: getDefaultVertexRegion(),\n    })\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_VERTEX_AUTH)) {\n      properties.push({\n        value: 'GCP auth skipped',\n      })\n    }\n  } else if (apiProvider === 'foundry') {\n    const foundryBaseUrl = process.env.ANTHROPIC_FOUNDRY_BASE_URL\n    if (foundryBaseUrl) {\n      properties.push({\n        label: 'Microsoft Foundry base URL',\n        value: foundryBaseUrl,\n      })\n    }\n\n    const foundryResource = process.env.ANTHROPIC_FOUNDRY_RESOURCE\n    if (foundryResource) {\n      properties.push({\n        label: 'Microsoft Foundry resource',\n        value: foundryResource,\n      })\n    }\n\n    if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_FOUNDRY_AUTH)) {\n      properties.push({\n        value: 'Microsoft Foundry auth skipped',\n      })\n    }\n  }\n\n  const proxyUrl = getProxyUrl()\n  if (proxyUrl) {\n    properties.push({\n      label: 'Proxy',\n      value: proxyUrl,\n    })\n  }\n\n  const mtlsConfig = getMTLSConfig()\n  if (process.env.NODE_EXTRA_CA_CERTS) {\n    properties.push({\n      label: 'Additional CA cert(s)',\n      value: process.env.NODE_EXTRA_CA_CERTS,\n    })\n  }\n  if (mtlsConfig) {\n    if (mtlsConfig.cert && process.env.CLAUDE_CODE_CLIENT_CERT) {\n      properties.push({\n        label: 'mTLS client cert',\n        value: process.env.CLAUDE_CODE_CLIENT_CERT,\n      })\n    }\n\n    if (mtlsConfig.key && process.env.CLAUDE_CODE_CLIENT_KEY) {\n      properties.push({\n        label: 'mTLS client key',\n        value: process.env.CLAUDE_CODE_CLIENT_KEY,\n      })\n    }\n  }\n\n  return properties\n}\n\nexport function getModelDisplayLabel(mainLoopModel: string | null): string {\n  let modelLabel = modelDisplayString(mainLoopModel)\n\n  if (mainLoopModel === null && isClaudeAISubscriber()) {\n    const description = getClaudeAiUserDefaultModelDescription()\n\n    modelLabel = `${chalk.bold('Default')} ${description}`\n  }\n\n  return modelLabel\n}\n"],"mappings":"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","ignoreList":[]}