@pikoloo/codex-proxy 1.0.6 → 1.1.0

package/src/account-rotation/index.js

@@ -4,20 +4,20 @@ import {
     clearInvalid,
     isAllRateLimited,
     getMinWaitTimeMs,
-    clearExpiredLimits
+    clearExpiredLimits,
+    isAccountCoolingDown
 } from './rate-limits.js';
 
-import { createStrategy, STRATEGIES } from './strategies/index.js';
+const MAX_WAIT_BEFORE_ERROR_MS = 120000;
 
 export class AccountRotator {
-    constructor(accountManager, strategyName = 'sticky') {
+    constructor(accountManager) {
         this.accountManager = accountManager;
-        this.strategy = createStrategy(strategyName);
     }
 
-    selectAccount(modelId, options = {}) {
+    selectAccount(modelId) {
         const { accounts } = this.accountManager.listAccounts();
-        return this.strategy.selectAccount(accounts, modelId, options);
+        return selectAccount(accounts, modelId);
     }
 
     markRateLimited(email, resetMs, modelId) {
@@ -48,23 +48,11 @@ export class AccountRotator {
         return getMinWaitTimeMs(accounts, modelId);
     }
 
-    notifySuccess(account, modelId) {
-        if (this.strategy.notifySuccess) {
-            this.strategy.notifySuccess(account, modelId);
-        }
-    }
+    notifySuccess(account, modelId) {}
 
-    notifyRateLimit(account, modelId) {
-        if (this.strategy.notifyRateLimit) {
-            this.strategy.notifyRateLimit(account, modelId);
-        }
-    }
+    notifyRateLimit(account, modelId) {}
 
-    notifyFailure(account, modelId) {
-        if (this.strategy.notifyFailure) {
-            this.strategy.notifyFailure(account, modelId);
-        }
-    }
+    notifyFailure(account, modelId) {}
 
     clearExpiredLimits() {
         const { accounts } = this.accountManager.listAccounts();
@@ -72,18 +60,67 @@ export class AccountRotator {
         this.accountManager.save();
     }
 
-    getStrategyName() {
-        return this.strategy.name;
+}
+
+function selectAccount(accounts, modelId) {
+    if (!accounts || accounts.length === 0) {
+        return { account: null, index: 0, waitMs: 0 };
+    }
+
+    const activeIndex = accounts.findIndex((account) => account.isActive);
+    const startIndex = activeIndex >= 0 ? activeIndex : 0;
+
+    for (let offset = 0; offset < accounts.length; offset++) {
+        const index = (startIndex + offset) % accounts.length;
+        const account = accounts[index];
+
+        if (isAccountUsable(account, modelId)) {
+            account.lastUsed = Date.now();
+            return { account, index, waitMs: 0 };
+        }
     }
 
-    getStrategyLabel() {
-        return this.strategy.label;
+    const waitMs = getAccountWaitMs(accounts[startIndex], modelId);
+    if (waitMs > 0 && waitMs <= MAX_WAIT_BEFORE_ERROR_MS) {
+        return { account: null, index: startIndex, waitMs };
     }
+
+    return { account: null, index: startIndex, waitMs: 0 };
+}
+
+function isAccountUsable(account, modelId) {
+    if (!account) return false;
+    if (account.isInvalid) return false;
+    if (account.enabled === false) return false;
+    if (isAccountCoolingDown(account)) return false;
+
+    const waitMs = getModelRateLimitWaitMs(account, modelId);
+    return waitMs === 0;
+}
+
+function getAccountWaitMs(account, modelId) {
+    if (!account) return 0;
+    if (account.isInvalid) return 0;
+    if (account.enabled === false) return 0;
+    if (isAccountCoolingDown(account)) return 0;
+
+    return getModelRateLimitWaitMs(account, modelId);
+}
+
+function getModelRateLimitWaitMs(account, modelId) {
+    if (!modelId || !account?.modelRateLimits?.[modelId]) {
+        return 0;
+    }
+
+    const limit = account.modelRateLimits[modelId];
+    if (!limit?.isRateLimited || !limit.resetTime || limit.resetTime <= Date.now()) {
+        return 0;
+    }
+
+    return limit.resetTime - Date.now();
 }
 
 export {
-    createStrategy,
-    STRATEGIES,
     markRateLimited,
     markInvalid,
     clearInvalid,

package/src/format-converter.js

@@ -64,7 +64,7 @@ function extractSystemPrompt(system) {
  * Convert Anthropic Messages API request to OpenAI Responses API format
  */
 export function convertAnthropicToResponsesAPI(anthropicRequest) {
-    const { model, messages, system, tools, tool_choice } = anthropicRequest;
+    const { model, messages, system, tools, tool_choice, reasoningLevel } = anthropicRequest;
 
     // [CRITICAL] Clean cache_control from all messages FIRST
     // Claude Code CLI sends cache_control fields that the API rejects
@@ -89,6 +89,10 @@ export function convertAnthropicToResponsesAPI(anthropicRequest) {
         request.instructions = '';
     }
 
+    if (reasoningLevel) {
+        request.reasoning = { effort: reasoningLevel };
+    }
+
     return request;
 }
 

package/src/index.js

@@ -14,7 +14,7 @@ startServer({ port: PORT, host: HOST });
 
 console.log(`
 ╔══════════════════════════════════════════════════════════════╗
-║                 Codex Claude Proxy v1.0.6                    ║
+║                 Codex Claude Proxy v1.1.0                    ║
 ║                   (Direct API Mode)                          ║
 ╠══════════════════════════════════════════════════════════════╣
 ║  Server:   http://${HOST}:${PORT}                          ║

package/src/model-mapper.js

@@ -9,6 +9,43 @@ const DEFAULT_OPENAI_MODEL = 'gpt-5.5';
 const DEFAULT_SMALL_OPENAI_MODEL = 'gpt-5.4-mini';
 const LATEST_CODEX_MODEL = 'gpt-5.3-codex';
 const KILO_ENABLED_ENV = 'CODEX_CLAUDE_PROXY_ENABLE_KILO';
+const CLAUDE_MODEL_ALIASES = ['opus', 'sonnet', 'haiku'];
+const OPENAI_MODEL_OPTIONS = [
+  { id: 'gpt-5.5', name: 'GPT-5.5' },
+  { id: 'gpt-5.5-2026-04-23', name: 'GPT-5.5 Snapshot' },
+  { id: 'gpt-5.4', name: 'GPT-5.4' },
+  { id: 'gpt-5.4-2026-03-05', name: 'GPT-5.4 Snapshot' },
+  { id: 'gpt-5.4-mini', name: 'GPT-5.4 Mini' },
+  { id: 'gpt-5.4-nano', name: 'GPT-5.4 Nano' },
+  { id: 'gpt-5.3-codex', name: 'GPT-5.3 Codex' },
+  { id: 'gpt-5.2-codex', name: 'GPT-5.2 Codex' },
+  { id: 'gpt-5.2', name: 'GPT-5.2' },
+  { id: 'gpt-5.1', name: 'GPT-5.1' },
+  { id: 'gpt-5', name: 'GPT-5' },
+  { id: 'gpt-5.1-codex-max', name: 'GPT-5.1 Codex Max' },
+  { id: 'gpt-5.1-codex', name: 'GPT-5.1 Codex' },
+  { id: 'gpt-5-codex', name: 'GPT-5 Codex' },
+  { id: 'gpt-5.1-codex-mini', name: 'GPT-5.1 Codex Mini' },
+  { id: 'gpt-5-codex-mini', name: 'GPT-5 Codex Mini' }
+];
+const OPENAI_MODEL_IDS = new Set(OPENAI_MODEL_OPTIONS.map((model) => model.id));
+const REASONING_LEVEL_OPTIONS = [
+  { id: 'low', name: 'Low', description: 'Fast responses with lighter reasoning' },
+  { id: 'medium', name: 'Medium', description: 'Balanced speed and reasoning depth' },
+  { id: 'high', name: 'High', description: 'Greater reasoning depth for complex work' },
+  { id: 'xhigh', name: 'Extra High', description: 'Extra high reasoning depth for complex work' }
+];
+const REASONING_LEVEL_IDS = new Set(REASONING_LEVEL_OPTIONS.map((level) => level.id));
+const DEFAULT_MODEL_MAPPINGS = {
+  opus: DEFAULT_OPENAI_MODEL,
+  sonnet: DEFAULT_OPENAI_MODEL,
+  haiku: DEFAULT_SMALL_OPENAI_MODEL
+};
+const DEFAULT_REASONING_MAPPINGS = {
+  opus: 'high',
+  sonnet: 'medium',
+  haiku: 'low'
+};
 
 const CLAUDE_MODEL_MAP = {
   // Current Claude 4.6 models (Feb 2026)
@@ -64,41 +101,114 @@ const CLAUDE_MODEL_MAP = {
   'gpt-5-codex-mini': 'gpt-5-codex-mini'
 };
 
+/**
+ * Normalizes persisted Claude alias mappings against supported GPT targets.
+ * @param {Record<string, string>} modelMappings
+ * @returns {{ opus: string, sonnet: string, haiku: string }}
+ */
+export function normalizeModelMappings(modelMappings = {}) {
+  const normalized = { ...DEFAULT_MODEL_MAPPINGS };
+  if (!modelMappings || typeof modelMappings !== 'object' || Array.isArray(modelMappings)) {
+    return normalized;
+  }
+
+  for (const alias of CLAUDE_MODEL_ALIASES) {
+    const candidate = modelMappings[alias];
+    if (typeof candidate === 'string' && OPENAI_MODEL_IDS.has(candidate)) {
+      normalized[alias] = candidate;
+    }
+  }
+
+  return normalized;
+}
+
+/**
+ * Normalizes persisted Claude alias reasoning mappings against supported efforts.
+ * @param {Record<string, string>} reasoningMappings
+ * @returns {{ opus: string, sonnet: string, haiku: string }}
+ */
+export function normalizeReasoningMappings(reasoningMappings = {}) {
+  const normalized = { ...DEFAULT_REASONING_MAPPINGS };
+  if (!reasoningMappings || typeof reasoningMappings !== 'object' || Array.isArray(reasoningMappings)) {
+    return normalized;
+  }
+
+  for (const alias of CLAUDE_MODEL_ALIASES) {
+    const candidate = reasoningMappings[alias];
+    if (typeof candidate === 'string' && REASONING_LEVEL_IDS.has(candidate)) {
+      normalized[alias] = candidate;
+    }
+  }
+
+  return normalized;
+}
+
+function inferClaudeAlias(modelLower) {
+  for (const alias of CLAUDE_MODEL_ALIASES) {
+    if (modelLower === alias || modelLower.includes(alias)) {
+      return alias;
+    }
+  }
+  return null;
+}
+
 /**
  * Maps a Claude/Anthropic model name to the upstream model identifier.
  * Falls back to the current OpenAI flagship model for unknown models.
  * @param {string} model
+ * @param {{ modelMappings?: Record<string, string> }} settings
  * @returns {string}
  */
-export function mapClaudeModel(model) {
+export function mapClaudeModel(model, settings = getServerSettings()) {
   if (!model) return DEFAULT_OPENAI_MODEL;
 
-  if (CLAUDE_MODEL_MAP[model]) {
-    return CLAUDE_MODEL_MAP[model];
-  }
-
-  const modelLower = model.toLowerCase();
+  const modelLower = String(model).toLowerCase();
 
   if (modelLower.startsWith('gpt-')) {
     return modelLower;
   }
 
-  if (modelLower.startsWith('claude-')) {
-    const cleanModel = modelLower.replace(/^claude-/, '');
-    if (cleanModel.includes('opus')) return DEFAULT_OPENAI_MODEL;
-    if (cleanModel.includes('sonnet')) return DEFAULT_OPENAI_MODEL;
-    if (cleanModel.includes('haiku')) return DEFAULT_SMALL_OPENAI_MODEL;
+  if (modelLower === 'codex') {
+    return LATEST_CODEX_MODEL;
   }
 
-  for (const [key, value] of Object.entries(CLAUDE_MODEL_MAP)) {
-    if (modelLower.includes(key.toLowerCase())) {
-      return value;
-    }
+  if (modelLower === 'kilo') {
+    return 'kilo';
+  }
+
+  const mappedAlias = inferClaudeAlias(modelLower);
+  if (mappedAlias) {
+    return normalizeModelMappings(settings?.modelMappings)[mappedAlias];
+  }
+
+  if (CLAUDE_MODEL_MAP[modelLower]) {
+    return CLAUDE_MODEL_MAP[modelLower];
   }
 
   return DEFAULT_OPENAI_MODEL;
 }
 
+/**
+ * Resolves the configured reasoning effort for Claude aliases.
+ * Direct GPT, codex, kilo, and unknown model requests do not force a reasoning level.
+ * @param {string} model
+ * @param {{ reasoningMappings?: Record<string, string> }} settings
+ * @returns {string|null}
+ */
+export function mapClaudeReasoningLevel(model, settings = getServerSettings()) {
+  if (!model) return null;
+
+  const modelLower = String(model).toLowerCase();
+  if (modelLower.startsWith('gpt-') || modelLower === 'codex' || modelLower === 'kilo') {
+    return null;
+  }
+
+  const mappedAlias = inferClaudeAlias(modelLower);
+  if (!mappedAlias) return null;
+
+  return normalizeReasoningMappings(settings?.reasoningMappings)[mappedAlias];
+}
+
 /**
  * Returns true if the mapped model should be routed through Kilo.
  * @param {string} mappedModel
@@ -117,40 +227,53 @@ export function isKiloEnabled() {
  * The setting stores the full Kilo model ID (e.g. 'minimax/minimax-m2.5:free').
  * @returns {string}
  */
-export function resolveKiloModel() {
-  const settings = getServerSettings();
+export function resolveKiloModel(settings = getServerSettings()) {
   return settings.haikuKiloModel || 'minimax/minimax-m2.5:free';
 }
 
 /**
  * Resolves all model routing info from a requested model name.
  * @param {string} requestedModel
- * @returns {{ mappedModel: string, isKilo: boolean, kiloTarget: string|null, upstreamModel: string }}
+ * @returns {{ mappedModel: string, isKilo: boolean, kiloTarget: string|null, upstreamModel: string, reasoningLevel: string|null }}
  */
-export function resolveModelRouting(requestedModel) {
-  const mappedModel = mapClaudeModel(requestedModel || DEFAULT_OPENAI_MODEL);
+export function resolveModelRouting(requestedModel, settings = getServerSettings()) {
+  const mappedModel = mapClaudeModel(requestedModel || DEFAULT_OPENAI_MODEL, settings);
+  const reasoningLevel = mapClaudeReasoningLevel(requestedModel, settings);
   const isKilo = isKiloModel(mappedModel);
-  const kiloTarget = isKilo ? resolveKiloModel() : null;
+  const kiloTarget = isKilo ? resolveKiloModel(settings) : null;
   const upstreamModel = isKilo ? kiloTarget : mappedModel;
-  return { mappedModel, isKilo, kiloTarget, upstreamModel };
+  return { mappedModel, isKilo, kiloTarget, upstreamModel, reasoningLevel };
 }
 
 export {
   CLAUDE_MODEL_MAP,
   DEFAULT_OPENAI_MODEL,
   DEFAULT_SMALL_OPENAI_MODEL,
+  DEFAULT_MODEL_MAPPINGS,
+  DEFAULT_REASONING_MAPPINGS,
+  CLAUDE_MODEL_ALIASES,
+  OPENAI_MODEL_OPTIONS,
+  REASONING_LEVEL_OPTIONS,
   LATEST_CODEX_MODEL,
   KILO_ENABLED_ENV
 };
 
 export default {
   mapClaudeModel,
+  mapClaudeReasoningLevel,
   isKiloModel,
   resolveKiloModel,
   resolveModelRouting,
   CLAUDE_MODEL_MAP,
   DEFAULT_OPENAI_MODEL,
   DEFAULT_SMALL_OPENAI_MODEL,
+  DEFAULT_MODEL_MAPPINGS,
+  DEFAULT_REASONING_MAPPINGS,
+  CLAUDE_MODEL_ALIASES,
+  OPENAI_MODEL_OPTIONS,
+  REASONING_LEVEL_OPTIONS,
+  normalizeModelMappings,
+  normalizeReasoningMappings,
   LATEST_CODEX_MODEL,
   KILO_ENABLED_ENV,
   isKiloEnabled

package/src/routes/api-routes.js

@@ -15,8 +15,17 @@ import { getStatus, ACCOUNTS_FILE } from '../account-manager.js';
 import { handleMessages } from './messages-route.js';
 import { handleChatCompletion, handleCountTokens } from './chat-route.js';
 import { handleListModels, handleAccountModels, handleAccountUsage } from './models-route.js';
-import { handleGetHaikuModel, handleSetHaikuModel, handleGetKiloModels, handleGetAccountStrategy, handleSetAccountStrategy } from './settings-route.js';
+import {
+  handleGetHaikuModel,
+  handleSetHaikuModel,
+  handleGetKiloModels,
+  handleGetModelMappings,
+  handleSetModelMappings,
+  handleGetClaudeProxySetting,
+  handleSetClaudeProxySetting
+} from './settings-route.js';
 import { handleGetLogs, handleStreamLogs } from './logs-route.js';
+import { handleGetMetricsRecent, handleGetMetricsStorage, handleGetMetricsSummary } from './metrics-route.js';
 import { handleGetClaudeConfig, handleSetProxyMode, handleSetDirectMode, handleSetClaudeApiEndpoint } from './claude-config-route.js';
 import {
   handleListAccounts,
@@ -64,8 +73,10 @@ export function registerApiRoutes(app, { port }) {
   app.get('/settings/haiku-model', handleGetHaikuModel);
   app.post('/settings/haiku-model', handleSetHaikuModel);
   app.get('/settings/kilo-models', handleGetKiloModels);
-  app.get('/settings/account-strategy', handleGetAccountStrategy);
-  app.post('/settings/account-strategy', handleSetAccountStrategy);
+  app.get('/settings/model-mappings', handleGetModelMappings);
+  app.post('/settings/model-mappings', handleSetModelMappings);
+  app.get('/settings/claude-proxy', handleGetClaudeProxySetting);
+  app.post('/settings/claude-proxy', handleSetClaudeProxySetting);
 
   // ─── Account Management ───────────────────────────────────────────────────
   app.get('/accounts', handleListAccounts);
@@ -93,6 +104,11 @@ export function registerApiRoutes(app, { port }) {
   // ─── Logs ──────────────────────────────────────────────────────────────────
   app.get('/api/logs', handleGetLogs);
   app.get('/api/logs/stream', handleStreamLogs);
+
+  // ─── Metrics ───────────────────────────────────────────────────────────────
+  app.get('/api/metrics/summary', handleGetMetricsSummary);
+  app.get('/api/metrics/recent', handleGetMetricsRecent);
+  app.get('/api/metrics/storage', handleGetMetricsStorage);
 }
 
 export default { registerApiRoutes };

package/src/routes/chat-route.js

@@ -10,6 +10,7 @@ import { DEFAULT_OPENAI_MODEL, isKiloEnabled, resolveModelRouting } from '../mod
 import { getCredentialsOrError, sendAuthError } from '../middleware/credentials.js';
 import { handleStreamError } from '../middleware/sse.js';
 import { logger } from '../utils/logger.js';
+import { recordUsageEventSafe } from '../usage-metrics.js';
 
 /**
  * POST /v1/chat/completions
@@ -21,9 +22,19 @@ export async function handleChatCompletion(req, res) {
   const body = req.body;
   const requestedModel = body.model || DEFAULT_OPENAI_MODEL;
 
-  const { isKilo, kiloTarget, upstreamModel } = resolveModelRouting(requestedModel);
+  const { isKilo, kiloTarget, upstreamModel, reasoningLevel } = resolveModelRouting(requestedModel);
 
   if (isKilo && !isKiloEnabled()) {
+    recordChatMetric({
+      body,
+      requestedModel,
+      upstreamModel,
+      provider: 'kilo',
+      accountLabel: 'kilo',
+      startTime,
+      status: 403,
+      errorType: 'kilo_disabled'
+    });
     return res.status(403).json({
       error: {
         message: 'Kilo routing is disabled. Set CODEX_CLAUDE_PROXY_ENABLE_KILO=true to enable third-party Kilo model routing.',
@@ -38,11 +49,20 @@ export async function handleChatCompletion(req, res) {
     creds = await getCredentialsOrError();
     if (!creds) {
       logger.response(401, { error: 'No active account' });
+      recordChatMetric({
+        body,
+        requestedModel,
+        upstreamModel,
+        provider: 'openai',
+        startTime,
+        status: 401,
+        errorType: 'auth_error'
+      });
       return sendAuthError(res, 'No active account. Add an account via /accounts/add');
     }
   }
 
-  const anthropicRequest = _buildAnthropicRequest(body, upstreamModel);
+  const anthropicRequest = _buildAnthropicRequest(body, upstreamModel, reasoningLevel);
 
   logger.request('POST', '/v1/chat/completions', {
     model: upstreamModel,
@@ -57,10 +77,31 @@ export async function handleChatCompletion(req, res) {
       : await sendMessage(anthropicRequest, creds.accessToken, creds.accountId);
 
     const duration = Date.now() - startTime;
-    logger.response(200, { model: upstreamModel, tokens: response.usage?.output_tokens || 0, duration });
+    logger.response(200, { model: upstreamModel, usage: response.usage, duration });
+    recordChatMetric({
+      body,
+      requestedModel,
+      upstreamModel,
+      provider: isKilo ? 'kilo' : 'openai',
+      accountLabel: isKilo ? 'kilo' : creds.email,
+      usage: response.usage,
+      startTime,
+      status: 200,
+      duration
+    });
 
     res.json(_buildOpenAIResponse(response, requestedModel));
   } catch (error) {
+    recordChatMetric({
+      body,
+      requestedModel,
+      upstreamModel,
+      provider: isKilo ? 'kilo' : 'openai',
+      accountLabel: isKilo ? 'kilo' : creds?.email,
+      startTime,
+      status: error.status || 500,
+      errorType: classifyMetricError(error)
+    });
     handleStreamError(res, error, upstreamModel, startTime);
   }
 }
@@ -117,7 +158,7 @@ export function handleCountTokens(req, res) {
  * @param {string} upstreamModel
  * @returns {object}
  */
-function _buildAnthropicRequest(body, upstreamModel) {
+function _buildAnthropicRequest(body, upstreamModel, reasoningLevel = null) {
   const anthropicRequest = {
     model: upstreamModel,
     messages: [],
@@ -125,6 +166,10 @@ function _buildAnthropicRequest(body, upstreamModel) {
     stream: false
   };
 
+  if (reasoningLevel) {
+    anthropicRequest.reasoningLevel = reasoningLevel;
+  }
+
   if (body.messages) {
     const systemMsg = body.messages.find(m => m.role === 'system');
     if (systemMsg) {
@@ -226,4 +271,32 @@ function _buildOpenAIResponse(response, responseModel) {
   };
 }
 
+function recordChatMetric(options) {
+  const body = options.body || {};
+  recordUsageEventSafe({
+    startedAt: new Date(options.startTime || Date.now()).toISOString(),
+    completedAt: new Date().toISOString(),
+    endpoint: '/v1/chat/completions',
+    requestedModel: options.requestedModel,
+    upstreamModel: options.upstreamModel,
+    accountLabel: options.accountLabel,
+    provider: options.provider,
+    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.includes('AUTH_EXPIRED')) return 'auth_expired';
+  if (message.startsWith('KILO_API_ERROR:')) return 'kilo_api_error';
+  if (message.startsWith('API_ERROR:')) return 'api_error';
+  return 'unknown_error';
+}
+
 export default { handleChatCompletion, handleCountTokens };