@kikkimo/claude-launcher 2.5.0 → 3.1.0

package/lib/launcher.js

@@ -7,11 +7,111 @@ const colors = require('./ui/colors');
 const i18n = require('./i18n');
 const { getProvider } = require('./presets/providers');
 const stdinManager = require('./utils/stdin-manager');
+const { loadConfigSync } = require('./utils/version-checker');
+
+// Module-level flag for console handoff state
+let consoleRelinquished = false;
+
+/**
+ * Detach stdin and suspend stdinManager so the child process owns the terminal
+ */
+function relinquishConsoleToChild() {
+    if (consoleRelinquished) return;
+    consoleRelinquished = true;
+    try {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+    } catch (_) {}
+
+    // Detach only current scope listeners to avoid affecting other modules
+    if (stdinManager.activeScope && typeof stdinManager.activeScope.detach === 'function') {
+        stdinManager.activeScope.detach();
+    }
+
+    // Suspend stdin manager so no new listeners are attached while Claude is running
+    if (typeof stdinManager.suspend === 'function') {
+        stdinManager.suspend();
+    }
+}
+
+/**
+ * Restore stdinManager after child process exits
+ */
+function restoreConsoleForLauncher() {
+    if (!consoleRelinquished) return;
+    consoleRelinquished = false;
+    if (typeof stdinManager.resume === 'function') {
+        stdinManager.resume();
+    }
+    stdinManager.enableCtrlC();
+}
+
+/**
+ * Handle launch failures with optional rollback and user prompt
+ */
+function handleLaunchFailure(message, opts = {}) {
+    if (opts.afterHandover) {
+        restoreConsoleForLauncher();
+    } else {
+        stdinManager.enableCtrlC();
+    }
+
+    // Rollback launch statistics if callback provided — pass error message for lastError
+    if (typeof opts.rollbackFn === 'function') {
+        try { opts.rollbackFn(message); } catch (_) {}
+    }
+
+    console.log(colors.red + '[x] ' + message + colors.reset);
+    console.log(colors.gray + i18n.tSync('ui.general.press_key_return_menu') + colors.reset);
+
+    if (process.stdin.isTTY) {
+        try {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+        } catch (_) {
+            // Ignore setup failures
+        }
+
+        // Set timeout to prevent infinite hanging
+        const timeoutId = setTimeout(() => {
+            try {
+                process.stdin.setRawMode(false);
+            } catch (_) {
+                // Ignore cleanup failures
+            }
+            process.exit(1);
+        }, 60000); // 60 second timeout
+
+        process.stdin.once('data', () => {
+            clearTimeout(timeoutId);
+            try {
+                process.stdin.setRawMode(false);
+            } catch (_) {
+                // Ignore cleanup failures
+            }
+            // Exit after user acknowledges the error
+            process.exit(1);
+        });
+    } else {
+        // For non-TTY environments, exit immediately
+        process.exit(1);
+    }
+}
 
 /**
  * Launch Claude Code with specified environment variables
  */
-function launchClaude(command, envVars = {}, disableAuthTokens = false) {
+function launchClaude(command, envVars = {}, disableAuthTokens = false, opts = {}) {
+    // Inject telemetry control from config
+    const launcherConfig = loadConfigSync();
+    if (launcherConfig.disableTelemetry) {
+        envVars.DISABLE_TELEMETRY = '1';
+    }
+    if (launcherConfig.noFlicker) {
+        envVars.CLAUDE_CODE_NO_FLICKER = '1';
+    }
+
     // Disable Ctrl+C monitoring before launching Claude Code
     // This allows Ctrl+C to be handled exclusively by Claude Code process
     stdinManager.disableCtrlC();
@@ -40,90 +140,14 @@ function launchClaude(command, envVars = {}, disableAuthTokens = false) {
 
     // Disable conflicting auth tokens when using third-party API
     if (disableAuthTokens) {
-        // Only delete CLAUDE_CODE_OAUTH_TOKEN - keep ANTHROPIC_AUTH_TOKEN that we just set
         delete env.CLAUDE_CODE_OAUTH_TOKEN;
-        console.log(colors.gray + '  Disabled: CLAUDE_CODE_OAUTH_TOKEN' + colors.reset);
+        delete env.ANTHROPIC_API_KEY;
     }
 
     // Parse command and arguments
     const args = command.split(' ');
     const cmd = args.shift();
 
-    let consoleRelinquished = false;
-    const relinquishConsoleToChild = () => {
-        if (consoleRelinquished) return;
-        consoleRelinquished = true;
-        // Do the minimal changes: switch to cooked mode and detach current scope, but do not pause stdin nor swallow signals
-        try {
-            if (process.stdin.isTTY) {
-                process.stdin.setRawMode(false);
-            }
-        } catch (_) {}
-
-        // Detach only current scope listeners to avoid affecting other modules
-        if (stdinManager.activeScope && typeof stdinManager.activeScope.detach === 'function') {
-            stdinManager.activeScope.detach();
-        }
-
-        // Suspend stdin manager so no new listeners are attached while Claude is running
-        if (typeof stdinManager.suspend === 'function') {
-            stdinManager.suspend();
-        }
-    };
-
-    const restoreConsoleForLauncher = () => {
-        if (!consoleRelinquished) return;
-        consoleRelinquished = false;
-        if (typeof stdinManager.resume === 'function') {
-            stdinManager.resume();
-        }
-        stdinManager.enableCtrlC();
-    };
-
-    const handleLaunchFailure = (message, opts = {}) => {
-        if (opts.afterHandover) {
-            restoreConsoleForLauncher();
-        } else {
-            stdinManager.enableCtrlC();
-        }
-
-        console.log(colors.red + '[x] ' + message + colors.reset);
-        console.log(colors.gray + i18n.tSync('ui.general.press_key_return_menu') + colors.reset);
-
-        if (process.stdin.isTTY) {
-            try {
-                process.stdin.setRawMode(true);
-                process.stdin.resume();
-            } catch (_) {
-                // Ignore setup failures
-            }
-
-            // Set timeout to prevent infinite hanging
-            const timeoutId = setTimeout(() => {
-                try {
-                    process.stdin.setRawMode(false);
-                } catch (_) {
-                    // Ignore cleanup failures
-                }
-                process.exit(1);
-            }, 60000); // 60 second timeout
-
-            process.stdin.once('data', () => {
-                clearTimeout(timeoutId);
-                try {
-                    process.stdin.setRawMode(false);
-                } catch (_) {
-                    // Ignore cleanup failures
-                }
-                // Exit after user acknowledges the error
-                process.exit(1);
-            });
-        } else {
-            // For non-TTY environments, exit immediately
-            process.exit(1);
-        }
-    };
-
     try {
         // Clean up terminal state before launching Claude
         if (process.stdin.isTTY) {
@@ -135,15 +159,8 @@ function launchClaude(command, envVars = {}, disableAuthTokens = false) {
             }
         }
 
-        // Note: stdin listener management is handled by relinquishConsoleToChild()
-        // using stdinManager.activeScope.detach() and stdinManager.suspend().
-        // This ensures only the current scope's listeners are detached while
-        // preserving any listeners from other modules.
-        //
-        // Note: Do NOT remove global SIGINT/SIGTERM handlers here.
-        // The existing handlers already check stdinManager.isSuspended() and
-        // will properly ignore signals during child process execution.
-        // Removing all handlers would break other modules and degrade reliability.
+        // Relinquish console before spawn so the child inherits a clean terminal
+        relinquishConsoleToChild();
 
         // Launch Claude in current terminal, inherit stdio
         const child = spawn(cmd, args, {
@@ -153,19 +170,22 @@ function launchClaude(command, envVars = {}, disableAuthTokens = false) {
             shell: true
         });
 
-        relinquishConsoleToChild();
-
         child.on('close', (code) => {
             restoreConsoleForLauncher();
             process.exit(code || 0);
         });
 
         child.on('error', (error) => {
-            handleLaunchFailure('Error running Claude: ' + error.message, { afterHandover: true });
+            handleLaunchFailure('Error running Claude: ' + error.message, {
+                afterHandover: true,
+                rollbackFn: opts.rollbackFn
+            });
         });
 
     } catch (error) {
-        handleLaunchFailure('Error launching Claude Code: ' + error.message);
+        handleLaunchFailure('Error launching Claude Code: ' + error.message, {
+            rollbackFn: opts.rollbackFn
+        });
     }
 }
 
@@ -196,47 +216,83 @@ function launchClaudeAutoMode() {
  * Get environment variables based on provider type
  */
 function getProviderEnvVars(api) {
-    // Decrypt the auth token (all tokens are stored encrypted)
     const { decrypt } = require('./crypto');
     const decrypted = decrypt(api.authToken);
-
     if (!decrypted.success) {
-        console.error('Failed to decrypt auth token:', decrypted.error);
         throw new Error('Failed to decrypt API auth token. Please check your configuration.');
     }
 
     const authToken = decrypted.value;
 
-    const baseEnvVars = {
+    // Step 1: Base variables
+    const env = {
         ANTHROPIC_BASE_URL: api.baseUrl,
         ANTHROPIC_AUTH_TOKEN: authToken,
         ANTHROPIC_MODEL: api.model,
-        ANTHROPIC_SMALL_FAST_MODEL: api.smallFastModel || api.model
+        ANTHROPIC_SMALL_FAST_MODEL: api.smallFastModel || api.model,
     };
 
-    // Get provider configuration and merge provider-specific environment variables
+    // Step 2: Provider-level defaults
     const providerConfig = getProvider(api.provider);
-
     if (providerConfig && providerConfig.envVars) {
-        // Merge base env vars with provider-specific env vars
-        return {
-            ...baseEnvVars,
-            ...providerConfig.envVars
-        };
+        Object.assign(env, providerConfig.envVars);
+    }
+
+    const { PREDEFINED_MODEL_ENV_KEYS, PREDEFINED_RUNTIME_KEYS, TYPE_A_FIELDS, RESERVED_ENV_KEYS } = require('./validators');
+
+    // Step 3: modelEnvVars (whitelist, non-empty)
+    if (api.modelEnvVars) {
+        for (const key of PREDEFINED_MODEL_ENV_KEYS) {
+            const val = api.modelEnvVars[key];
+            if (val !== undefined && val !== '') env[key] = val;
+        }
     }
 
-    return baseEnvVars;
+    // Step 4: runtimeEnvVars (whitelist, non-empty, skip "off")
+    if (api.runtimeEnvVars) {
+        for (const key of PREDEFINED_RUNTIME_KEYS) {
+            const val = api.runtimeEnvVars[key];
+            if (val !== undefined && val !== '' && val !== 'off') env[key] = val;
+        }
+    }
+
+    // Step 5: customEnvVars (skip reserved/predefined)
+    if (api.customEnvVars) {
+        const allPredefined = new Set([...RESERVED_ENV_KEYS, ...PREDEFINED_RUNTIME_KEYS, ...PREDEFINED_MODEL_ENV_KEYS]);
+        for (const [key, val] of Object.entries(api.customEnvVars)) {
+            if (allPredefined.has(key)) continue;
+            if (val !== undefined && val !== '') env[key] = val;
+        }
+    }
+
+    // Step 6: Remove Type A fields with "off" (tombstone)
+    if (api.runtimeEnvVars) {
+        for (const key of TYPE_A_FIELDS) {
+            if (api.runtimeEnvVars[key] === 'off') delete env[key];
+        }
+    }
+
+    return env;
 }
 
 /**
  * Launch Claude with third-party API configuration
  */
-function launchClaudeWithApi(api, skipPermissions = false) {
+function launchClaudeWithApi(api, skipPermissions = false, opts = {}) {
     const command = skipPermissions
         ? 'claude --dangerously-skip-permissions'
         : 'claude';
 
-    const envVars = getProviderEnvVars(api);
+    let envVars;
+    try {
+        envVars = getProviderEnvVars(api);
+    } catch (error) {
+        handleLaunchFailure('Failed to prepare API environment: ' + error.message, {
+            afterHandover: true,
+            rollbackFn: opts.rollbackFn
+        });
+        return;
+    }
 
     console.log('');
     console.log(colors.bright + colors.orange + '🔗 ' + i18n.tSync('launch.using_third_party_api') + colors.reset);
@@ -254,8 +310,8 @@ function launchClaudeWithApi(api, skipPermissions = false) {
     if (providerConfig && providerConfig.envVars && Object.keys(providerConfig.envVars).length > 0) {
         console.log(colors.yellow + '  ⚡ ' + i18n.tSync('launch.provider_optimizations_applied') + colors.reset);
 
-        // Display specific optimizations based on envVars
-        const msRaw = providerConfig.envVars.API_TIMEOUT_MS;
+        // Display specific optimizations from merged envVars
+        const msRaw = envVars.API_TIMEOUT_MS;
         const ms = Number(msRaw);
         if (Number.isFinite(ms) && ms > 0) {
             const timeoutSec = Math.floor(ms / 1000);
@@ -281,7 +337,7 @@ function launchClaudeWithApi(api, skipPermissions = false) {
 
     console.log('');
 
-    launchClaude(command, envVars, true);
+    launchClaude(command, envVars, true, { rollbackFn: opts.rollbackFn });
 }
 
 /**
@@ -365,5 +421,6 @@ module.exports = {
     launchClaudeAutoMode,
     launchClaudeWithApi,
     getProviderEnvVars,
-    testApiConnection
+    testApiConnection,
+    handleLaunchFailure
 };

package/lib/presets/providers.js

@@ -4,50 +4,106 @@
  * Note: Only includes APIs that are compatible with Claude Code's Anthropic API format
  */
 
+// Template factory: same-gen fast model downgrade via lookup map
+function makeFastMapTemplate(fastMap) {
+    return {
+        getValues(model) {
+            const fastModel = fastMap[model] || model;
+            return {
+                ANTHROPIC_CUSTOM_MODEL_OPTION: model,
+                ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: model,
+                ANTHROPIC_DEFAULT_SONNET_MODEL: model,
+                ANTHROPIC_DEFAULT_OPUS_MODEL: model,
+                ANTHROPIC_DEFAULT_HAIKU_MODEL: fastModel,
+                CLAUDE_CODE_SUBAGENT_MODEL: fastModel,
+                smallFastModel: fastModel,
+            };
+        },
+    };
+}
+
+// Template factory: for providers with single model, no tier split
+function makeSingleTemplate() {
+    return {
+        getValues(model) {
+            return {
+                ANTHROPIC_CUSTOM_MODEL_OPTION: model,
+                ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: model,
+                ANTHROPIC_DEFAULT_SONNET_MODEL: model,
+                ANTHROPIC_DEFAULT_OPUS_MODEL: model,
+                ANTHROPIC_DEFAULT_HAIKU_MODEL: model,
+                CLAUDE_CODE_SUBAGENT_MODEL: model,
+                smallFastModel: model,
+            };
+        },
+    };
+}
+
+// Anthropic models — defined as const so the template factory can reference them
+const anthropicModels = [
+    'claude-opus-4-7',
+    'claude-sonnet-4-6',
+    'claude-haiku-4-5-20251001',
+    'claude-sonnet-4-5',
+    'claude-opus-4-6',
+    'claude-opus-4-5',
+];
+
 const providers = {
     anthropic: {
         name: 'Anthropic (Official)',
         baseUrl: 'https://api.anthropic.com',
-        models: [
-            'claude-3-5-haiku-20241022',
-            'claude-3-7-sonnet',
-            'claude-sonnet-4',
-            'claude-sonnet-4-5',
-            'claude-opus-4',
-            'claude-opus-4-1',
-            'claude-opus-4-5',
-            'claude-opus-4-6'
-        ],
-        // Version aliases for upgrade detection (manually maintained)
-        // Covers ALL models in each series for comprehensive upgrade detection
+        models: anthropicModels,
         versionAliases: {
-            // Opus series -> latest opus
-            'claude-opus-4': 'claude-opus-4-6',
-            'claude-opus-4-1': 'claude-opus-4-6',
-            'claude-opus-4-5': 'claude-opus-4-6',
-            // Sonnet series -> latest sonnet
-            'claude-sonnet-4': 'claude-sonnet-4-5',
-            'claude-3-7-sonnet': 'claude-sonnet-4-5'
+            'claude-opus-4': 'claude-opus-4-7',
+            'claude-opus-4-1': 'claude-opus-4-7',
+            'claude-opus-4-5': 'claude-opus-4-7',
+            'claude-opus-4-6': 'claude-opus-4-7',
+            'claude-sonnet-4': 'claude-sonnet-4-6',
+            'claude-sonnet-4-5': 'claude-sonnet-4-6',
+            'claude-3-7-sonnet': 'claude-sonnet-4-6',
         },
         authTokenFormat: 'sk-ant-api03-...',
         description: 'Official Anthropic API - Fully compatible',
         requiresToken: true,
-        compatibility: 'native'
+        compatibility: 'native',
+        envVars: {
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+        },
+        modelEnvTemplate: {
+            getValues(model) {
+                const latestSonnet = anthropicModels.find(m => m.includes('sonnet')) || model;
+                const latestOpus = anthropicModels.find(m => m.includes('opus')) || model;
+                const latestHaiku = anthropicModels.find(m => m.includes('haiku')) || model;
+                return {
+                    ANTHROPIC_CUSTOM_MODEL_OPTION: model,
+                    ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: model,
+                    ANTHROPIC_DEFAULT_SONNET_MODEL: latestSonnet,
+                    ANTHROPIC_DEFAULT_OPUS_MODEL: latestOpus,
+                    ANTHROPIC_DEFAULT_HAIKU_MODEL: latestHaiku,
+                    CLAUDE_CODE_SUBAGENT_MODEL: latestHaiku,
+                    smallFastModel: latestHaiku,
+                };
+            },
+        },
     },
     moonshot: {
-        name: 'Moonshot AI (Kimi-K2.5/K2-Thinking)',
+        name: 'Moonshot AI (Kimi-K2.6/K2.5/K2-Thinking)',
         baseUrl: 'https://api.moonshot.cn/anthropic',
         models: [
+            'kimi-k2.6',
             'kimi-k2.5',
             'kimi-k2-thinking',
-            'kimi-k2-thinking-turbo'
+            'kimi-k2-thinking-turbo',
         ],
         versionAliases: {
-            'kimi-k2-0711-preview': 'kimi-k2.5',
-            'kimi-k2-0905-preview': 'kimi-k2.5',
-            'kimi-k2-turbo-preview': 'kimi-k2.5',
-            'kimi-k2-thinking': 'kimi-k2.5',
-            'kimi-k2-thinking-turbo': 'kimi-k2.5'
+            'kimi-k2-0711-preview': 'kimi-k2.6',
+            'kimi-k2-0905-preview': 'kimi-k2.6',
+            'kimi-k2-turbo-preview': 'kimi-k2.6',
+            'kimi-k2-thinking': 'kimi-k2.6',
+            'kimi-k2-thinking-turbo': 'kimi-k2.6',
+            'kimi-k2.5': 'kimi-k2.6',
         },
         authTokenFormat: 'sk-...',
         description: 'Moonshot AI - Provides Anthropic-compatible API',
@@ -55,8 +111,12 @@ const providers = {
         compatibility: 'anthropic-compatible',
         envVars: {
             API_TIMEOUT_MS: '3000000',
-            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+            CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: '1'
         },
+                modelEnvTemplate: makeFastMapTemplate({"kimi-k2.6":"kimi-k2-thinking-turbo","kimi-k2-thinking":"kimi-k2-thinking-turbo"}),
         note: 'Requires extended timeout for large responses'
     },
     kimi_for_coding: {
@@ -71,8 +131,12 @@ const providers = {
         compatibility: 'anthropic-compatible',
         envVars: {
             API_TIMEOUT_MS: '3000000',
-            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+            CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: '1'
         },
+                modelEnvTemplate: makeSingleTemplate(),
         note: 'Requires extended timeout for large responses'
     },
     minimax_cn: {
@@ -80,8 +144,12 @@ const providers = {
         baseUrl: 'https://api.minimaxi.com/anthropic',
         models: [
             'MiniMax-M2.7',
+            'MiniMax-M2.7-highspeed',
             'MiniMax-M2.5',
-            'MiniMax-M2.1'
+            'MiniMax-M2.5-highspeed',
+            'MiniMax-M2.1',
+            'MiniMax-M2.1-highspeed',
+            'MiniMax-M2',
         ],
         versionAliases: {
             'MiniMax-M2.1': 'MiniMax-M2.7',
@@ -93,8 +161,12 @@ const providers = {
         compatibility: 'anthropic-compatible',
         envVars: {
             API_TIMEOUT_MS: '3000000',
-            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+            CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: '1'
         },
+                modelEnvTemplate: makeFastMapTemplate({"MiniMax-M2.7":"MiniMax-M2.7-highspeed","MiniMax-M2.5":"MiniMax-M2.5-highspeed","MiniMax-M2.1":"MiniMax-M2.1-highspeed"}),
         note: 'Requires extended timeout for large responses'
     },
     minimax_global: {
@@ -102,8 +174,12 @@ const providers = {
         baseUrl: 'https://api.minimax.io/anthropic',
         models: [
             'MiniMax-M2.7',
+            'MiniMax-M2.7-highspeed',
             'MiniMax-M2.5',
-            'MiniMax-M2.1'
+            'MiniMax-M2.5-highspeed',
+            'MiniMax-M2.1',
+            'MiniMax-M2.1-highspeed',
+            'MiniMax-M2',
         ],
         versionAliases: {
             'MiniMax-M2.1': 'MiniMax-M2.7',
@@ -115,26 +191,41 @@ const providers = {
         compatibility: 'anthropic-compatible',
         envVars: {
             API_TIMEOUT_MS: '3000000',
-            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+            CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: '1'
         },
+                modelEnvTemplate: makeFastMapTemplate({"MiniMax-M2.7":"MiniMax-M2.7-highspeed","MiniMax-M2.5":"MiniMax-M2.5-highspeed","MiniMax-M2.1":"MiniMax-M2.1-highspeed"}),
         note: 'Requires extended timeout for large responses'
     },
     deepseek: {
-        name: 'DeepSeek (DeepSeek V3/V3.1)',
+        name: 'DeepSeek (V4-Pro/V4-Flash)',
         baseUrl: 'https://api.deepseek.com/anthropic',
         models: [
+            'deepseek-v4-pro[1m]',
+            'deepseek-v4-flash[1m]',
             'deepseek-chat',
-            'deepseek-reasoner'
+            'deepseek-reasoner',
         ],
+        versionAliases: {
+            'deepseek-chat': 'deepseek-v4-flash[1m]',
+            'deepseek-reasoner': 'deepseek-v4-pro[1m]',
+        },
         authTokenFormat: 'sk-...',
         description: 'DeepSeek AI - Anthropic-compatible endpoint',
         requiresToken: true,
         compatibility: 'anthropic-compatible',
         envVars: {
             API_TIMEOUT_MS: '600000',
-            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+            CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: '1',
+            CLAUDE_CODE_EFFORT_LEVEL: 'max',
         },
-        note: 'Requires extended timeout for complex reasoning tasks'
+        modelEnvTemplate: makeFastMapTemplate({"deepseek-v4-pro[1m]":"deepseek-v4-flash[1m]"}),
+        note: 'Requires extended timeout for complex reasoning tasks',
     },
     zhipu: {
         name: 'ZhiPu AI (GLM-5.1/5-Turbo/5/4.7) - 智谱清言',
@@ -158,8 +249,12 @@ const providers = {
         compatibility: 'anthropic-compatible',
         envVars: {
             API_TIMEOUT_MS: '3000000',
-            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+            CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: '1'
         },
+                modelEnvTemplate: makeFastMapTemplate({"glm-5.1":"glm-5-turbo"}),
         note: 'Requires extended timeout for large responses'
     },
     zai: {
@@ -184,8 +279,12 @@ const providers = {
         compatibility: 'anthropic-compatible',
         envVars: {
             API_TIMEOUT_MS: '3000000',
-            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1'
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+            CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK: '1'
         },
+                modelEnvTemplate: makeFastMapTemplate({"glm-5.1":"glm-5-turbo"}),
         note: 'Requires extended timeout for large responses'
     },
     custom: {
@@ -198,6 +297,11 @@ const providers = {
         description: 'Custom server with Anthropic-compatible API',
         requiresToken: true,
         compatibility: 'anthropic-compatible',
+        envVars: {
+            CLAUDE_CODE_ATTRIBUTION_HEADER: '0',
+            CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: '1',
+        },
+        modelEnvTemplate: makeSingleTemplate(),
         note: 'Replace URL and model with your actual server details'
     }
 };