@pikoloo/codex-proxy 1.0.6 → 1.1.0

package/src/routes/messages-route.js

@@ -5,28 +5,23 @@ import { sendAuthError, getCredentialsOrError, getCredentialsForAccount } from '
 import { initSSEResponse, pipeSSEStream, handleStreamError } from '../middleware/sse.js';
 import { logger } from '../utils/logger.js';
 import { AccountRotator } from '../account-rotation/index.js';
-import { listAccounts, getActiveAccount, save } from '../account-manager.js';
-import { getServerSettings, isMultiAccountRotationEnabled } from '../server-settings.js';
+import { listAccounts, save } from '../account-manager.js';
+import { isMultiAccountRotationEnabled } from '../server-settings.js';
+import { recordUsageEventSafe, tapUsageEventStream } from '../usage-metrics.js';
 
 const MAX_RETRIES = 5;
 const MAX_WAIT_BEFORE_ERROR_MS = 120000;
 const SHORT_RATE_LIMIT_THRESHOLD_MS = 5000;
 
 let accountRotator = null;
-let currentStrategy = null;
 
 function getAccountRotator() {
-    const settings = getServerSettings();
-    const strategy = settings.accountStrategy || 'sticky';
-    
-    if (!accountRotator || currentStrategy !== strategy) {
+    if (!accountRotator) {
         accountRotator = new AccountRotator({
             listAccounts,
-            save,
-            getActiveAccount
-        }, strategy);
-        currentStrategy = strategy;
-        logger.info(`[Messages] Account strategy: ${strategy}`);
+            save
+        });
+        logger.info('[Messages] Account rotation enabled');
     }
     return accountRotator;
 }
@@ -37,10 +32,21 @@ export async function handleMessages(req, res) {
     const requestedModel = body.model || DEFAULT_OPENAI_MODEL;
     const isStreaming = body.stream !== false;
     
-    const { isKilo, kiloTarget, upstreamModel } = resolveModelRouting(requestedModel);
+    const { isKilo, kiloTarget, upstreamModel, reasoningLevel } = resolveModelRouting(requestedModel);
     
     if (isKilo) {
         if (!isKiloEnabled()) {
+            recordMessageMetric({
+                body,
+                endpoint: '/v1/messages',
+                requestedModel,
+                upstreamModel,
+                provider: 'kilo',
+                accountLabel: 'kilo',
+                startTime,
+                status: 403,
+                errorType: 'kilo_disabled'
+            });
             return res.status(403).json({
                 type: 'error',
                 error: {
@@ -59,10 +65,20 @@ export async function handleMessages(req, res) {
     if (!isMultiAccountRotationEnabled()) {
         const creds = await getCredentialsOrError();
         if (!creds) {
+            recordMessageMetric({
+                body,
+                endpoint: '/v1/messages',
+                requestedModel,
+                upstreamModel,
+                provider: 'openai',
+                startTime,
+                status: 401,
+                errorType: 'auth_error'
+            });
             return sendAuthError(res);
         }
 
-        const anthropicRequest = { ...body, model: upstreamModel };
+        const anthropicRequest = { ...body, model: upstreamModel, ...(reasoningLevel ? { reasoningLevel } : {}) };
         try {
             if (isStreaming) {
                 await _streamDirectWithRotation(res, anthropicRequest, creds, requestedModel, startTime, null);
@@ -71,6 +87,17 @@ export async function handleMessages(req, res) {
             }
             return;
         } catch (error) {
+            recordMessageMetric({
+                body,
+                endpoint: '/v1/messages',
+                requestedModel,
+                upstreamModel,
+                provider: 'openai',
+                accountLabel: creds.email,
+                startTime,
+                status: error.status || 500,
+                errorType: classifyMetricError(error)
+            });
             return handleStreamError(res, error, requestedModel, startTime);
         }
     }
@@ -79,6 +106,16 @@ export async function handleMessages(req, res) {
     const accountSnapshot = listAccounts();
 
     if (accountSnapshot.total === 0) {
+        recordMessageMetric({
+            body,
+            endpoint: '/v1/messages',
+            requestedModel,
+            upstreamModel,
+            provider: 'openai',
+            startTime,
+            status: 401,
+            errorType: 'auth_error'
+        });
         return sendAuthError(res, 'No active account with valid credentials. Add an account via /accounts/add');
     }
     
@@ -91,6 +128,16 @@ export async function handleMessages(req, res) {
             const minWait = rotator.getMinWaitTimeMs(upstreamModel);
             
             if (minWait > MAX_WAIT_BEFORE_ERROR_MS) {
+                recordMessageMetric({
+                    body,
+                    endpoint: '/v1/messages',
+                    requestedModel,
+                    upstreamModel,
+                    provider: 'openai',
+                    startTime,
+                    status: 429,
+                    errorType: 'rate_limited'
+                });
                 return handleStreamError(res, new Error(`RESOURCE_EXHAUSTED: All accounts rate-limited. Wait ${Math.round(minWait/1000)}s`), requestedModel, startTime);
             }
             
@@ -109,6 +156,16 @@ export async function handleMessages(req, res) {
                 attempt--;
                 continue;
             }
+            recordMessageMetric({
+                body,
+                endpoint: '/v1/messages',
+                requestedModel,
+                upstreamModel,
+                provider: 'openai',
+                startTime,
+                status: 401,
+                errorType: 'auth_error'
+            });
             return sendAuthError(res, 'No available accounts');
         }
         
@@ -118,7 +175,7 @@ export async function handleMessages(req, res) {
             continue;
         }
         
-        const anthropicRequest = { ...body, model: upstreamModel };
+        const anthropicRequest = { ...body, model: upstreamModel, ...(reasoningLevel ? { reasoningLevel } : {}) };
         
         try {
             if (isStreaming) {
@@ -152,38 +209,117 @@ export async function handleMessages(req, res) {
                 continue;
             }
             
+            recordMessageMetric({
+                body,
+                endpoint: '/v1/messages',
+                requestedModel,
+                upstreamModel,
+                provider: 'openai',
+                accountLabel: account.email,
+                startTime,
+                status: error.status || 500,
+                errorType: classifyMetricError(error)
+            });
             return handleStreamError(res, error, requestedModel, startTime);
         }
     }
     
+    recordMessageMetric({
+        body,
+        endpoint: '/v1/messages',
+        requestedModel,
+        upstreamModel,
+        provider: 'openai',
+        startTime,
+        status: 500,
+        errorType: 'max_retries'
+    });
     return handleStreamError(res, new Error('Max retries exceeded'), requestedModel, startTime);
 }
 
 async function _streamDirectWithRotation(res, anthropicRequest, creds, responseModel, startTime, rotator) {
     initSSEResponse(res);
-    const stream = sendMessageStream(anthropicRequest, creds.accessToken, creds.accountId, rotator, creds.email);
+    const sourceStream = sendMessageStream(anthropicRequest, creds.accessToken, creds.accountId, rotator, creds.email);
+    let finalUsage = null;
+    const stream = tapUsageEventStream(sourceStream, (usage) => {
+        finalUsage = usage;
+        recordMessageMetric({
+            body: anthropicRequest,
+            endpoint: '/v1/messages',
+            requestedModel: responseModel,
+            upstreamModel: anthropicRequest.model,
+            provider: 'openai',
+            accountLabel: creds.email,
+            stream: true,
+            usage,
+            startTime,
+            status: 200
+        });
+    });
     await pipeSSEStream(res, stream);
-    logger.response(200, { model: anthropicRequest.model, duration: Date.now() - startTime });
+    logger.response(200, { model: anthropicRequest.model, usage: finalUsage, duration: Date.now() - startTime });
 }
 
 async function _sendDirectWithRotation(res, anthropicRequest, creds, responseModel, startTime, rotator) {
     const response = await sendMessage(anthropicRequest, creds.accessToken, creds.accountId);
     const duration = Date.now() - startTime;
-    logger.response(200, { model: anthropicRequest.model, tokens: response.usage?.output_tokens || 0, duration });
+    logger.response(200, { model: anthropicRequest.model, usage: response.usage, duration });
+    recordMessageMetric({
+        body: anthropicRequest,
+        endpoint: '/v1/messages',
+        requestedModel: responseModel,
+        upstreamModel: anthropicRequest.model,
+        provider: 'openai',
+        accountLabel: creds.email,
+        stream: false,
+        usage: response.usage,
+        startTime,
+        status: 200,
+        duration
+    });
     res.json({ ...response, model: responseModel });
 }
 
 async function _streamKilo(res, anthropicRequest, kiloTarget, responseModel, startTime) {
     initSSEResponse(res);
-    const stream = sendKiloMessageStream(anthropicRequest, kiloTarget);
+    const sourceStream = sendKiloMessageStream(anthropicRequest, kiloTarget);
+    let finalUsage = null;
+    const stream = tapUsageEventStream(sourceStream, (usage) => {
+        finalUsage = usage;
+        recordMessageMetric({
+            body: anthropicRequest,
+            endpoint: '/v1/messages',
+            requestedModel: responseModel,
+            upstreamModel: kiloTarget,
+            provider: 'kilo',
+            accountLabel: 'kilo',
+            stream: true,
+            usage,
+            startTime,
+            status: 200
+        });
+    });
     await pipeSSEStream(res, stream);
-    logger.response(200, { model: kiloTarget, duration: Date.now() - startTime });
+    logger.response(200, { model: kiloTarget, usage: finalUsage, duration: Date.now() - startTime });
 }
 
 async function _sendKilo(res, anthropicRequest, kiloTarget, responseModel, startTime) {
     const response = await sendKiloMessage(anthropicRequest, kiloTarget);
     const duration = Date.now() - startTime;
-    logger.response(200, { model: kiloTarget, tokens: response.usage?.output_tokens || 0, duration });
+    logger.response(200, { model: kiloTarget, usage: response.usage, duration });
+    recordMessageMetric({
+        body: anthropicRequest,
+        endpoint: '/v1/messages',
+        requestedModel: responseModel,
+        upstreamModel: kiloTarget,
+        provider: 'kilo',
+        accountLabel: 'kilo',
+        stream: false,
+        usage: response.usage,
+        startTime,
+        status: 200,
+        duration
+    });
     res.json({
         id: response.id || undefined,
         type: 'message',
@@ -200,4 +336,36 @@ function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+function recordMessageMetric(options) {
+    const body = options.body || {};
+    recordUsageEventSafe({
+        startedAt: new Date(options.startTime || Date.now()).toISOString(),
+        completedAt: new Date().toISOString(),
+        endpoint: options.endpoint,
+        requestedModel: options.requestedModel,
+        upstreamModel: options.upstreamModel,
+        accountLabel: options.accountLabel,
+        provider: options.provider,
+        stream: options.stream ?? body.stream !== false,
+        messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
+        toolCount: Array.isArray(body.tools) ? body.tools.length : 0,
+        usage: options.usage,
+        status: options.status,
+        errorType: options.errorType,
+        durationMs: options.duration ?? Date.now() - (options.startTime || Date.now())
+    });
+}
+
+function classifyMetricError(error) {
+    const message = error?.message || '';
+    if (message.startsWith('RATE_LIMITED:') || message.startsWith('RESOURCE_EXHAUSTED:')) return 'rate_limited';
+    if (message.includes('AUTH_EXPIRED')) return 'auth_expired';
+    if (message.startsWith('CLOUDFLARE_BLOCKED:')) return 'cloudflare_blocked';
+    if (message.startsWith('FORBIDDEN:')) return 'forbidden';
+    if (message.startsWith('INVALID_REQUEST:')) return 'invalid_request';
+    if (message.startsWith('KILO_API_ERROR:')) return 'kilo_api_error';
+    if (message.startsWith('API_ERROR:')) return 'api_error';
+    return 'unknown_error';
+}
+
 export default { handleMessages };

package/src/routes/metrics-route.js

@@ -0,0 +1,43 @@
+import { getUsageMetricsStore } from '../usage-metrics.js';
+
+const VALID_RANGES = new Set(['24h', '7d', '30d', 'all']);
+const VALID_STATUSES = new Set(['success', 'error']);
+
+function parseFilters(query = {}) {
+  const limit = Number(query.limit);
+  const status = String(query.status || '');
+  return {
+    range: VALID_RANGES.has(query.range) ? query.range : '24h',
+    model: typeof query.model === 'string' && query.model.trim() ? query.model.trim() : undefined,
+    account: typeof query.account === 'string' && query.account.trim() ? query.account.trim() : undefined,
+    status: VALID_STATUSES.has(status) || /^\d+$/.test(status) ? status : undefined,
+    limit: Number.isFinite(limit) ? Math.max(1, Math.min(100, Math.trunc(limit))) : 50
+  };
+}
+
+function routeStore(options = {}) {
+  return options.metricsStore || getUsageMetricsStore();
+}
+
+export async function handleGetMetricsSummary(req, res, options = {}) {
+  const { limit, ...filters } = parseFilters(req.query);
+  const summary = await routeStore(options).getSummary(filters);
+  res.json({ success: true, summary });
+}
+
+export async function handleGetMetricsRecent(req, res, options = {}) {
+  const filters = parseFilters(req.query);
+  const recent = await routeStore(options).getRecentEvents(filters);
+  res.json({ success: true, ...recent });
+}
+
+export async function handleGetMetricsStorage(req, res, options = {}) {
+  const storage = await routeStore(options).getStorageInfo();
+  res.json({ success: true, storage });
+}
+
+export default {
+  handleGetMetricsSummary,
+  handleGetMetricsRecent,
+  handleGetMetricsStorage
+};

package/src/routes/settings-route.js

@@ -3,16 +3,39 @@
  * Handles server settings endpoints:
  *   GET  /settings/haiku-model
  *   POST /settings/haiku-model
- *   GET  /settings/account-strategy
- *   POST /settings/account-strategy
+ *   GET  /settings/claude-proxy
+ *   POST /settings/claude-proxy
  *   GET  /settings/kilo-models
  */
 
-import { getServerSettings, isMultiAccountRotationEnabled, setServerSettings } from '../server-settings.js';
+import { getServerSettings, setServerSettings } from '../server-settings.js';
 import { fetchFreeModels } from '../kilo-models.js';
-import { isKiloEnabled } from '../model-mapper.js';
+import {
+  CLAUDE_MODEL_ALIASES,
+  DEFAULT_MODEL_MAPPINGS,
+  DEFAULT_REASONING_MAPPINGS,
+  OPENAI_MODEL_OPTIONS,
+  REASONING_LEVEL_OPTIONS,
+  isKiloEnabled,
+  normalizeModelMappings,
+  normalizeReasoningMappings
+} from '../model-mapper.js';
 
-const VALID_STRATEGIES = ['sticky', 'round-robin'];
+const VALID_OPENAI_MODEL_IDS = new Set(OPENAI_MODEL_OPTIONS.map((model) => model.id));
+const VALID_REASONING_LEVEL_IDS = new Set(REASONING_LEVEL_OPTIONS.map((level) => level.id));
+
+function modelMappingsPayload(modelMappings, reasoningMappings) {
+  return {
+    success: true,
+    aliases: CLAUDE_MODEL_ALIASES,
+    models: OPENAI_MODEL_OPTIONS,
+    reasoningLevels: REASONING_LEVEL_OPTIONS,
+    defaults: DEFAULT_MODEL_MAPPINGS,
+    reasoningDefaults: DEFAULT_REASONING_MAPPINGS,
+    modelMappings: normalizeModelMappings(modelMappings),
+    reasoningMappings: normalizeReasoningMappings(reasoningMappings)
+  };
+}
 
 /**
  * GET /settings/haiku-model
@@ -100,37 +123,118 @@ export async function handleGetKiloModels(req, res) {
 }
 
 /**
- * GET /settings/account-strategy
- * Returns the current account selection strategy.
+ * GET /settings/model-mappings
+ * Returns editable Claude alias -> upstream GPT model mappings.
+ */
+export function handleGetModelMappings(req, res) {
+  const settings = getServerSettings();
+  res.json(modelMappingsPayload(settings.modelMappings, settings.reasoningMappings));
+}
+
+/**
+ * POST /settings/model-mappings
+ * Updates one or more Claude alias mappings.
+ */
+export function handleSetModelMappings(req, res) {
+  const { modelMappings, reasoningMappings } = req.body || {};
+  const hasModelMappings = modelMappings !== undefined;
+  const hasReasoningMappings = reasoningMappings !== undefined;
+
+  if (!hasModelMappings && !hasReasoningMappings) {
+    return res.status(400).json({
+      success: false,
+      error: 'modelMappings or reasoningMappings is required'
+    });
+  }
+
+  if (hasModelMappings && (!modelMappings || typeof modelMappings !== 'object' || Array.isArray(modelMappings))) {
+    return res.status(400).json({
+      success: false,
+      error: 'modelMappings is required and must be an object'
+    });
+  }
+
+  if (hasReasoningMappings && (!reasoningMappings || typeof reasoningMappings !== 'object' || Array.isArray(reasoningMappings))) {
+    return res.status(400).json({
+      success: false,
+      error: 'reasoningMappings must be an object'
+    });
+  }
+
+  const modelAliases = hasModelMappings ? Object.keys(modelMappings) : [];
+  const reasoningAliases = hasReasoningMappings ? Object.keys(reasoningMappings) : [];
+  const unknownAliases = [...modelAliases, ...reasoningAliases].filter((alias) => !CLAUDE_MODEL_ALIASES.includes(alias));
+  if (unknownAliases.length > 0) {
+    return res.status(400).json({
+      success: false,
+      error: `Invalid model mapping alias. Use one of: ${CLAUDE_MODEL_ALIASES.join(', ')}`
+    });
+  }
+
+  for (const [alias, model] of Object.entries(modelMappings || {})) {
+    if (typeof model !== 'string' || !VALID_OPENAI_MODEL_IDS.has(model)) {
+      return res.status(400).json({
+        success: false,
+        error: `Invalid model for ${alias}. Use one of: ${OPENAI_MODEL_OPTIONS.map((option) => option.id).join(', ')}`
+      });
+    }
+  }
+
+  for (const [alias, reasoning] of Object.entries(reasoningMappings || {})) {
+    if (typeof reasoning !== 'string' || !VALID_REASONING_LEVEL_IDS.has(reasoning)) {
+      return res.status(400).json({
+        success: false,
+        error: `Invalid reasoning level for ${alias}. Use one of: ${REASONING_LEVEL_OPTIONS.map((option) => option.id).join(', ')}`
+      });
+    }
+  }
+
+  const settings = getServerSettings();
+  const nextMappings = {
+    ...normalizeModelMappings(settings.modelMappings),
+    ...(modelMappings || {})
+  };
+  const nextReasoningMappings = {
+    ...normalizeReasoningMappings(settings.reasoningMappings),
+    ...(reasoningMappings || {})
+  };
+  const nextSettings = setServerSettings({
+    modelMappings: nextMappings,
+    reasoningMappings: nextReasoningMappings
+  });
+  res.json(modelMappingsPayload(nextSettings.modelMappings, nextSettings.reasoningMappings));
+}
+
+/**
+ * GET /settings/claude-proxy
+ * Returns Claude proxy configuration preferences.
  */
-export function handleGetAccountStrategy(req, res) {
+export function handleGetClaudeProxySetting(req, res) {
   const settings = getServerSettings();
   res.json({
     success: true,
-    accountStrategy: settings.accountStrategy,
-    rotationEnabled: isMultiAccountRotationEnabled()
+    configureClaudeOnStartup: settings.configureClaudeOnStartup === true
   });
 }
 
 /**
- * POST /settings/account-strategy
- * Updates the account selection strategy.
+ * POST /settings/claude-proxy
+ * Updates Claude proxy configuration preferences.
  */
-export function handleSetAccountStrategy(req, res) {
-  const { accountStrategy } = req.body || {};
+export function handleSetClaudeProxySetting(req, res) {
+  const { configureClaudeOnStartup } = req.body || {};
 
-  if (!VALID_STRATEGIES.includes(accountStrategy)) {
+  if (typeof configureClaudeOnStartup !== 'boolean') {
     return res.status(400).json({
       success: false,
-      error: `Invalid accountStrategy. Use one of: ${VALID_STRATEGIES.join(', ')}`
+      error: 'configureClaudeOnStartup is required and must be a boolean'
     });
   }
 
-  const settings = setServerSettings({ accountStrategy });
+  const settings = setServerSettings({ configureClaudeOnStartup });
   res.json({
     success: true,
-    accountStrategy: settings.accountStrategy,
-    rotationEnabled: isMultiAccountRotationEnabled()
+    configureClaudeOnStartup: settings.configureClaudeOnStartup === true
   });
 }
 
@@ -138,6 +242,8 @@ export default {
   handleGetHaikuModel, 
   handleSetHaikuModel,
   handleGetKiloModels,
-  handleGetAccountStrategy,
-  handleSetAccountStrategy
+  handleGetModelMappings,
+  handleSetModelMappings,
+  handleGetClaudeProxySetting,
+  handleSetClaudeProxySetting
 };

package/src/security.js

@@ -3,7 +3,8 @@ const CONTROL_PATH_PREFIXES = [
   '/accounts',
   '/settings',
   '/claude/config',
-  '/api/logs'
+  '/api/logs',
+  '/api/metrics'
 ];
 const SAFE_FETCH_SITES = new Set(['same-origin', 'same-site', 'none']);
 const SENSITIVE_KEY_RE = /(api[_-]?key|auth[_-]?token|access[_-]?token|refresh[_-]?token|id[_-]?token|secret|password)/i;

package/src/server-settings.js

@@ -7,9 +7,43 @@ const MULTI_ACCOUNT_ROTATION_ENV = 'CODEX_CLAUDE_PROXY_ENABLE_MULTI_ACCOUNT_ROTA
 
 const DEFAULT_SETTINGS = {
     haikuKiloModel: 'minimax/minimax-m2.5:free',
-    accountStrategy: 'sticky'
+    configureClaudeOnStartup: false,
+    modelMappings: {
+        opus: 'gpt-5.5',
+        sonnet: 'gpt-5.5',
+        haiku: 'gpt-5.4-mini'
+    },
+    reasoningMappings: {
+        opus: 'high',
+        sonnet: 'medium',
+        haiku: 'low'
+    }
 };
 
+export function normalizeSettings(data = {}) {
+    const modelMappings = data?.modelMappings && typeof data.modelMappings === 'object' && !Array.isArray(data.modelMappings)
+        ? data.modelMappings
+        : {};
+    const reasoningMappings = data?.reasoningMappings && typeof data.reasoningMappings === 'object' && !Array.isArray(data.reasoningMappings)
+        ? data.reasoningMappings
+        : {};
+
+    return {
+        haikuKiloModel: typeof data.haikuKiloModel === 'string'
+            ? data.haikuKiloModel
+            : DEFAULT_SETTINGS.haikuKiloModel,
+        configureClaudeOnStartup: data.configureClaudeOnStartup === true,
+        modelMappings: {
+            ...DEFAULT_SETTINGS.modelMappings,
+            ...modelMappings
+        },
+        reasoningMappings: {
+            ...DEFAULT_SETTINGS.reasoningMappings,
+            ...reasoningMappings
+        }
+    };
+}
+
 function ensureConfigDir() {
     if (!existsSync(CONFIG_DIR)) {
         mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
@@ -20,21 +54,21 @@ export function getServerSettings() {
     ensureConfigDir();
 
     if (!existsSync(SETTINGS_FILE)) {
-        return { ...DEFAULT_SETTINGS };
+        return normalizeSettings();
     }
 
     try {
         const data = JSON.parse(readFileSync(SETTINGS_FILE, 'utf8'));
-        return { ...DEFAULT_SETTINGS, ...data };
+        return normalizeSettings(data);
     } catch (error) {
         console.error('[ServerSettings] Failed to read settings:', error.message);
-        return { ...DEFAULT_SETTINGS };
+        return normalizeSettings();
     }
 }
 
 export function setServerSettings(patch = {}) {
     const current = getServerSettings();
-    const next = { ...current, ...patch };
+    const next = normalizeSettings({ ...current, ...patch });
 
     ensureConfigDir();
     writeFileSync(SETTINGS_FILE, JSON.stringify(next, null, 2), { mode: 0o600 });
@@ -50,6 +84,7 @@ export { SETTINGS_FILE, MULTI_ACCOUNT_ROTATION_ENV };
 export default {
     getServerSettings,
     setServerSettings,
+    normalizeSettings,
     isMultiAccountRotationEnabled,
     MULTI_ACCOUNT_ROTATION_ENV,
     SETTINGS_FILE

package/src/server.js

@@ -9,8 +9,16 @@ import cors from 'cors';
 import { ensureAccountsPersist, startAutoRefresh } from './account-manager.js';
 import { registerApiRoutes } from './routes/api-routes.js';
 import { buildAllowedOrigins, securityMiddleware } from './security.js';
+import { getServerSettings } from './server-settings.js';
+import { setProxyMode } from './claude-config.js';
 
 export const DEFAULT_HOST = '127.0.0.1';
+const CLAUDE_PROXY_MODELS = {
+  default: 'claude-sonnet-4-6',
+  opus: 'claude-opus-4-6',
+  sonnet: 'claude-sonnet-4-6',
+  haiku: 'claude-haiku-4-5'
+};
 
 export function createServer({ port, host = DEFAULT_HOST }) {
   ensureAccountsPersist();
@@ -52,7 +60,24 @@ export function createServer({ port, host = DEFAULT_HOST }) {
 
 export function startServer({ port, host = process.env.HOST || DEFAULT_HOST }) {
   const app = createServer({ port, host });
-  return app.listen(port, host);
+  const server = app.listen(port, host);
+  server.once('listening', () => {
+    configureClaudeOnStartup({ port }).catch((error) => {
+      console.error('[ClaudeConfig] Startup proxy configuration failed:', error.message);
+    });
+  });
+  return server;
+}
+
+export async function configureClaudeOnStartup({ port }) {
+  const settings = getServerSettings();
+  if (settings.configureClaudeOnStartup !== true) {
+    return { configured: false, reason: 'disabled' };
+  }
+
+  const proxyUrl = `http://localhost:${port}`;
+  await setProxyMode(proxyUrl, CLAUDE_PROXY_MODELS);
+  return { configured: true, proxyUrl };
 }
 
-export default { createServer, startServer };
+export default { createServer, startServer, configureClaudeOnStartup };