neoagent 2.3.1-beta.99 → 2.4.0

package/server/services/ai/providers/claudeCode.js

@@ -0,0 +1,273 @@
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const Anthropic = require('@anthropic-ai/sdk');
+const { AnthropicProvider } = require('./anthropic');
+
+const CLAUDE_CLI_CREDS_PATH = path.join(os.homedir(), '.claude', '.credentials.json');
+const CLAUDE_CODE_BASE_URL = 'https://api.anthropic.com';
+const CLAUDE_CODE_VERSION = process.env.CLAUDE_CODE_VERSION || '2.1.75';
+const CLAUDE_CODE_OAUTH_BETA = 'claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14';
+const CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude.";
+const CLAUDE_CODE_CLIENT_ID = '9d1c250a-e61b-44d9-88ed-5944d1962f5e';
+const CLAUDE_CODE_TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
+const CLAUDE_CODE_SCOPES = 'user:inference user:profile org:create_api_key user:sessions:claude_code user:mcp_servers';
+
+function readTokenRecord(data) {
+  const tokens = data?.claudeAiOauthTokens || data?.claudeAiOauth || {};
+  const access = tokens.accessToken || tokens.access;
+  const refresh = tokens.refreshToken || tokens.refresh;
+  const expires = tokens.expiresAt || tokens.expires;
+  return {
+    access: typeof access === 'string' && access ? access : null,
+    refresh: typeof refresh === 'string' && refresh ? refresh : null,
+    expires: typeof expires === 'number' && Number.isFinite(expires) ? expires : null,
+  };
+}
+
+function readTokenValue(data) {
+  return readTokenRecord(data).access;
+}
+
+function readClaudeCliTokenRecord() {
+  try {
+    const raw = fs.readFileSync(CLAUDE_CLI_CREDS_PATH, 'utf8');
+    const data = JSON.parse(raw);
+    return readTokenRecord(data);
+  } catch {
+    return { access: null, refresh: null, expires: null };
+  }
+}
+
+function readClaudeCliToken() {
+  return readClaudeCliTokenRecord().access;
+}
+
+function mergeAnthropicBeta(existing) {
+  if (!existing) return CLAUDE_CODE_OAUTH_BETA;
+  const seen = new Set();
+  return String(existing)
+    .split(',')
+    .concat(CLAUDE_CODE_OAUTH_BETA.split(','))
+    .map((item) => item.trim())
+    .filter((item) => {
+      if (!item || seen.has(item)) return false;
+      seen.add(item);
+      return true;
+    })
+    .join(',');
+}
+
+function normalizeExpiresAt(data) {
+  if (typeof data.expires_at === 'number' && Number.isFinite(data.expires_at)) {
+    return data.expires_at > 10_000_000_000 ? data.expires_at : data.expires_at * 1000;
+  }
+  if (typeof data.expiresAt === 'number' && Number.isFinite(data.expiresAt)) {
+    return data.expiresAt > 10_000_000_000 ? data.expiresAt : data.expiresAt * 1000;
+  }
+  if (typeof data.expires_in === 'number' && Number.isFinite(data.expires_in)) {
+    return Date.now() + (data.expires_in * 1000);
+  }
+  return null;
+}
+
+function sanitizeEnvKey(key) {
+  return String(key).replace(/[\r\n]/g, '');
+}
+
+function sanitizeEnvValue(value) {
+  return String(value).replace(/[\r\n]/g, '');
+}
+
+function persistEnvValue(key, value) {
+  if (!value) return;
+  try {
+    const { ENV_FILE } = require('../../../../runtime/paths');
+    const safeKey = sanitizeEnvKey(key);
+    const safeValue = sanitizeEnvValue(value);
+    const raw = fs.existsSync(ENV_FILE) ? fs.readFileSync(ENV_FILE, 'utf8') : '';
+    const lines = raw ? raw.split('\n') : [];
+    let replaced = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith(`${safeKey}=`)) {
+        lines[i] = `${safeKey}=${safeValue}`;
+        replaced = true;
+        break;
+      }
+    }
+    if (!replaced) lines.push(`${safeKey}=${safeValue}`);
+    const output = lines.filter((_, idx, arr) => idx !== arr.length - 1 || arr[idx] !== '').join('\n') + '\n';
+    fs.mkdirSync(path.dirname(ENV_FILE), { recursive: true });
+    fs.writeFileSync(ENV_FILE, output, { mode: 0o600 });
+  } catch { }
+}
+
+async function refreshClaudeCodeAccessToken(refreshToken, fetchImpl = fetch) {
+  if (!refreshToken) return null;
+  const response = await fetchImpl(CLAUDE_CODE_TOKEN_URL, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: CLAUDE_CODE_CLIENT_ID,
+    }),
+  });
+
+  const text = await response.text();
+  let data = {};
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    data = {};
+  }
+
+  if (!response.ok) {
+    const detail = data?.error?.message || data?.error_description || data?.error || text || 'Unknown error';
+    throw new Error(`Claude Code OAuth refresh failed: HTTP ${response.status} ${detail}`);
+  }
+  if (!data.access_token) {
+    throw new Error('Claude Code OAuth refresh succeeded but no access_token was returned.');
+  }
+
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token || refreshToken,
+    expires: normalizeExpiresAt(data),
+  };
+}
+
+function isAuthenticationError(err) {
+  return err?.status === 401 || err?.error?.type === 'authentication_error';
+}
+
+function isInferenceScopeError(err) {
+  const message = String(err?.error?.message || err?.message || '');
+  const type = String(err?.error?.type || err?.type || '');
+  return err?.status === 403
+    && (type === 'permission_error' || message.includes('"permission_error"'))
+    && message.includes('scope requirement')
+    && message.includes('user:inference');
+}
+
+function formatClaudeCodeCredentialError(err) {
+  if (isInferenceScopeError(err)) {
+    return new Error(`Claude Code OAuth token is missing inference scope. Re-run \`neoagent login claude-code\` to create a token with ${CLAUDE_CODE_SCOPES}.`);
+  }
+  return err;
+}
+
+class ClaudeCodeProvider extends AnthropicProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'claude-code';
+    this.models = [
+      'claude-opus-4-7',
+      'claude-sonnet-4-6',
+      'claude-haiku-4-5-20251001',
+    ];
+    this.contextWindows = {
+      'claude-opus-4-7': 200000,
+      'claude-sonnet-4-6': 200000,
+      'claude-haiku-4-5-20251001': 200000,
+    };
+
+    const cliTokenRecord = readClaudeCliTokenRecord();
+    const authToken = config.apiKey || process.env.CLAUDE_CODE_OAUTH_TOKEN || cliTokenRecord.access;
+    if (!authToken) {
+      console.warn('[ClaudeCode] No access token. Run `neoagent login claude-code` to authenticate.');
+    }
+
+    this.authToken = authToken || null;
+    this.refreshToken = config.refreshToken || process.env.CLAUDE_CODE_REFRESH_TOKEN || cliTokenRecord.refresh || null;
+    this.fetchImpl = config.fetch || fetch;
+    this.baseURL = config.baseUrl || CLAUDE_CODE_BASE_URL;
+    this.defaultHeaders = {
+      ...(config.defaultHeaders || {}),
+      accept: 'application/json',
+      'anthropic-dangerous-direct-browser-access': 'true',
+      'anthropic-beta': mergeAnthropicBeta(config.defaultHeaders?.['anthropic-beta']),
+      'user-agent': `claude-cli/${CLAUDE_CODE_VERSION}`,
+      'x-app': 'cli',
+    };
+
+    this.client = this.createClient(this.authToken, config);
+  }
+
+  createClient(authToken, config = this.config) {
+    // OAuth tokens use Authorization: Bearer. Claude Code subscription inference
+    // also requires the Claude Code beta surface headers used by the official CLI.
+    return new Anthropic({
+      authToken: authToken || undefined,
+      baseURL: this.baseURL,
+      defaultHeaders: authToken ? this.defaultHeaders : config.defaultHeaders,
+      ...(this.fetchImpl ? { fetch: this.fetchImpl } : {}),
+    });
+  }
+
+  async refreshClient() {
+    const refreshed = await refreshClaudeCodeAccessToken(this.refreshToken, this.fetchImpl);
+    if (!refreshed?.access) return false;
+    this.authToken = refreshed.access;
+    this.refreshToken = refreshed.refresh || this.refreshToken;
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = this.authToken;
+    persistEnvValue('CLAUDE_CODE_OAUTH_TOKEN', this.authToken);
+    if (this.refreshToken) {
+      process.env.CLAUDE_CODE_REFRESH_TOKEN = this.refreshToken;
+      persistEnvValue('CLAUDE_CODE_REFRESH_TOKEN', this.refreshToken);
+    }
+    this.client = this.createClient(this.authToken);
+    return true;
+  }
+
+  convertMessages(messages) {
+    const converted = super.convertMessages(messages);
+    if (!converted.system) {
+      converted.system = [{ type: 'text', text: CLAUDE_CODE_SYSTEM_PROMPT }];
+      return converted;
+    }
+    converted.system = [
+      { type: 'text', text: CLAUDE_CODE_SYSTEM_PROMPT },
+      { type: 'text', text: converted.system },
+    ];
+    return converted;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    try {
+      return await super.chat(messages, tools, options);
+    } catch (err) {
+      if ((!isAuthenticationError(err) && !isInferenceScopeError(err)) || !this.refreshToken) {
+        throw formatClaudeCodeCredentialError(err);
+      }
+      await this.refreshClient();
+      try {
+        return await super.chat(messages, tools, options);
+      } catch (retryErr) {
+        throw formatClaudeCodeCredentialError(retryErr);
+      }
+    }
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    try {
+      yield* super.stream(messages, tools, options);
+    } catch (err) {
+      if ((!isAuthenticationError(err) && !isInferenceScopeError(err)) || !this.refreshToken) {
+        throw formatClaudeCodeCredentialError(err);
+      }
+      await this.refreshClient();
+      try {
+        yield* super.stream(messages, tools, options);
+      } catch (retryErr) {
+        throw formatClaudeCodeCredentialError(retryErr);
+      }
+    }
+  }
+}
+
+module.exports = { ClaudeCodeProvider, readClaudeCliToken, refreshClaudeCodeAccessToken, CLAUDE_CODE_SCOPES };

package/server/services/ai/providers/openaiCodex.js

@@ -1,7 +1,68 @@
+const crypto = require('crypto');
 const OpenAI = require('openai');
 const { BaseProvider } = require('./base');
 
-const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
+const DEFAULT_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+const OPENAI_CODEX_EMPTY_INPUT_TEXT = ' ';
+const NEOAGENT_VERSION = (() => {
+  try {
+    return require('../../../../package.json').version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+})();
+
+// Stable per-process installation ID — Codex backend uses it for request tracking.
+const INSTALLATION_ID = crypto.randomUUID();
+
+function decodeJwtPayload(token) {
+  try {
+    const parts = String(token || '').split('.');
+    if (parts.length < 2) return null;
+    const payload = Buffer.from(parts[1], 'base64url').toString('utf8');
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+}
+
+function isCodexBackendBaseUrl(baseURL) {
+  const trimmed = String(baseURL || '').trim();
+  if (!trimmed) return false;
+
+  try {
+    const url = new URL(trimmed);
+    const path = url.pathname.replace(/\/+$/, '');
+    return url.hostname === 'chatgpt.com'
+      && (path === '/backend-api' || path === '/backend-api/v1' || path === '/backend-api/codex' || path === '/backend-api/codex/v1');
+  } catch {
+    return false;
+  }
+}
+
+function isOpenAIApiBaseUrl(baseURL) {
+  const trimmed = String(baseURL || '').trim();
+  if (!trimmed) return false;
+
+  try {
+    const url = new URL(trimmed);
+    const path = url.pathname.replace(/\/+$/, '');
+    return url.hostname === 'api.openai.com' && (path === '' || path === '/v1');
+  } catch {
+    return false;
+  }
+}
+
+function normalizeCodexBaseUrl(baseURL) {
+  if (!baseURL || isOpenAIApiBaseUrl(baseURL) || isCodexBackendBaseUrl(baseURL)) {
+    return DEFAULT_BASE_URL;
+  }
+  return baseURL;
+}
+
+function isNativeCodexResponsesBaseUrl(baseURL) {
+  return isCodexBackendBaseUrl(baseURL);
+}
 
 function normalizeContent(content) {
   if (content == null) return '';
@@ -18,33 +79,45 @@ function normalizeContent(content) {
   return String(content);
 }
 
-function normalizeInputContent(content) {
+function normalizeMessageContent(content, role = 'user') {
   if (content == null) return [];
+  const isAssistant = role === 'assistant';
+  const textType = isAssistant ? 'output_text' : 'input_text';
 
   if (typeof content === 'string') {
-    return [{ type: 'input_text', text: content }];
+    return [{ type: textType, text: content, ...(isAssistant ? { annotations: [] } : {}) }];
   }
 
   if (!Array.isArray(content)) {
     const text = String(content);
-    return text ? [{ type: 'input_text', text }] : [];
+    return text ? [{ type: textType, text, ...(isAssistant ? { annotations: [] } : {}) }] : [];
   }
 
   const parts = [];
   for (const part of content) {
     if (!part) continue;
     if (typeof part === 'string') {
-      if (part.trim()) parts.push({ type: 'input_text', text: part });
+      if (part.trim()) parts.push({ type: textType, text: part, ...(isAssistant ? { annotations: [] } : {}) });
       continue;
     }
     if (part.type === 'text' && typeof part.text === 'string') {
-      parts.push({ type: 'input_text', text: part.text });
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: [] } : {}) });
       continue;
     }
     if (part.type === 'input_text' && typeof part.text === 'string') {
-      parts.push({ type: 'input_text', text: part.text });
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: [] } : {}) });
+      continue;
+    }
+    if (part.type === 'output_text' && typeof part.text === 'string') {
+      parts.push({ type: textType, text: part.text, ...(isAssistant ? { annotations: part.annotations || [] } : {}) });
+      continue;
+    }
+    if (isAssistant && part.type === 'refusal') {
+      const refusal = typeof part.refusal === 'string' ? part.refusal : part.text;
+      if (typeof refusal === 'string') parts.push({ type: 'refusal', refusal });
       continue;
     }
+    if (isAssistant) continue;
     if (part.type === 'image_url') {
       const imageUrl = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url;
       if (imageUrl) {
@@ -126,11 +199,15 @@ class OpenAICodexProvider extends BaseProvider {
   constructor(config = {}) {
     super(config);
 
-    const baseURL = config.baseUrl || process.env.OPENAI_CODEX_BASE_URL || DEFAULT_BASE_URL;
+    const configuredBaseURL = config.baseUrl || process.env.OPENAI_CODEX_BASE_URL || DEFAULT_BASE_URL;
+    const baseURL = normalizeCodexBaseUrl(configuredBaseURL);
+
+    this.baseURL = baseURL;
+    this.usesCodexBackend = isCodexBackendBaseUrl(baseURL);
 
-    if (!baseURL.includes('chatgpt.com/backend-api/codex') && !baseURL.includes('api.openai.com')) {
+    if (!this.usesCodexBackend && !baseURL.includes('api.openai.com')) {
       console.warn(`[OpenAICodex] Using non-official base URL: ${baseURL}`);
-    } else if (baseURL.includes('chatgpt.com/backend-api/codex')) {
+    } else if (this.usesCodexBackend) {
       console.info(`[OpenAICodex] Using ChatGPT Codex endpoint: ${baseURL}`);
     }
 
@@ -145,11 +222,25 @@ class OpenAICodexProvider extends BaseProvider {
       'gpt-5.4',
       'gpt-5.4-mini',
     ]);
-    const defaultHeaders = baseURL.includes('chatgpt.com/backend-api/codex')
+
+    let accountId = process.env.OPENAI_CODEX_ACCOUNT_ID || '';
+    if (!accountId && this.usesCodexBackend) {
+      const accessToken = config.apiKey || process.env.OPENAI_CODEX_ACCESS_TOKEN || '';
+      const payload = decodeJwtPayload(accessToken);
+      // account_id lives in access_token directly, or nested under the OIDC namespace in id_token
+      accountId = payload?.chatgpt_account_id
+        || payload?.['https://api.openai.com/auth']?.chatgpt_account_id
+        || '';
+    }
+
+    const defaultHeaders = this.usesCodexBackend
       ? {
-          'Editor-Version': process.env.OPENAI_CODEX_EDITOR_VERSION || 'vscode/1.99.0',
-          'Editor-Plugin-Version': process.env.OPENAI_CODEX_EDITOR_PLUGIN_VERSION || 'neoagent/1.0.0',
-          'User-Agent': process.env.OPENAI_CODEX_USER_AGENT || 'NeoAgent/1.0.0',
+          'originator': 'openclaw',
+          'version': NEOAGENT_VERSION,
+          'User-Agent': `openclaw/${NEOAGENT_VERSION}`,
+          'x-codex-installation-id': INSTALLATION_ID,
+          'x-openai-internal-codex-residency': process.env.OPENAI_CODEX_RESIDENCY || 'us',
+          ...(accountId ? { 'ChatGPT-Account-Id': accountId } : {}),
         }
       : undefined;
 
@@ -157,6 +248,7 @@ class OpenAICodexProvider extends BaseProvider {
       apiKey: config.apiKey || process.env.OPENAI_CODEX_ACCESS_TOKEN,
       baseURL,
       defaultHeaders,
+      ...(config.fetch ? { fetch: config.fetch } : {}),
     });
   }
 
@@ -198,11 +290,12 @@ class OpenAICodexProvider extends BaseProvider {
         continue;
       }
 
-      const content = normalizeInputContent(msg.content);
+      const role = msg.role === 'assistant' ? 'assistant' : 'user';
+      const content = normalizeMessageContent(msg.content, role);
       if (content.length > 0) {
         input.push({
           type: 'message',
-          role: msg.role === 'assistant' ? 'assistant' : 'user',
+          role,
           content,
         });
       }
@@ -227,40 +320,120 @@ class OpenAICodexProvider extends BaseProvider {
       input,
     };
 
-    if (instructions.length > 0) {
+    if (this.usesCodexBackend) {
+      if (input.length === 0 && instructions.length > 0) {
+        input.push({
+          type: 'message',
+          role: 'user',
+          content: [{ type: 'input_text', text: OPENAI_CODEX_EMPTY_INPUT_TEXT }],
+        });
+      }
+      // instructions must always be present (even empty) — backend returns 400 if omitted
       request.instructions = instructions.join('\n\n');
+      request.store = false;
+      // tools fields must always be explicit
+      if (tools && tools.length > 0) {
+        request.tools = this.formatTools(tools);
+        request.tool_choice = options.toolChoice || 'auto';
+      } else {
+        request.tools = [];
+        request.tool_choice = 'auto';
+      }
+      request.parallel_tool_calls = false;
+      // reasoning: both effort and summary required for Codex reasoning models
+      if (this._isReasoningModel(model)) {
+        const effort = options.reasoningEffort || options.reasoning_effort || 'medium';
+        request.reasoning = { effort, summary: 'auto' };
+        request.include = ['reasoning.encrypted_content'];
+      }
+      this._sanitizeNativeCodexRequest(request);
+    } else {
+      if (instructions.length > 0) {
+        request.instructions = instructions.join('\n\n');
+      }
+      if (tools && tools.length > 0) {
+        request.tools = this.formatTools(tools);
+        request.tool_choice = options.toolChoice || 'auto';
+      }
+      request.max_output_tokens = options.maxTokens || 16384;
+      if (options.temperature !== undefined && options.temperature !== null) {
+        request.temperature = options.temperature;
+      }
+      const reasoningEffort = options.reasoningEffort || options.reasoning_effort;
+      if (reasoningEffort || this._isReasoningModel(model)) {
+        request.reasoning = { effort: reasoningEffort || 'medium' };
+      }
     }
 
-    if (tools && tools.length > 0) {
-      request.tools = this.formatTools(tools);
-      request.tool_choice = options.toolChoice || 'auto';
-    }
+    return request;
+  }
 
-    request.max_output_tokens = options.maxTokens || 16384;
+  _requestHeaders() {
+    const requestId = crypto.randomUUID();
+    return this.usesCodexBackend
+      ? {
+          'x-client-request-id': requestId,
+          'x-openclaw-session-id': requestId,
+          'x-openclaw-turn-id': requestId,
+          'x-openclaw-turn-attempt': '1',
+        }
+      : undefined;
+  }
 
-    if (options.temperature !== undefined && options.temperature !== null) {
-      request.temperature = options.temperature;
+  _sanitizeNativeCodexRequest(request) {
+    if (!isNativeCodexResponsesBaseUrl(this.baseURL)) return request;
+    for (const key of [
+      'max_output_tokens',
+      'metadata',
+      'prompt_cache_retention',
+      'service_tier',
+      'temperature',
+      'top_p',
+    ]) {
+      delete request[key];
     }
-
-    const reasoningEffort = options.reasoningEffort || options.reasoning_effort;
-    if (reasoningEffort || this._isReasoningModel(model)) {
-      request.reasoning = {
-        effort: reasoningEffort || 'medium',
-      };
+    if (request.text && typeof request.text === 'object' && !Array.isArray(request.text)) {
+      const text = { ...request.text };
+      delete text.format;
+      if (Object.keys(text).length > 0) {
+        request.text = text;
+      } else {
+        delete request.text;
+      }
     }
-
     return request;
   }
 
   async chat(messages, tools = [], options = {}) {
+    if (this.usesCodexBackend) {
+      let final = null;
+      let content = '';
+      for await (const event of this.stream(messages, tools, options)) {
+        if (event.type === 'content') {
+          content += event.content || '';
+          continue;
+        }
+        if (event.type === 'tool_calls' || event.type === 'done') {
+          final = event;
+        }
+      }
+      return {
+        content: final?.content || content,
+        toolCalls: final?.toolCalls || [],
+        finishReason: final?.finishReason || (final?.toolCalls?.length > 0 ? 'tool_calls' : 'stop'),
+        usage: final?.usage || null,
+        model: final?.model || options.model || this.config.model || this.getDefaultModel(),
+      };
+    }
+
     const model = options.model || this.config.model || this.getDefaultModel();
     const request = this._buildRequest(messages, tools, options, model);
     let response;
     try {
-      response = await this.client.responses.create({
-        model,
-        ...request,
-      });
+      response = await this.client.responses.create(
+        { model, ...request },
+        { headers: this._requestHeaders() },
+      );
     } catch (err) {
       throw new Error(`OpenAI Codex request failed: ${formatOpenAIError(err)}`);
     }
@@ -285,11 +458,10 @@ class OpenAICodexProvider extends BaseProvider {
     const request = this._buildRequest(messages, tools, options, model);
     let stream;
     try {
-      stream = await this.client.responses.create({
-        model,
-        ...request,
-        stream: true,
-      });
+      stream = await this.client.responses.create(
+        { model, ...request, stream: true },
+        { headers: this._requestHeaders() },
+      );
     } catch (err) {
       throw new Error(`OpenAI Codex request failed: ${formatOpenAIError(err)}`);
     }

package/server/services/ai/settings.js

@@ -72,12 +72,22 @@ const AI_PROVIDER_DEFINITIONS = Object.freeze({
   'openai-codex': {
     id: 'openai-codex',
     label: 'OpenAI Codex',
-    description: 'Use Codex models through OpenAI authentication.',
+    description: 'Use Codex models through ChatGPT Codex authentication.',
     envKey: 'OPENAI_CODEX_ACCESS_TOKEN',
     supportsApiKey: true,
     supportsBaseUrl: true,
     defaultEnabled: false,
-    defaultBaseUrl: 'https://api.openai.com/v1'
+    defaultBaseUrl: 'https://chatgpt.com/backend-api/codex'
+  },
+  'claude-code': {
+    id: 'claude-code',
+    label: 'Claude Code',
+    description: 'Claude models via Claude Code subscription. Login with `neoagent login claude-code`.',
+    envKey: 'CLAUDE_CODE_OAUTH_TOKEN',
+    supportsApiKey: true,
+    supportsBaseUrl: false,
+    defaultEnabled: false,
+    defaultBaseUrl: ''
   },
   ollama: {
     id: 'ollama',