@pikoloo/codex-proxy 1.0.6 → 1.0.7

package/public/js/app.js

@@ -1,5 +1,5 @@
 document.addEventListener('alpine:init', () => {
-    const validTabs = ['dashboard', 'accounts', 'logs', 'settings'];
+    const validTabs = ['dashboard', 'metrics', 'accounts', 'logs', 'settings'];
     const initialTab = () => {
         const params = new URLSearchParams(window.location.search);
         const requested = params.get('tab') || window.location.hash.replace(/^#/, '');
@@ -7,7 +7,7 @@ document.addEventListener('alpine:init', () => {
     };
 
     Alpine.data('app', () => ({
-        version: '1.0.5',
+        version: '1.0.7',
         connectionStatus: 'connecting',
         activeTab: initialTab(),
         sidebarOpen: window.innerWidth >= 1024,
@@ -18,12 +18,44 @@ document.addEventListener('alpine:init', () => {
         accounts: [],
         searchQuery: '',
         stats: { total: 0, active: 0, expired: 0, planType: '-' },
+        metricsRange: '24h',
+        metricsStatusFilter: '',
+        metricsLoading: false,
+        metricsError: '',
+        metricsSummary: {
+            totals: {
+                requestCount: 0,
+                successCount: 0,
+                errorCount: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadInputTokens: 0,
+                totalTokens: 0,
+                averageDurationMs: 0
+            },
+            byModel: [],
+            byAccount: [],
+            timeline: []
+        },
+        metricsRecent: [],
+        metricsStorage: null,
 
         haikuKiloModel: 'minimax/minimax-m2.5:free',
+        modelMappings: { opus: 'gpt-5.5', sonnet: 'gpt-5.5', haiku: 'gpt-5.4-mini' },
+        modelMappingDefaults: { opus: 'gpt-5.5', sonnet: 'gpt-5.5', haiku: 'gpt-5.4-mini' },
+        reasoningMappings: { opus: 'high', sonnet: 'medium', haiku: 'low' },
+        reasoningMappingDefaults: { opus: 'high', sonnet: 'medium', haiku: 'low' },
+        openAiModelOptions: [],
+        reasoningLevelOptions: [],
+        modelMappingSaving: null,
+        reasoningMappingSaving: null,
         accountStrategy: 'sticky',
         multiAccountRotationEnabled: false,
         haikuModelSaving: false,
         strategySaving: false,
+        configureClaudeOnStartup: false,
+        claudeProxyConfiguring: false,
+        claudeProxyStartupSaving: false,
         kiloEnabled: false,
         kiloModels: [],
         kiloModelsLoading: false,
@@ -48,9 +80,7 @@ document.addEventListener('alpine:init', () => {
         haikuTesting: false,
 
         haikuModelLabel() {
-            if (!this.kiloEnabled) return 'gpt-5.4-mini';
-            const model = this.kiloModels.find(m => m.id === this.haikuKiloModel);
-            return model ? model.name : this.haikuKiloModel;
+            return this.modelOptionName(this.modelMappings?.haiku || 'gpt-5.4-mini');
         },
 
         async testHaikuChat() {
@@ -73,6 +103,7 @@ document.addEventListener('alpine:init', () => {
         },
         
         configPath: '~/.codex-claude-proxy/accounts.json',
+        serverUrl: window.location.origin,
         
         logs: [],
         logSearchQuery: '',
@@ -94,6 +125,31 @@ document.addEventListener('alpine:init', () => {
             return this.accounts.filter(a => a.email.toLowerCase().includes(q));
         },
 
+        get metricsTotals() {
+            return this.metricsSummary?.totals || {
+                requestCount: 0,
+                successCount: 0,
+                errorCount: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cacheReadInputTokens: 0,
+                totalTokens: 0,
+                averageDurationMs: 0
+            };
+        },
+
+        get metricsTimelineMax() {
+            return Math.max(1, ...this.metricsSummary.timeline.map((entry) => Number(entry.totalTokens) || 0));
+        },
+
+        get metricsModelMax() {
+            return Math.max(1, ...this.metricsSummary.byModel.map((entry) => Number(entry.totalTokens) || 0));
+        },
+
+        get metricsAccountMax() {
+            return Math.max(1, ...this.metricsSummary.byAccount.map((entry) => Number(entry.totalTokens) || 0));
+        },
+
         init() {
             this.updateTime();
             setInterval(() => this.updateTime(), 1000);
@@ -101,8 +157,11 @@ document.addEventListener('alpine:init', () => {
             this.checkHealth();
             setInterval(() => this.checkHealth(), 30000);
             this.startLogStream();
+            this.loadModelMappingsSetting();
             this.loadHaikuModelSetting();
             this.loadAccountStrategySetting();
+            this.loadClaudeProxySetting();
+            this.loadMetrics();
 
             window.addEventListener('resize', () => {
                 this.sidebarOpen = window.innerWidth >= 1024;
@@ -124,6 +183,9 @@ document.addEventListener('alpine:init', () => {
         setActiveTab(tab) {
             if (!validTabs.includes(tab)) return;
             this.activeTab = tab;
+            if (tab === 'metrics') {
+                this.loadMetrics();
+            }
             const nextUrl = new URL(window.location.href);
             if (tab === 'dashboard') {
                 nextUrl.searchParams.delete('tab');
@@ -174,6 +236,96 @@ document.addEventListener('alpine:init', () => {
             this.loading = false;
         },
 
+        refreshCurrentView() {
+            if (this.activeTab === 'metrics') {
+                return this.loadMetrics();
+            }
+            return this.refreshAccounts();
+        },
+
+        async loadMetrics() {
+            this.metricsLoading = true;
+            this.metricsError = '';
+            const params = new URLSearchParams({ range: this.metricsRange });
+            if (this.metricsStatusFilter) {
+                params.set('status', this.metricsStatusFilter);
+            }
+
+            const [summary, recent, storage] = await Promise.all([
+                this.api(`/api/metrics/summary?${params.toString()}`),
+                this.api(`/api/metrics/recent?${params.toString()}&limit=50`),
+                this.api('/api/metrics/storage')
+            ]);
+
+            if (summary.ok && summary.data?.summary) {
+                this.metricsSummary = summary.data.summary;
+            } else {
+                this.metricsError = summary.data?.error || summary.error || 'Failed to load metrics';
+            }
+
+            if (recent.ok && Array.isArray(recent.data?.events)) {
+                this.metricsRecent = recent.data.events;
+            }
+
+            if (storage.ok && storage.data?.storage) {
+                this.metricsStorage = storage.data.storage;
+            }
+
+            this.metricsLoading = false;
+        },
+
+        setMetricsRange(range) {
+            if (this.metricsRange === range) return;
+            this.metricsRange = range;
+            this.loadMetrics();
+        },
+
+        setMetricsStatusFilter(status) {
+            if (this.metricsStatusFilter === status) return;
+            this.metricsStatusFilter = status;
+            this.loadMetrics();
+        },
+
+        metricBarWidth(value, maxValue) {
+            const valueNumber = Number(value) || 0;
+            const maxNumber = Number(maxValue) || 1;
+            return Math.max(2, Math.min(100, Math.round((valueNumber / maxNumber) * 100)));
+        },
+
+        formatTokenCount(value) {
+            const number = Number(value) || 0;
+            if (number >= 1000000) return `${(number / 1000000).toFixed(1)}M`;
+            if (number >= 1000) return `${(number / 1000).toFixed(1)}K`;
+            return String(number);
+        },
+
+        formatDuration(value) {
+            const number = Number(value) || 0;
+            if (number >= 1000) return `${(number / 1000).toFixed(1)}s`;
+            return `${number}ms`;
+        },
+
+        formatBytes(value) {
+            const number = Number(value) || 0;
+            if (number >= 1024 * 1024) return `${(number / (1024 * 1024)).toFixed(1)} MB`;
+            if (number >= 1024) return `${(number / 1024).toFixed(1)} KB`;
+            return `${number} B`;
+        },
+
+        formatMetricTime(value) {
+            if (!value) return '-';
+            const date = new Date(value);
+            if (Number.isNaN(date.getTime())) return '-';
+            return date.toLocaleString([], { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });
+        },
+
+        metricsStatusClass(status) {
+            const code = Number(status) || 0;
+            if (code >= 200 && code < 400) return 'metrics-status-success';
+            if (code >= 400) return 'metrics-status-error';
+            return 'metrics-status-muted';
+        },
+
         async refreshAllQuotaData() {
             if (!this.accounts.length) return;
             const { ok, data } = await this.api('/accounts/quota/all');
@@ -493,6 +645,86 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
+        modelOptionName(modelId) {
+            const option = this.openAiModelOptions.find((model) => model.id === modelId);
+            return option ? option.name : modelId;
+        },
+
+        modelMappingLabel(alias) {
+            const labels = { opus: 'Opus', sonnet: 'Sonnet', haiku: 'Haiku' };
+            return labels[alias] || alias;
+        },
+
+        async loadModelMappingsSetting() {
+            const { ok, data } = await this.api('/settings/model-mappings');
+            if (!ok || !data?.modelMappings) return;
+
+            this.modelMappings = data.modelMappings;
+            this.modelMappingDefaults = data.defaults || this.modelMappingDefaults;
+            this.reasoningMappings = data.reasoningMappings || this.reasoningMappings;
+            this.reasoningMappingDefaults = data.reasoningDefaults || this.reasoningMappingDefaults;
+            this.openAiModelOptions = Array.isArray(data.models) ? data.models : [];
+            this.reasoningLevelOptions = Array.isArray(data.reasoningLevels) ? data.reasoningLevels : [];
+        },
+
+        async setModelMapping(alias, model) {
+            if (this.modelMappingSaving || !alias || !model) return;
+
+            const previous = this.modelMappings[alias];
+            if (previous === model) return;
+
+            this.modelMappings = { ...this.modelMappings, [alias]: model };
+            this.modelMappingSaving = alias;
+            const { ok, data } = await this.api('/settings/model-mappings', {
+                method: 'POST',
+                body: JSON.stringify({ modelMappings: { [alias]: model } })
+            });
+            this.modelMappingSaving = null;
+
+            if (ok && data?.modelMappings) {
+                this.modelMappings = data.modelMappings;
+                this.modelMappingDefaults = data.defaults || this.modelMappingDefaults;
+                this.reasoningMappings = data.reasoningMappings || this.reasoningMappings;
+                this.reasoningMappingDefaults = data.reasoningDefaults || this.reasoningMappingDefaults;
+                this.openAiModelOptions = Array.isArray(data.models) ? data.models : this.openAiModelOptions;
+                this.reasoningLevelOptions = Array.isArray(data.reasoningLevels) ? data.reasoningLevels : this.reasoningLevelOptions;
+                this.showToast(`${this.modelMappingLabel(alias)} now maps to ${this.modelOptionName(data.modelMappings[alias])}`, 'success');
+            } else {
+                this.modelMappings = { ...this.modelMappings, [alias]: previous };
+                this.showToast(data?.error || 'Failed to update model mapping', 'error');
+            }
+        },
+
+        reasoningOptionName(reasoningId) {
+            const option = this.reasoningLevelOptions.find((level) => level.id === reasoningId);
+            return option ? option.name : reasoningId;
+        },
+
+        async setReasoningMapping(alias, reasoning) {
+            if (this.reasoningMappingSaving || !alias || !reasoning) return;
+
+            const previous = this.reasoningMappings[alias];
+            if (previous === reasoning) return;
+
+            this.reasoningMappings = { ...this.reasoningMappings, [alias]: reasoning };
+            this.reasoningMappingSaving = alias;
+            const { ok, data } = await this.api('/settings/model-mappings', {
+                method: 'POST',
+                body: JSON.stringify({ reasoningMappings: { [alias]: reasoning } })
+            });
+            this.reasoningMappingSaving = null;
+
+            if (ok && data?.reasoningMappings) {
+                this.reasoningMappings = data.reasoningMappings;
+                this.reasoningMappingDefaults = data.reasoningDefaults || this.reasoningMappingDefaults;
+                this.reasoningLevelOptions = Array.isArray(data.reasoningLevels) ? data.reasoningLevels : this.reasoningLevelOptions;
+                this.showToast(`${this.modelMappingLabel(alias)} reasoning set to ${this.reasoningOptionName(data.reasoningMappings[alias])}`, 'success');
+            } else {
+                this.reasoningMappings = { ...this.reasoningMappings, [alias]: previous };
+                this.showToast(data?.error || 'Failed to update reasoning level', 'error');
+            }
+        },
+
         async loadAccountStrategySetting() {
             const { ok, data } = await this.api('/settings/account-strategy');
             if (ok && data?.accountStrategy) {
@@ -518,22 +750,51 @@ document.addEventListener('alpine:init', () => {
             }
         },
 
-        async setClaudeCodeProxyTestConfig() {
-            const { ok, data, error } = await this.api('/claude/config/set', {
-                method: 'POST',
-                body: JSON.stringify({
-                    apiUrl: 'http://localhost:8081',
-                    apiKey: 'test'
-                })
-            });
+        async loadClaudeProxySetting() {
+            const { ok, data } = await this.api('/settings/claude-proxy');
+            if (ok && typeof data?.configureClaudeOnStartup === 'boolean') {
+                this.configureClaudeOnStartup = data.configureClaudeOnStartup;
+            }
+        },
+
+        async configureClaudeProxy() {
+            if (this.claudeProxyConfiguring) return;
+            this.claudeProxyConfiguring = true;
+            const { ok, data, error } = await this.api('/claude/config/proxy', { method: 'POST' });
+            this.claudeProxyConfiguring = false;
 
             if (ok && data?.success) {
-                this.showToast('Updated Claude Code settings.json (API URL + API key).', 'success');
+                this.showToast(data.message || 'Claude Code configured to use this proxy.', 'success');
             } else {
                 this.showToast(data?.error || error || 'Failed to update Claude Code settings.json', 'error');
             }
         },
 
+        async setConfigureClaudeOnStartup(enabled) {
+            if (this.claudeProxyStartupSaving) return;
+            const previous = this.configureClaudeOnStartup;
+            this.configureClaudeOnStartup = enabled;
+            this.claudeProxyStartupSaving = true;
+            const { ok, data, error } = await this.api('/settings/claude-proxy', {
+                method: 'POST',
+                body: JSON.stringify({ configureClaudeOnStartup: enabled })
+            });
+            this.claudeProxyStartupSaving = false;
+
+            if (ok && typeof data?.configureClaudeOnStartup === 'boolean') {
+                this.configureClaudeOnStartup = data.configureClaudeOnStartup;
+                this.showToast(
+                    data.configureClaudeOnStartup
+                        ? 'Claude Code will be configured on proxy startup.'
+                        : 'Startup Claude Code configuration disabled.',
+                    'success'
+                );
+            } else {
+                this.configureClaudeOnStartup = previous;
+                this.showToast(data?.error || error || 'Failed to update startup setting', 'error');
+            }
+        },
+
         showToast(message, type = 'success') {
             this.toast = { message, type };
             setTimeout(() => { this.toast = null; }, 3000);

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.0.7                    ║
 ║                   (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,19 @@ 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,
+  handleGetAccountStrategy,
+  handleSetAccountStrategy,
+  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 +75,12 @@ 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/model-mappings', handleGetModelMappings);
+  app.post('/settings/model-mappings', handleSetModelMappings);
   app.get('/settings/account-strategy', handleGetAccountStrategy);
   app.post('/settings/account-strategy', handleSetAccountStrategy);
+  app.get('/settings/claude-proxy', handleGetClaudeProxySetting);
+  app.post('/settings/claude-proxy', handleSetClaudeProxySetting);
 
   // ─── Account Management ───────────────────────────────────────────────────
   app.get('/accounts', handleListAccounts);
@@ -93,6 +108,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 };