@anh3d0nic/qwen-code-termux-ice 21.1.0 → 21.2.0

package/core-dist/src/models/modelsConfig.js

@@ -0,0 +1,957 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import process from 'node:process';
+import { AuthType } from '../core/contentGenerator.js';
+import { DEFAULT_QWEN_MODEL } from '../config/models.js';
+import { tokenLimit } from '../core/tokenLimits.js';
+import { defaultModalities } from '../core/modalityDefaults.js';
+import { ModelRegistry } from './modelRegistry.js';
+import {} from './types.js';
+import { MODEL_GENERATION_CONFIG_FIELDS, CREDENTIAL_FIELDS, PROVIDER_SOURCED_FIELDS, } from './constants.js';
+export { MODEL_GENERATION_CONFIG_FIELDS, CREDENTIAL_FIELDS, PROVIDER_SOURCED_FIELDS, };
+/**
+ * ModelsConfig manages all model selection logic and state.
+ *
+ * This class encapsulates:
+ * - ModelRegistry for model configuration storage
+ * - Current authType and modelId selection
+ * - Generation config management
+ * - Model switching logic
+ *
+ * Config uses this as a thin entry point for all model-related operations.
+ */
+export class ModelsConfig {
+    modelRegistry;
+    // Current selection state
+    currentAuthType;
+    // Generation config state
+    _generationConfig;
+    generationConfigSources;
+    // Flag for strict model provider selection
+    strictModelProviderSelection = false;
+    // One-shot flag for qwen-oauth credential caching
+    requireCachedQwenCredentialsOnce = false;
+    // One-shot flag indicating credentials were manually set via updateCredentials()
+    // When true, syncAfterAuthRefresh should NOT override these credentials with
+    // modelProviders defaults (even if the model ID matches a registry entry).
+    //
+    // This must be persistent across auth refreshes, because refreshAuth() can be
+    // triggered multiple times after a credential prompt flow. We only clear this
+    // flag when we explicitly apply modelProvider defaults (i.e. when the user
+    // switches to a registry model via switchModel).
+    hasManualCredentials = false;
+    // Callback for notifying Config of model changes
+    onModelChange;
+    // Flag indicating whether authType was explicitly provided (not defaulted)
+    authTypeWasExplicitlyProvided;
+    /**
+     * Runtime model snapshot storage.
+     *
+     * These snapshots store runtime-resolved model configurations that are NOT from
+     * modelProviders registry (e.g., models with manually set credentials).
+     *
+     * Key: snapshotId (format: `$runtime|${authType}|${modelId}`)
+     *   Uses `$runtime|` prefix since `$` and `|` are unlikely to appear in real model IDs.
+     *   This prevents conflicts with model IDs containing `-` or `:` characters.
+     * Value: RuntimeModelSnapshot containing the model's configuration
+     *
+     * Note: This is different from state snapshots used for rollback during model switching.
+     * RuntimeModelSnapshot stores persistent model configurations, while state snapshots
+     * are temporary and used only for error recovery.
+     */
+    runtimeModelSnapshots = new Map();
+    /**
+     * Currently active RuntimeModelSnapshot ID.
+     *
+     * When set, indicates that the current model is a runtime model (not from registry).
+     * This ID is included in state snapshots for rollback purposes.
+     */
+    activeRuntimeModelSnapshotId;
+    static deepClone(value) {
+        if (value === null || typeof value !== 'object') {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => ModelsConfig.deepClone(v));
+        }
+        const out = {};
+        for (const key of Object.keys(value)) {
+            out[key] = ModelsConfig.deepClone(value[key]);
+        }
+        return out;
+    }
+    constructor(options = {}) {
+        this.modelRegistry = new ModelRegistry(options.modelProvidersConfig);
+        this.onModelChange = options.onModelChange;
+        // Initialize generation config
+        // Note: generationConfig.model should already be fully resolved by ModelConfigResolver
+        // before ModelsConfig is instantiated, so we use it as the single source of truth
+        this._generationConfig = {
+            ...(options.generationConfig || {}),
+        };
+        this.generationConfigSources = options.generationConfigSources || {};
+        // Track if authType was explicitly provided
+        this.authTypeWasExplicitlyProvided = options.initialAuthType !== undefined;
+        // Initialize selection state
+        this.currentAuthType = options.initialAuthType;
+    }
+    /**
+     * Create a snapshot of the current ModelsConfig state for rollback purposes.
+     * Used before model switching operations to enable recovery on errors.
+     *
+     * Note: This is different from RuntimeModelSnapshot which stores runtime model configs.
+     */
+    createStateSnapshotForRollback() {
+        return {
+            currentAuthType: this.currentAuthType,
+            generationConfig: ModelsConfig.deepClone(this._generationConfig),
+            generationConfigSources: ModelsConfig.deepClone(this.generationConfigSources),
+            strictModelProviderSelection: this.strictModelProviderSelection,
+            requireCachedQwenCredentialsOnce: this.requireCachedQwenCredentialsOnce,
+            hasManualCredentials: this.hasManualCredentials,
+            activeRuntimeModelSnapshotId: this.activeRuntimeModelSnapshotId,
+        };
+    }
+    /**
+     * Restore ModelsConfig state from a previously created state snapshot.
+     * Used for rollback when model switching operations fail.
+     *
+     * @param snapshot - The state snapshot to restore
+     */
+    rollbackToStateSnapshot(snapshot) {
+        this.currentAuthType = snapshot.currentAuthType;
+        this._generationConfig = snapshot.generationConfig;
+        this.generationConfigSources = snapshot.generationConfigSources;
+        this.strictModelProviderSelection = snapshot.strictModelProviderSelection;
+        this.requireCachedQwenCredentialsOnce =
+            snapshot.requireCachedQwenCredentialsOnce;
+        this.hasManualCredentials = snapshot.hasManualCredentials;
+        this.activeRuntimeModelSnapshotId = snapshot.activeRuntimeModelSnapshotId;
+    }
+    /**
+     * Get current model ID
+     */
+    getModel() {
+        return this._generationConfig.model || DEFAULT_QWEN_MODEL;
+    }
+    /**
+     * Get current authType
+     */
+    getCurrentAuthType() {
+        return this.currentAuthType;
+    }
+    /**
+     * Check if authType was explicitly provided (via CLI or settings).
+     * If false, no authType was provided yet (fresh user).
+     */
+    wasAuthTypeExplicitlyProvided() {
+        return this.authTypeWasExplicitlyProvided;
+    }
+    /**
+     * Get available models for current authType
+     */
+    getAvailableModels() {
+        return this.currentAuthType
+            ? this.modelRegistry.getModelsForAuthType(this.currentAuthType)
+            : [];
+    }
+    /**
+     * Get available models for a specific authType
+     */
+    getAvailableModelsForAuthType(authType) {
+        return this.modelRegistry.getModelsForAuthType(authType);
+    }
+    /**
+     * Get all configured models across authTypes.
+     *
+     * Notes:
+     * - By default, returns models across all authTypes.
+     * - qwen-oauth models are always ordered first.
+     * - Runtime model option (if active) is included before registry models of the same authType.
+     */
+    getAllConfiguredModels(authTypes) {
+        const inputAuthTypes = authTypes && authTypes.length > 0 ? authTypes : Object.values(AuthType);
+        // De-duplicate while preserving the original order.
+        const seen = new Set();
+        const uniqueAuthTypes = [];
+        for (const authType of inputAuthTypes) {
+            if (!seen.has(authType)) {
+                seen.add(authType);
+                uniqueAuthTypes.push(authType);
+            }
+        }
+        // Force qwen-oauth to the front (if requested / defaulted in).
+        const orderedAuthTypes = [];
+        if (uniqueAuthTypes.includes(AuthType.QWEN_OAUTH)) {
+            orderedAuthTypes.push(AuthType.QWEN_OAUTH);
+        }
+        for (const authType of uniqueAuthTypes) {
+            if (authType !== AuthType.QWEN_OAUTH) {
+                orderedAuthTypes.push(authType);
+            }
+        }
+        // Get runtime model option
+        const runtimeOption = this.getRuntimeModelOption();
+        const allModels = [];
+        for (const authType of orderedAuthTypes) {
+            // Add runtime option first if it matches this authType
+            if (runtimeOption && runtimeOption.authType === authType) {
+                allModels.push(runtimeOption);
+            }
+            // Add registry models
+            allModels.push(...this.modelRegistry.getModelsForAuthType(authType));
+        }
+        return allModels;
+    }
+    /**
+     * Check if a model exists for the given authType
+     */
+    hasModel(authType, modelId) {
+        return this.modelRegistry.hasModel(authType, modelId);
+    }
+    /**
+     * Set model programmatically (e.g., VLM auto-switch, fallback).
+     * Supports both registry models and raw model IDs.
+     */
+    async setModel(newModel, metadata) {
+        // Special case: qwen-oauth model switch - hot update in place
+        // coder-model supports vision capabilities and can be hot-updated
+        if (this.currentAuthType === AuthType.QWEN_OAUTH &&
+            newModel === DEFAULT_QWEN_MODEL) {
+            this.strictModelProviderSelection = false;
+            this._generationConfig.model = newModel;
+            this.generationConfigSources['model'] = {
+                kind: 'programmatic',
+                detail: metadata?.reason || 'setModel',
+            };
+            // Notify Config to update contentGeneratorConfig
+            if (this.onModelChange) {
+                await this.onModelChange(AuthType.QWEN_OAUTH, false);
+            }
+            return;
+        }
+        // If model exists in registry, use full switch logic
+        if (this.currentAuthType &&
+            this.modelRegistry.hasModel(this.currentAuthType, newModel)) {
+            await this.switchModel(this.currentAuthType, newModel);
+            return;
+        }
+        // Raw model override: update generation config in-place
+        this.strictModelProviderSelection = false;
+        this._generationConfig.model = newModel;
+        this.generationConfigSources['model'] = {
+            kind: 'programmatic',
+            detail: metadata?.reason || 'setModel',
+        };
+    }
+    /**
+     * Switch model (and optionally authType).
+     * Supports both registry-backed models and RuntimeModelSnapshots.
+     *
+     * For runtime models, the modelId can be:
+     * - A RuntimeModelSnapshot ID (format: `$runtime|${authType}|${modelId}`)
+     * - With explicit `$runtime|` prefix (format: `$runtime|${authType}|${modelId}`)
+     *
+     * When called from ACP integration, the modelId has already been parsed
+     * by parseAcpModelOption, which strips any (${authType}) suffix.
+     */
+    async switchModel(authType, modelId, options) {
+        // Check if this is a RuntimeModelSnapshot reference
+        const runtimeModelSnapshotId = this.extractRuntimeModelSnapshotId(modelId);
+        if (runtimeModelSnapshotId) {
+            await this.switchToRuntimeModel(runtimeModelSnapshotId);
+            return;
+        }
+        const rollbackSnapshot = this.createStateSnapshotForRollback();
+        if (authType === AuthType.QWEN_OAUTH && options?.requireCachedCredentials) {
+            this.requireCachedQwenCredentialsOnce = true;
+        }
+        try {
+            const isAuthTypeChange = authType !== this.currentAuthType;
+            this.currentAuthType = authType;
+            const model = this.modelRegistry.getModel(authType, modelId);
+            if (!model) {
+                throw new Error(`Model '${modelId}' not found for authType '${authType}'`);
+            }
+            // Apply model defaults
+            this.applyResolvedModelDefaults(model);
+            // Clear active runtime model snapshot since we're now using a registry model
+            this.activeRuntimeModelSnapshotId = undefined;
+            const requiresRefresh = isAuthTypeChange
+                ? true
+                : this.checkRequiresRefresh(rollbackSnapshot.generationConfig.model || '');
+            if (this.onModelChange) {
+                await this.onModelChange(authType, requiresRefresh);
+            }
+        }
+        catch (error) {
+            // Rollback on error
+            this.rollbackToStateSnapshot(rollbackSnapshot);
+            throw error;
+        }
+    }
+    /**
+     * Prefix used to identify RuntimeModelSnapshot IDs.
+     * Chosen to avoid conflicts with real model IDs which may contain `-` or `:`.
+     */
+    static RUNTIME_SNAPSHOT_PREFIX = '$runtime|';
+    /**
+     * Build a RuntimeModelSnapshot ID from authType and modelId.
+     * The format is: `$runtime|${authType}|${modelId}`
+     *
+     * This is the canonical way to construct snapshot IDs, ensuring
+     * consistency across creation and lookup.
+     *
+     * @param authType - The authentication type
+     * @param modelId - The model ID
+     * @returns The snapshot ID in format `$runtime|${authType}|${modelId}`
+     */
+    buildRuntimeModelSnapshotId(authType, modelId) {
+        return `${ModelsConfig.RUNTIME_SNAPSHOT_PREFIX}${authType}|${modelId}`;
+    }
+    /**
+     * Extract RuntimeModelSnapshot ID from modelId if it's a runtime model reference.
+     *
+     * Supports the following formats:
+     * - Direct snapshot ID: `$runtime|${authType}|${modelId}` → returns as-is if exists in Map
+     * - Direct snapshot ID match: returns if exists in Map
+     *
+     * Note: When called from ACP integration via setModel, the modelId has already
+     * been parsed by parseAcpModelOption which strips any (${authType}) suffix.
+     * So we don't need to handle ACP format here - the ACP layer handles that.
+     *
+     * @param modelId - The model ID to parse
+     * @returns The RuntimeModelSnapshot ID if found, undefined otherwise
+     */
+    extractRuntimeModelSnapshotId(modelId) {
+        // Check if modelId starts with the runtime snapshot prefix
+        if (modelId.startsWith(ModelsConfig.RUNTIME_SNAPSHOT_PREFIX)) {
+            // Verify the snapshot exists
+            if (this.runtimeModelSnapshots.has(modelId)) {
+                return modelId;
+            }
+            // Even with prefix, if it doesn't exist, don't return it
+            return undefined;
+        }
+        // Check if modelId itself is a valid snapshot ID (exists in Map)
+        if (this.runtimeModelSnapshots.has(modelId)) {
+            return modelId;
+        }
+        return undefined;
+    }
+    /**
+     * Get generation config for ContentGenerator creation
+     */
+    getGenerationConfig() {
+        return this._generationConfig;
+    }
+    /**
+     * Get generation config sources for debugging/UI
+     */
+    getGenerationConfigSources() {
+        return this.generationConfigSources;
+    }
+    /**
+     * Merge settings generation config, preserving existing values.
+     * Used when provider-sourced config is cleared but settings should still apply.
+     */
+    mergeSettingsGenerationConfig(settingsGenerationConfig) {
+        if (!settingsGenerationConfig) {
+            return;
+        }
+        for (const field of MODEL_GENERATION_CONFIG_FIELDS) {
+            if (!(field in this._generationConfig) &&
+                field in settingsGenerationConfig) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this._generationConfig[field] =
+                    settingsGenerationConfig[field];
+                this.generationConfigSources[field] = {
+                    kind: 'settings',
+                    detail: `model.generationConfig.${field}`,
+                };
+            }
+        }
+    }
+    /**
+     * Update credentials in generation config.
+     * Sets a flag to prevent syncAfterAuthRefresh from overriding these credentials.
+     *
+     * When credentials are manually set, we clear all provider-sourced configuration
+     * to maintain provider atomicity (either fully applied or not at all).
+     * Other layers (CLI, env, settings, defaults) will participate in resolve.
+     *
+     * Also updates or creates a RuntimeModelSnapshot when credentials form a complete config
+     * for a model not in the registry. This allows the runtime model to be reused later.
+     *
+     * @param settingsGenerationConfig Optional generation config from settings.json
+     *                                  to merge after clearing provider-sourced config.
+     *                                  This ensures settings.model.generationConfig fields
+     *                                  (e.g., samplingParams, timeout) are preserved.
+     */
+    updateCredentials(credentials, settingsGenerationConfig) {
+        /**
+         * If any fields are updated here, we treat the resulting config as manually overridden
+         * and avoid applying modelProvider defaults during the next auth refresh.
+         *
+         * Clear all provider-sourced configuration to maintain provider atomicity.
+         * This ensures that when user manually sets credentials, the provider config
+         * is either fully applied (via switchModel) or not at all.
+         */
+        if (credentials.apiKey || credentials.baseUrl || credentials.model) {
+            this.hasManualCredentials = true;
+            this.clearProviderSourcedConfig();
+        }
+        if (credentials.apiKey) {
+            this._generationConfig.apiKey = credentials.apiKey;
+            this.generationConfigSources['apiKey'] = {
+                kind: 'programmatic',
+                detail: 'updateCredentials',
+            };
+        }
+        if (credentials.baseUrl) {
+            this._generationConfig.baseUrl = credentials.baseUrl;
+            this.generationConfigSources['baseUrl'] = {
+                kind: 'programmatic',
+                detail: 'updateCredentials',
+            };
+        }
+        if (credentials.model) {
+            this._generationConfig.model = credentials.model;
+            this.generationConfigSources['model'] = {
+                kind: 'programmatic',
+                detail: 'updateCredentials',
+            };
+        }
+        // When credentials are manually set, disable strict model provider selection
+        // so validation doesn't require envKey-based credentials
+        this.strictModelProviderSelection = false;
+        // Clear apiKeyEnvKey to prevent validation from requiring environment variable
+        this._generationConfig.apiKeyEnvKey = undefined;
+        // After clearing provider-sourced config, merge settings.model.generationConfig
+        // to ensure fields like samplingParams, timeout, etc. are preserved.
+        // This follows the resolution strategy where settings.model.generationConfig
+        // has lower priority than programmatic overrides but should still be applied.
+        if (settingsGenerationConfig) {
+            this.mergeSettingsGenerationConfig(settingsGenerationConfig);
+        }
+        // Sync with runtime model snapshot if we have a complete configuration
+        this.syncRuntimeModelSnapshotWithCredentials();
+    }
+    /**
+     * Sync RuntimeModelSnapshot with current credentials.
+     *
+     * Creates or updates a RuntimeModelSnapshot when current credentials form a complete
+     * configuration for a model not in the registry. This enables:
+     * - Reusing the runtime model configuration later
+     * - Showing the runtime model as an available option in model lists
+     *
+     * Only creates snapshots for models NOT in the registry (to avoid duplication).
+     */
+    syncRuntimeModelSnapshotWithCredentials() {
+        const currentAuthType = this.currentAuthType;
+        const { model, apiKey, baseUrl } = this._generationConfig;
+        // Early return if missing required fields
+        if (!model || !currentAuthType || !apiKey || !baseUrl) {
+            return;
+        }
+        // Check if model exists in registry - if so, don't create RuntimeModelSnapshot
+        if (this.modelRegistry.hasModel(currentAuthType, model)) {
+            return;
+        }
+        // If we have an active snapshot, update it
+        if (this.activeRuntimeModelSnapshotId &&
+            this.runtimeModelSnapshots.has(this.activeRuntimeModelSnapshotId)) {
+            const snapshot = this.runtimeModelSnapshots.get(this.activeRuntimeModelSnapshotId);
+            // Update snapshot with current values (already verified to exist above)
+            snapshot.apiKey = apiKey;
+            snapshot.baseUrl = baseUrl;
+            snapshot.modelId = model;
+            // Update ID if model changed
+            const newSnapshotId = this.buildRuntimeModelSnapshotId(snapshot.authType, snapshot.modelId);
+            if (newSnapshotId !== snapshot.id) {
+                this.runtimeModelSnapshots.delete(snapshot.id);
+                snapshot.id = newSnapshotId;
+                this.runtimeModelSnapshots.set(newSnapshotId, snapshot);
+                this.activeRuntimeModelSnapshotId = newSnapshotId;
+            }
+            snapshot.createdAt = Date.now();
+        }
+        else {
+            // Create new snapshot
+            this.detectAndCaptureRuntimeModel();
+        }
+    }
+    /**
+     * Clear configuration fields that were sourced from modelProviders.
+     * This ensures provider config atomicity when user manually sets credentials.
+     * Other layers (CLI, env, settings, defaults) will participate in resolve.
+     */
+    clearProviderSourcedConfig() {
+        for (const field of PROVIDER_SOURCED_FIELDS) {
+            const source = this.generationConfigSources[field];
+            if (source?.kind === 'modelProviders') {
+                // Clear the value - let other layers resolve it
+                delete this._generationConfig[field];
+                delete this.generationConfigSources[field];
+            }
+        }
+    }
+    /**
+     * Get whether strict model provider selection is enabled
+     */
+    isStrictModelProviderSelection() {
+        return this.strictModelProviderSelection;
+    }
+    /**
+     * Reset strict model provider selection flag
+     */
+    resetStrictModelProviderSelection() {
+        this.strictModelProviderSelection = false;
+    }
+    /**
+     * Check and consume the one-shot cached credentials flag
+     */
+    consumeRequireCachedCredentialsFlag() {
+        const value = this.requireCachedQwenCredentialsOnce;
+        this.requireCachedQwenCredentialsOnce = false;
+        return value;
+    }
+    /**
+     * Apply resolved model config to generation config
+     */
+    applyResolvedModelDefaults(model) {
+        this.strictModelProviderSelection = true;
+        // We're explicitly applying modelProvider defaults now, so manual overrides
+        // should no longer block syncAfterAuthRefresh from applying provider defaults.
+        this.hasManualCredentials = false;
+        this._generationConfig.model = model.id;
+        this.generationConfigSources['model'] = {
+            kind: 'modelProviders',
+            authType: model.authType,
+            modelId: model.id,
+            detail: 'model.id',
+        };
+        // Clear credentials to avoid reusing previous model's API key
+        // For Qwen OAuth, apiKey must always be a placeholder. It will be dynamically
+        // replaced when building requests. Do not preserve any previous key or read
+        // from envKey.
+        //
+        // (OpenAI client instantiation requires an apiKey even though it will be
+        // replaced later.)
+        if (this.currentAuthType === AuthType.QWEN_OAUTH) {
+            this._generationConfig.apiKey = 'QWEN_OAUTH_DYNAMIC_TOKEN';
+            this.generationConfigSources['apiKey'] = {
+                kind: 'computed',
+                detail: 'Qwen OAuth placeholder token',
+            };
+            this._generationConfig.apiKeyEnvKey = undefined;
+            delete this.generationConfigSources['apiKeyEnvKey'];
+        }
+        else {
+            this._generationConfig.apiKey = undefined;
+            this._generationConfig.apiKeyEnvKey = undefined;
+        }
+        // Read API key from environment variable if envKey is specified
+        if (model.envKey !== undefined) {
+            const apiKey = process.env[model.envKey];
+            if (apiKey) {
+                this._generationConfig.apiKey = apiKey;
+                this.generationConfigSources['apiKey'] = {
+                    kind: 'env',
+                    envKey: model.envKey,
+                    via: {
+                        kind: 'modelProviders',
+                        authType: model.authType,
+                        modelId: model.id,
+                        detail: 'envKey',
+                    },
+                };
+            }
+            this._generationConfig.apiKeyEnvKey = model.envKey;
+            this.generationConfigSources['apiKeyEnvKey'] = {
+                kind: 'modelProviders',
+                authType: model.authType,
+                modelId: model.id,
+                detail: 'envKey',
+            };
+        }
+        // Base URL
+        this._generationConfig.baseUrl = model.baseUrl;
+        this.generationConfigSources['baseUrl'] = {
+            kind: 'modelProviders',
+            authType: model.authType,
+            modelId: model.id,
+            detail: 'baseUrl',
+        };
+        // Generation config: apply all fields from MODEL_GENERATION_CONFIG_FIELDS
+        const gc = model.generationConfig;
+        for (const field of MODEL_GENERATION_CONFIG_FIELDS) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this._generationConfig[field] = gc[field];
+            this.generationConfigSources[field] = {
+                kind: 'modelProviders',
+                authType: model.authType,
+                modelId: model.id,
+                detail: `generationConfig.${field}`,
+            };
+        }
+        // contextWindowSize fallback: auto-detect from model when not set by provider
+        if (gc.contextWindowSize === undefined) {
+            this._generationConfig.contextWindowSize = tokenLimit(model.id, 'input');
+            this.generationConfigSources['contextWindowSize'] = {
+                kind: 'computed',
+                detail: 'auto-detected from model',
+            };
+        }
+        // modalities fallback: auto-detect from model when not set by provider
+        if (gc.modalities === undefined) {
+            this._generationConfig.modalities = defaultModalities(model.id);
+            this.generationConfigSources['modalities'] = {
+                kind: 'computed',
+                detail: 'auto-detected from model',
+            };
+        }
+    }
+    /**
+     * Check if model switch requires ContentGenerator refresh.
+     *
+     * Note: This method is ONLY called by switchModel() for same-authType model switches.
+     * Cross-authType switches use switchModel(authType, modelId), which always requires full refresh.
+     *
+     * When this method is called:
+     * - this.currentAuthType is already the target authType
+     * - We're checking if switching between two models within the SAME authType needs refresh
+     *
+     * Examples:
+     * - Qwen OAuth: coder-model switches (same authType, hot-update safe)
+     * - OpenAI: model-a -> model-b with same envKey (same authType, hot-update safe)
+     * - OpenAI: gpt-4 -> deepseek-chat with different envKey (same authType, needs refresh)
+     *
+     * Cross-authType scenarios:
+     * - OpenAI -> Qwen OAuth: handled by switchModel(authType, modelId), always refreshes
+     * - Qwen OAuth -> OpenAI: handled by switchModel(authType, modelId), always refreshes
+     */
+    checkRequiresRefresh(previousModelId) {
+        // Defensive: this method is only called after switchModel() sets currentAuthType,
+        // but keep type safety for any future callsites.
+        const authType = this.currentAuthType;
+        if (!authType) {
+            return true;
+        }
+        // For Qwen OAuth, model switches within the same authType can always be hot-updated
+        // (coder-model supports vision capabilities and doesn't require ContentGenerator recreation)
+        if (authType === AuthType.QWEN_OAUTH) {
+            return false;
+        }
+        // Get previous and current model configs
+        const previousModel = this.modelRegistry.getModel(authType, previousModelId);
+        const currentModel = this.modelRegistry.getModel(authType, this._generationConfig.model || '');
+        // If either model is not in registry, require refresh to be safe
+        if (!previousModel || !currentModel) {
+            return true;
+        }
+        // Check if critical fields changed that require ContentGenerator recreation
+        const criticalFieldsChanged = previousModel.envKey !== currentModel.envKey ||
+            previousModel.baseUrl !== currentModel.baseUrl;
+        if (criticalFieldsChanged) {
+            return true;
+        }
+        // For other auth types with strict model provider selection,
+        // if no critical fields changed, we can still hot-update
+        // (e.g., switching between two OpenAI models with same envKey and baseUrl)
+        return false;
+    }
+    /**
+     * Sync state after auth refresh with fallback strategy:
+     * 1. If modelId can be found in modelRegistry, use the config from modelRegistry.
+     * 2. Otherwise, if existing credentials exist in resolved generationConfig from other sources
+     *    (not modelProviders), preserve them and update authType/modelId only.
+     * 3. Otherwise, fall back to default model for the authType.
+     * 4. If no default is available, leave the generationConfig incomplete and let
+     *    resolveContentGeneratorConfigWithSources throw exceptions as expected.
+     */
+    syncAfterAuthRefresh(authType, modelId) {
+        this.strictModelProviderSelection = false;
+        const previousAuthType = this.currentAuthType;
+        this.currentAuthType = authType;
+        // Step 1: If modelId exists in registry, always use config from modelRegistry
+        // Manual credentials won't have a modelId that matches a provider model (handleAuthSelect prevents it),
+        // so if modelId exists in registry, we should always use provider config.
+        // This handles provider switching even within the same authType.
+        if (modelId && this.modelRegistry.hasModel(authType, modelId)) {
+            const resolved = this.modelRegistry.getModel(authType, modelId);
+            if (resolved) {
+                this.applyResolvedModelDefaults(resolved);
+                this.strictModelProviderSelection = true;
+                // Clear active runtime model snapshot since we're now using a registry model
+                this.activeRuntimeModelSnapshotId = undefined;
+                return;
+            }
+        }
+        // Step 2: Check if there are existing credentials from other sources (not modelProviders)
+        const apiKeySource = this.generationConfigSources['apiKey'];
+        const baseUrlSource = this.generationConfigSources['baseUrl'];
+        const hasExistingCredentials = (this._generationConfig.apiKey &&
+            apiKeySource?.kind !== 'modelProviders') ||
+            (this._generationConfig.baseUrl &&
+                baseUrlSource?.kind !== 'modelProviders');
+        // Only preserve credentials if:
+        // 1. AuthType hasn't changed (credentials are authType-specific), AND
+        // 2. The modelId doesn't exist in the registry (if it did, we would have used provider config in Step 1), AND
+        // 3. Either:
+        //    a. We have manual credentials (set via updateCredentials), OR
+        //    b. We have existing credentials
+        // Note: Even if authType hasn't changed, switching to a different provider model (that exists in registry)
+        // will use provider config (Step 1), not preserve old credentials. This ensures credentials change when
+        // switching providers, independent of authType changes.
+        const isAuthTypeChange = previousAuthType !== authType;
+        const shouldPreserveCredentials = !isAuthTypeChange &&
+            (modelId === undefined ||
+                !this.modelRegistry.hasModel(authType, modelId)) &&
+            (this.hasManualCredentials || hasExistingCredentials);
+        if (shouldPreserveCredentials) {
+            // Preserve existing credentials, just update authType and modelId if provided
+            if (modelId) {
+                this._generationConfig.model = modelId;
+                if (!this.generationConfigSources['model']) {
+                    this.generationConfigSources['model'] = {
+                        kind: 'programmatic',
+                        detail: 'auth refresh (preserved credentials)',
+                    };
+                }
+            }
+            return;
+        }
+        // Step 3: Fall back to default model for the authType
+        const defaultModel = this.modelRegistry.getDefaultModelForAuthType(authType);
+        if (defaultModel) {
+            this.applyResolvedModelDefaults(defaultModel);
+            // Clear active runtime model snapshot since we're now using a registry model
+            this.activeRuntimeModelSnapshotId = undefined;
+            return;
+        }
+        // Step 4: No default available - leave generationConfig incomplete
+        // resolveContentGeneratorConfigWithSources will throw exceptions as expected
+        if (modelId) {
+            this._generationConfig.model = modelId;
+            if (!this.generationConfigSources['model']) {
+                this.generationConfigSources['model'] = {
+                    kind: 'programmatic',
+                    detail: 'auth refresh (no default model)',
+                };
+            }
+        }
+    }
+    /**
+     * Update callback for model changes
+     */
+    setOnModelChange(callback) {
+        this.onModelChange = callback;
+    }
+    /**
+     * Detect and capture RuntimeModelSnapshot during initialization.
+     *
+     * Checks if the current configuration represents a runtime model (not from
+     * modelProviders registry) and captures it as a RuntimeModelSnapshot.
+     *
+     * This enables runtime models to persist across sessions and appear in model lists.
+     *
+     * @returns Created snapshot ID, or undefined if current config is a registry model
+     */
+    detectAndCaptureRuntimeModel() {
+        const { model: currentModel, apiKey, baseUrl, apiKeyEnvKey, ...generationConfig } = this._generationConfig;
+        const currentAuthType = this.currentAuthType;
+        if (!currentModel || !currentAuthType) {
+            return undefined;
+        }
+        // Check if model exists in registry - if so, it's not a runtime model
+        if (this.modelRegistry.hasModel(currentAuthType, currentModel)) {
+            // Current is a registry model, clear any previous RuntimeModelSnapshot for this authType
+            this.clearRuntimeModelSnapshotForAuthType(currentAuthType);
+            return undefined;
+        }
+        // Check if we have valid credentials (apiKey + baseUrl)
+        const hasValidCredentials = this._generationConfig.apiKey && this._generationConfig.baseUrl;
+        if (!hasValidCredentials) {
+            return undefined;
+        }
+        // Create or update RuntimeModelSnapshot
+        const snapshotId = this.buildRuntimeModelSnapshotId(currentAuthType, currentModel);
+        const snapshot = {
+            id: snapshotId,
+            authType: currentAuthType,
+            modelId: currentModel,
+            apiKey,
+            baseUrl,
+            apiKeyEnvKey,
+            generationConfig,
+            sources: { ...this.generationConfigSources },
+            createdAt: Date.now(),
+        };
+        this.runtimeModelSnapshots.set(snapshotId, snapshot);
+        this.activeRuntimeModelSnapshotId = snapshotId;
+        // Enforce per-authType limit
+        this.cleanupOldRuntimeModelSnapshots();
+        return snapshotId;
+    }
+    /**
+     * Get the currently active RuntimeModelSnapshot.
+     *
+     * @returns The active RuntimeModelSnapshot, or undefined if no runtime model is active
+     */
+    getActiveRuntimeModelSnapshot() {
+        if (!this.activeRuntimeModelSnapshotId) {
+            return undefined;
+        }
+        return this.runtimeModelSnapshots.get(this.activeRuntimeModelSnapshotId);
+    }
+    /**
+     * Get the ID of the currently active RuntimeModelSnapshot.
+     *
+     * @returns The active snapshot ID, or undefined if no runtime model is active
+     */
+    getActiveRuntimeModelSnapshotId() {
+        return this.activeRuntimeModelSnapshotId;
+    }
+    /**
+     * Switch to a RuntimeModelSnapshot.
+     *
+     * Applies the configuration from a previously captured RuntimeModelSnapshot.
+     * Uses state rollback pattern: creates a state snapshot before switching and
+     * restores it on error.
+     *
+     * @param snapshotId - The ID of the RuntimeModelSnapshot to switch to
+     */
+    async switchToRuntimeModel(snapshotId) {
+        const runtimeModelSnapshot = this.runtimeModelSnapshots.get(snapshotId);
+        if (!runtimeModelSnapshot) {
+            throw new Error(`Runtime model snapshot '${snapshotId}' not found`);
+        }
+        const rollbackSnapshot = this.createStateSnapshotForRollback();
+        try {
+            const isAuthTypeChange = runtimeModelSnapshot.authType !== this.currentAuthType;
+            this.currentAuthType = runtimeModelSnapshot.authType;
+            this.activeRuntimeModelSnapshotId = snapshotId;
+            // Apply runtime configuration
+            this.strictModelProviderSelection = false;
+            this.hasManualCredentials = true; // Mark as manual to prevent provider override
+            this._generationConfig.model = runtimeModelSnapshot.modelId;
+            this.generationConfigSources['model'] = {
+                kind: 'programmatic',
+                detail: 'runtimeModelSwitch',
+            };
+            if (runtimeModelSnapshot.apiKey) {
+                this._generationConfig.apiKey = runtimeModelSnapshot.apiKey;
+                this.generationConfigSources['apiKey'] = runtimeModelSnapshot.sources['apiKey'] || {
+                    kind: 'programmatic',
+                    detail: 'runtimeModelSwitch',
+                };
+            }
+            if (runtimeModelSnapshot.baseUrl) {
+                this._generationConfig.baseUrl = runtimeModelSnapshot.baseUrl;
+                this.generationConfigSources['baseUrl'] = runtimeModelSnapshot.sources['baseUrl'] || {
+                    kind: 'programmatic',
+                    detail: 'runtimeModelSwitch',
+                };
+            }
+            if (runtimeModelSnapshot.apiKeyEnvKey) {
+                this._generationConfig.apiKeyEnvKey = runtimeModelSnapshot.apiKeyEnvKey;
+            }
+            // Apply generation config
+            if (runtimeModelSnapshot.generationConfig) {
+                Object.assign(this._generationConfig, runtimeModelSnapshot.generationConfig);
+            }
+            const requiresRefresh = isAuthTypeChange;
+            if (this.onModelChange) {
+                await this.onModelChange(runtimeModelSnapshot.authType, requiresRefresh);
+            }
+        }
+        catch (error) {
+            this.rollbackToStateSnapshot(rollbackSnapshot);
+            throw error;
+        }
+    }
+    /**
+     * Get the active RuntimeModelSnapshot as an AvailableModel option.
+     *
+     * Converts the active RuntimeModelSnapshot to an AvailableModel format for display
+     * in model lists. Returns undefined if no runtime model is active.
+     *
+     * @returns The runtime model as an AvailableModel option, or undefined
+     */
+    getRuntimeModelOption() {
+        const snapshot = this.getActiveRuntimeModelSnapshot();
+        if (!snapshot) {
+            return undefined;
+        }
+        return {
+            id: snapshot.modelId,
+            label: snapshot.modelId,
+            authType: snapshot.authType,
+            /**
+             * `isVision` is for automatic switching of qwen-oauth vision model.
+             * Runtime models are basically specified via CLI arguments, env variables,
+             * or settings for other auth types.
+             */
+            isVision: false,
+            contextWindowSize: snapshot.generationConfig?.contextWindowSize,
+            isRuntimeModel: true,
+            runtimeSnapshotId: snapshot.id,
+        };
+    }
+    /**
+     * Clear all RuntimeModelSnapshots for a specific authType.
+     *
+     * Removes all RuntimeModelSnapshots associated with the given authType.
+     * Called when switching to a registry model to avoid stale RuntimeModelSnapshots.
+     *
+     * @param authType - The authType whose snapshots should be cleared
+     */
+    clearRuntimeModelSnapshotForAuthType(authType) {
+        for (const [id, snapshot] of this.runtimeModelSnapshots.entries()) {
+            if (snapshot.authType === authType) {
+                this.runtimeModelSnapshots.delete(id);
+                if (this.activeRuntimeModelSnapshotId === id) {
+                    this.activeRuntimeModelSnapshotId = undefined;
+                }
+            }
+        }
+    }
+    /**
+     * Cleanup old RuntimeModelSnapshots to enforce per-authType limit.
+     *
+     * Keeps only the latest RuntimeModelSnapshot for each authType.
+     * Older snapshots are removed to prevent unbounded growth.
+     */
+    cleanupOldRuntimeModelSnapshots() {
+        const snapshotsByAuthType = new Map();
+        for (const snapshot of this.runtimeModelSnapshots.values()) {
+            const existing = snapshotsByAuthType.get(snapshot.authType);
+            if (!existing || snapshot.createdAt > existing.createdAt) {
+                snapshotsByAuthType.set(snapshot.authType, snapshot);
+            }
+        }
+        this.runtimeModelSnapshots.clear();
+        for (const snapshot of snapshotsByAuthType.values()) {
+            this.runtimeModelSnapshots.set(snapshot.id, snapshot);
+        }
+        // Update active snapshot ID if it was removed
+        if (this.activeRuntimeModelSnapshotId &&
+            !this.runtimeModelSnapshots.has(this.activeRuntimeModelSnapshotId)) {
+            this.activeRuntimeModelSnapshotId = undefined;
+        }
+    }
+    /**
+     * Reload model providers configuration at runtime.
+     * This enables hot-reloading of modelProviders settings without restarting the CLI.
+     *
+     * @param modelProvidersConfig - The updated model providers configuration
+     */
+    reloadModelProvidersConfig(modelProvidersConfig) {
+        this.modelRegistry.reloadModels(modelProvidersConfig);
+    }
+}
+//# sourceMappingURL=modelsConfig.js.map