@pikoloo/codex-proxy 1.0.7 → 1.1.0

package/src/server-settings.js

@@ -7,7 +7,6 @@ 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',
@@ -21,6 +20,30 @@ const DEFAULT_SETTINGS = {
     }
 };
 
+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 });
@@ -31,46 +54,21 @@ export function getServerSettings() {
     ensureConfigDir();
 
     if (!existsSync(SETTINGS_FILE)) {
-        return {
-            ...DEFAULT_SETTINGS,
-            modelMappings: { ...DEFAULT_SETTINGS.modelMappings },
-            reasoningMappings: { ...DEFAULT_SETTINGS.reasoningMappings }
-        };
+        return normalizeSettings();
     }
 
     try {
         const data = JSON.parse(readFileSync(SETTINGS_FILE, 'utf8'));
-        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 {
-            ...DEFAULT_SETTINGS,
-            ...data,
-            modelMappings: {
-                ...DEFAULT_SETTINGS.modelMappings,
-                ...modelMappings
-            },
-            reasoningMappings: {
-                ...DEFAULT_SETTINGS.reasoningMappings,
-                ...reasoningMappings
-            }
-        };
+        return normalizeSettings(data);
     } catch (error) {
         console.error('[ServerSettings] Failed to read settings:', error.message);
-        return {
-            ...DEFAULT_SETTINGS,
-            modelMappings: { ...DEFAULT_SETTINGS.modelMappings },
-            reasoningMappings: { ...DEFAULT_SETTINGS.reasoningMappings }
-        };
+        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 });
@@ -86,6 +84,7 @@ export { SETTINGS_FILE, MULTI_ACCOUNT_ROTATION_ENV };
 export default {
     getServerSettings,
     setServerSettings,
+    normalizeSettings,
     isMultiAccountRotationEnabled,
     MULTI_ACCOUNT_ROTATION_ENV,
     SETTINGS_FILE

package/src/utils/logger.js

@@ -140,8 +140,21 @@ class Logger extends EventEmitter {
 
     response(status, details = {}) {
         const parts = [`status=${status}`];
+        const usage = details.usage || {};
+        const inputTokens = usage.input_tokens ?? usage.prompt_tokens;
+        const outputTokens = usage.output_tokens ?? usage.completion_tokens;
+        const cacheTokens = usage.cache_read_input_tokens ?? usage.prompt_tokens_details?.cached_tokens;
+        const totalTokens = details.tokens ?? usage.total_tokens ?? (
+            Number.isFinite(inputTokens) && Number.isFinite(outputTokens)
+                ? inputTokens + outputTokens
+                : undefined
+        );
+
         if (details.model) parts.push(`model=${details.model}`);
-        if (details.tokens) parts.push(`tokens=${details.tokens}`);
+        if (Number.isFinite(totalTokens)) parts.push(`tokens=${totalTokens}`);
+        if (Number.isFinite(inputTokens)) parts.push(`input=${inputTokens}`);
+        if (Number.isFinite(outputTokens)) parts.push(`output=${outputTokens}`);
+        if (Number.isFinite(cacheTokens)) parts.push(`cache=${cacheTokens}`);
         if (details.duration) parts.push(`${details.duration}ms`);
         if (details.error) parts.push(`error=${details.error}`);
         

package/src/account-rotation/strategies/base-strategy.js

@@ -1,48 +0,0 @@
-import { isAccountCoolingDown } from '../rate-limits.js';
-
-export class BaseStrategy {
-    constructor(config, name = 'base') {
-        if (this.constructor === BaseStrategy) {
-            throw new Error('BaseStrategy is abstract and cannot be instantiated directly');
-        }
-        this.config = config;
-        this.name = name;
-    }
-
-    selectAccount(accounts, modelId, options) {
-        throw new Error('selectAccount must be implemented by subclass');
-    }
-
-    onSuccess(account, modelId) {}
-
-    onRateLimit(account, modelId) {}
-
-    onFailure(account, modelId) {}
-
-    isAccountUsable(account, modelId) {
-        if (!account) return false;
-        if (account.isInvalid) return false;
-        if (account.enabled === false) return false;
-        if (isAccountCoolingDown(account)) return false;
-        
-        // Check model-specific rate limit
-        if (modelId && account.modelRateLimits && account.modelRateLimits[modelId]) {
-            const limit = account.modelRateLimits[modelId];
-            if (limit.isRateLimited && limit.resetTime > Date.now()) {
-                return false;
-            }
-        }
-        
-        return true;
-    }
-
-    getUsableAccounts(accounts, modelId) {
-        const usable = [];
-        for (let i = 0; i < accounts.length; i++) {
-            if (this.isAccountUsable(accounts[i], modelId)) {
-                usable.push({ account: accounts[i], index: i });
-            }
-        }
-        return usable;
-    }
-}

package/src/account-rotation/strategies/index.js

@@ -1,31 +0,0 @@
-import { BaseStrategy } from './base-strategy.js';
-import { StickyStrategy } from './sticky-strategy.js';
-import { RoundRobinStrategy } from './round-robin-strategy.js';
-
-export { BaseStrategy, StickyStrategy, RoundRobinStrategy };
-
-export const DEFAULT_STRATEGY = 'sticky';
-
-export const STRATEGIES = {
-  STICKY: 'sticky',
-  ROUND_ROBIN: 'round-robin',
-};
-
-const strategyMap = {
-  sticky: StickyStrategy,
-  'round-robin': RoundRobinStrategy,
-};
-
-const strategyLabels = {
-  sticky: 'Sticky (Cache-Optimized)',
-  'round-robin': 'Round-Robin (Load-Balanced)',
-};
-
-export function createStrategy(name, config) {
-  const StrategyClass = strategyMap[name] || StickyStrategy;
-  return new StrategyClass(config);
-}
-
-export function getStrategyLabel(name) {
-  return strategyLabels[name] || strategyLabels[DEFAULT_STRATEGY];
-}

package/src/account-rotation/strategies/round-robin-strategy.js

@@ -1,42 +0,0 @@
-import { BaseStrategy } from './base-strategy.js';
-import { logger } from '../../utils/logger.js';
-
-export class RoundRobinStrategy extends BaseStrategy {
-    constructor(config) {
-        super(config, 'round-robin');
-        this.cursor = 0;
-    }
-
-    selectAccount(accounts, modelId, options = {}) {
-        if (!accounts || accounts.length === 0) {
-            return { account: null, index: 0, waitMs: 0 };
-        }
-
-        // Clamp cursor
-        if (this.cursor >= accounts.length) {
-            this.cursor = 0;
-        }
-
-        // Start from next position after cursor
-        const startIndex = (this.cursor + 1) % accounts.length;
-
-        for (let i = 0; i < accounts.length; i++) {
-            const checkIndex = (startIndex + i) % accounts.length;
-            const account = accounts[checkIndex];
-
-            if (this.isAccountUsable(account, modelId)) {
-                account.lastUsed = Date.now();
-                this.cursor = checkIndex;
-                logger.debug(`RoundRobinStrategy: Using account at index ${checkIndex}`);
-                return { account, index: checkIndex, waitMs: 0 };
-            }
-        }
-
-        // No usable accounts
-        return { account: null, index: this.cursor, waitMs: 0 };
-    }
-
-    resetCursor() {
-        this.cursor = 0;
-    }
-}

package/src/account-rotation/strategies/sticky-strategy.js

@@ -1,97 +0,0 @@
-import { BaseStrategy } from './base-strategy.js';
-import { logger } from '../../utils/logger.js';
-
-const MAX_WAIT_BEFORE_ERROR_MS = 120000;
-
-export class StickyStrategy extends BaseStrategy {
-    constructor(config) {
-        super(config, 'sticky');
-        this.currentIndex = 0;
-    }
-
-    selectAccount(accounts, modelId, options = {}) {
-        const { currentIndex = 0, onSave } = options;
-
-        if (!accounts || accounts.length === 0) {
-            return { account: null, index: currentIndex, waitMs: 0 };
-        }
-
-        const clampedIndex = Math.max(0, Math.min(currentIndex, accounts.length - 1));
-        const currentAccount = accounts[clampedIndex];
-
-        if (this.isAccountUsable(currentAccount, modelId)) {
-            currentAccount.lastUsed = Date.now();
-            if (onSave) onSave();
-            logger.debug(`StickyStrategy: Using sticky account at index ${clampedIndex}`);
-            return { account: currentAccount, index: clampedIndex, waitMs: 0 };
-        }
-
-        // Try to find another usable account
-        const usableAccounts = this.getUsableAccounts(accounts, modelId);
-        
-        if (usableAccounts.length > 0) {
-            const nextResult = this.#pickNext(accounts, clampedIndex, modelId, onSave);
-            if (nextResult) {
-                this.currentIndex = nextResult.index;
-                return nextResult;
-            }
-        }
-
-        // Check if we should wait for the current account
-        const { shouldWait, waitMs } = this.#shouldWaitForAccount(currentAccount, modelId);
-        if (shouldWait && waitMs <= MAX_WAIT_BEFORE_ERROR_MS) {
-            logger.debug(`StickyStrategy: Waiting ${waitMs}ms for sticky account`);
-            return { account: null, index: clampedIndex, waitMs };
-        }
-
-        // No usable accounts, return null
-        return { account: null, index: clampedIndex, waitMs: 0 };
-    }
-
-    #shouldWaitForAccount(account, modelId) {
-        if (!account) {
-            return { shouldWait: false, waitMs: 0 };
-        }
-
-        if (account.isInvalid) {
-            return { shouldWait: false, waitMs: 0 };
-        }
-
-        if (account.enabled === false) {
-            return { shouldWait: false, waitMs: 0 };
-        }
-
-        // Check model-specific rate limit
-        if (modelId && account.modelRateLimits && account.modelRateLimits[modelId]) {
-            const limit = account.modelRateLimits[modelId];
-            if (limit.isRateLimited && limit.resetTime > Date.now()) {
-                const waitMs = limit.resetTime - Date.now();
-                if (waitMs <= MAX_WAIT_BEFORE_ERROR_MS) {
-                    return { shouldWait: true, waitMs };
-                }
-            }
-        }
-
-        return { shouldWait: false, waitMs: 0 };
-    }
-
-    #pickNext(accounts, currentIndex, modelId, onSave) {
-        const startIndex = (currentIndex + 1) % accounts.length;
-        
-        for (let i = 0; i < accounts.length; i++) {
-            const checkIndex = (startIndex + i) % accounts.length;
-            const account = accounts[checkIndex];
-            
-            if (checkIndex === currentIndex) continue;
-            
-            if (this.isAccountUsable(account, modelId)) {
-                account.lastUsed = Date.now();
-                if (onSave) onSave();
-                logger.debug(`StickyStrategy: Switched to account at index ${checkIndex}`);
-                return { account, index: checkIndex, waitMs: 0 };
-            }
-        }
-
-        return null;
-    }
-}