@qwen-code/qwen-code 0.23.3 → 0.23.4

package/chunks/chunk-5JG3DAKS.js

@@ -0,0 +1,1416 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  DEFAULT_OPENAI_BASE_URL
+} from "./chunk-JL6APGBX.js";
+import {
+  defaultModalities
+} from "./chunk-7MIBD3LG.js";
+import {
+  tokenLimit
+} from "./chunk-FPGTNKCP.js";
+import {
+  DEFAULT_QWEN_MODEL,
+  MODEL_GENERATION_CONFIG_FIELDS,
+  PROVIDER_SOURCED_FIELDS,
+  QWEN_OAUTH_MODELS
+} from "./chunk-7W2Y3PZD.js";
+import {
+  AuthType
+} from "./chunk-ERU3SDXT.js";
+import {
+  createDebugLogger
+} from "./chunk-ZAFYHRVY.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/runtimeModelPrefix.ts
+init_esbuild_shims();
+var RUNTIME_SNAPSHOT_PREFIX = "$runtime|";
+function buildRuntimeSnapshotId(authType, modelId) {
+  return `${RUNTIME_SNAPSHOT_PREFIX}${authType}|${modelId}`;
+}
+__name(buildRuntimeSnapshotId, "buildRuntimeSnapshotId");
+function stripRuntimeSnapshotPrefix(modelId) {
+  let id = modelId;
+  while (id.startsWith(RUNTIME_SNAPSHOT_PREFIX)) {
+    const stripped = id.split("|").slice(2).join("|");
+    if (!stripped) break;
+    id = stripped;
+  }
+  return id;
+}
+__name(stripRuntimeSnapshotPrefix, "stripRuntimeSnapshotPrefix");
+
+// packages/core/src/utils/modelId.ts
+init_esbuild_shims();
+var AUTH_TYPES = new Set(Object.values(AuthType));
+function resolveModelId(model, context = {}) {
+  return resolveModelIdSelector(parseModelIdSelector(model), context);
+}
+__name(resolveModelId, "resolveModelId");
+function buildModelIdContext(config) {
+  return {
+    currentModel: config.getModel?.(),
+    currentAuthType: config.getContentGeneratorConfig?.()?.authType,
+    fastModel: config.getFastModel?.(),
+    getAvailableModels: /* @__PURE__ */ __name((authTypes) => config.getAllConfiguredModels?.(authTypes) ?? [], "getAvailableModels")
+  };
+}
+__name(buildModelIdContext, "buildModelIdContext");
+function parseModelIdSelector(model) {
+  const trimmed = model?.trim();
+  if (!trimmed || trimmed === "inherit") {
+    return { kind: "inherit" };
+  }
+  if (trimmed === "fast") {
+    return { kind: "fast" };
+  }
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex === -1) {
+    return { kind: "model", modelId: trimmed };
+  }
+  const maybeAuthType = trimmed.slice(0, colonIndex).trim();
+  const modelId = trimmed.slice(colonIndex + 1).trim();
+  if (!AUTH_TYPES.has(maybeAuthType)) {
+    return { kind: "model", modelId: trimmed };
+  }
+  if (!modelId) {
+    throw new Error(
+      "Model selector must include a model ID after the authType"
+    );
+  }
+  return {
+    kind: "model",
+    authType: maybeAuthType,
+    modelId
+  };
+}
+__name(parseModelIdSelector, "parseModelIdSelector");
+function resolveAuthTypeForBareModel(modelId, context) {
+  if (context.currentAuthType && context.getAvailableModels) {
+    const currentModels = context.getAvailableModels([context.currentAuthType]);
+    if (currentModels.some((model) => model.id === modelId)) {
+      return context.currentAuthType;
+    }
+  }
+  const configuredModel = context.getAvailableModels ? context.getAvailableModels().find((model) => model.id === modelId) : void 0;
+  return configuredModel?.authType ?? context.currentAuthType;
+}
+__name(resolveAuthTypeForBareModel, "resolveAuthTypeForBareModel");
+function resolveModelIdSelector(selector, context) {
+  if (selector.kind === "model") {
+    const authType = selector.authType ?? resolveAuthTypeForBareModel(selector.modelId, context);
+    return {
+      ...authType ? { authType } : {},
+      modelId: selector.modelId
+    };
+  }
+  if (selector.kind === "inherit") {
+    return context.currentModel ? {
+      ...context.currentAuthType ? { authType: context.currentAuthType } : {},
+      modelId: context.currentModel
+    } : void 0;
+  }
+  if (!context.fastModel) {
+    return void 0;
+  }
+  const fastSelector = parseModelIdSelector(context.fastModel);
+  if (fastSelector.kind === "fast") {
+    return void 0;
+  }
+  return resolveModelIdSelector(fastSelector, {
+    ...context,
+    fastModel: void 0
+  });
+}
+__name(resolveModelIdSelector, "resolveModelIdSelector");
+
+// packages/core/src/models/image-generation-capability.ts
+init_esbuild_shims();
+function isImageGenerationCapable(model) {
+  return model.supportsImageGeneration === true || model.imageOnly === true;
+}
+__name(isImageGenerationCapable, "isImageGenerationCapable");
+
+// packages/core/src/models/modelRegistry.ts
+init_esbuild_shims();
+
+// packages/core/src/models/types.ts
+init_esbuild_shims();
+
+// packages/core/src/models/modelRegistry.ts
+var debugLogger = createDebugLogger("MODEL_REGISTRY");
+function validateAuthTypeKey(key) {
+  if (Object.values(AuthType).includes(key)) {
+    return key;
+  }
+  return void 0;
+}
+__name(validateAuthTypeKey, "validateAuthTypeKey");
+function resolveProviderProtocol(providerId, providerProtocol) {
+  const explicit = providerProtocol && Object.hasOwn(providerProtocol, providerId) ? providerProtocol[providerId] : void 0;
+  if (explicit !== void 0) {
+    return validateAuthTypeKey(explicit);
+  }
+  return validateAuthTypeKey(providerId);
+}
+__name(resolveProviderProtocol, "resolveProviderProtocol");
+function shouldUseCanonicalModalities(modelId) {
+  return /^minimax-m3/i.test(modelId.trim().toLowerCase());
+}
+__name(shouldUseCanonicalModalities, "shouldUseCanonicalModalities");
+function modelRegistryKey(id, baseUrl) {
+  return baseUrl ? `${id}\0${baseUrl}` : id;
+}
+__name(modelRegistryKey, "modelRegistryKey");
+var ModelRegistry = class _ModelRegistry {
+  static {
+    __name(this, "ModelRegistry");
+  }
+  modelsByAuthType;
+  /** providerId -> SDK protocol mapping; persists across reloads. */
+  providerProtocolConfig;
+  /** Raw providers config this registry was last built from. */
+  modelProvidersConfig;
+  getDefaultBaseUrl(authType) {
+    switch (authType) {
+      case "qwen-oauth" /* QWEN_OAUTH */:
+        return "DYNAMIC_QWEN_OAUTH_BASE_URL";
+      case "openai" /* USE_OPENAI */:
+        return DEFAULT_OPENAI_BASE_URL;
+      default:
+        return "";
+    }
+  }
+  constructor(modelProvidersConfig, providerProtocolConfig) {
+    this.modelsByAuthType = /* @__PURE__ */ new Map();
+    this.providerProtocolConfig = providerProtocolConfig ?? {};
+    this.modelProvidersConfig = modelProvidersConfig;
+    this.registerAuthTypeModels("qwen-oauth" /* QWEN_OAUTH */, QWEN_OAUTH_MODELS);
+    this.registerProvidersConfig(modelProvidersConfig);
+  }
+  /**
+   * Register every user-configured provider under its resolved SDK protocol.
+   * A provider id maps to a protocol via {@link resolveProviderProtocol}
+   * (explicit `providerProtocol` entry, or the id itself when it is a built-in
+   * protocol). Unmapped unknown ids are skipped with a warning.
+   */
+  registerProvidersConfig(modelProvidersConfig) {
+    if (!modelProvidersConfig) return;
+    for (const [providerId, models] of Object.entries(modelProvidersConfig)) {
+      const protocol = resolveProviderProtocol(
+        providerId,
+        this.providerProtocolConfig
+      );
+      if (!protocol) {
+        const knownProtocols = Object.values(AuthType).join(", ");
+        const mapped = Object.hasOwn(this.providerProtocolConfig, providerId) ? this.providerProtocolConfig[providerId] : void 0;
+        const message = mapped !== void 0 ? `Provider "${providerId}" maps to "${mapped}" via providerProtocol, which is not a known protocol (${knownProtocols}); skipping.` : `Provider "${providerId}" in modelProviders is not a built-in protocol (${knownProtocols}) and has no providerProtocol mapping; skipping. Add providerProtocol["${providerId}"] to route it to an SDK protocol.`;
+        debugLogger.warn(message);
+        continue;
+      }
+      if (protocol === "qwen-oauth" /* QWEN_OAUTH */) {
+        continue;
+      }
+      this.registerAuthTypeModels(protocol, models, providerId);
+    }
+  }
+  /**
+   * Register models for an authType.
+   * Uniqueness is determined by the composite key (id + baseUrl).
+   * Two models with the same id but different baseUrls are treated as distinct.
+   * If multiple models share both id and baseUrl, the first one takes precedence.
+   */
+  registerAuthTypeModels(authType, models, providerId) {
+    if (!Array.isArray(models)) {
+      debugLogger.warn(
+        `modelProviders for provider "${providerId ?? authType}" is not an array; skipping. Expected ModelConfig[]; legacy { protocol, models } entries are normally rewritten by the v5->v4 settings migration.`
+      );
+      return;
+    }
+    const modelMap = this.modelsByAuthType.get(authType) ?? /* @__PURE__ */ new Map();
+    const providerLabel = providerId && providerId !== authType ? ` (provider "${providerId}")` : "";
+    for (const config of models) {
+      const key = modelRegistryKey(config.id, config.baseUrl);
+      if (modelMap.has(key)) {
+        debugLogger.warn(
+          `Duplicate model id "${config.id}"${config.baseUrl ? ` with baseUrl "${config.baseUrl}"` : ""} for protocol "${authType}"${providerLabel}. Using the first registered config.`
+        );
+        continue;
+      }
+      const resolved = this.resolveModelConfig(config, authType);
+      modelMap.set(key, resolved);
+    }
+    this.modelsByAuthType.set(authType, modelMap);
+  }
+  /**
+   * Get all models for a specific authType.
+   * This is used by /model command to show only relevant models.
+   */
+  getModelsForAuthType(authType) {
+    const models = this.modelsByAuthType.get(authType);
+    if (!models) return [];
+    return Array.from(models.values()).map((model) => ({
+      id: model.id,
+      label: model.name,
+      description: model.description,
+      capabilities: model.capabilities,
+      authType: model.authType,
+      isVision: model.capabilities?.vision ?? false,
+      contextWindowSize: model.generationConfig.contextWindowSize ?? tokenLimit(model.id),
+      // `modalities` is auto-filled in `resolveModelConfig`, so it is
+      // always defined on `ResolvedModelConfig` — no fallback needed here.
+      modalities: model.generationConfig.modalities,
+      baseUrl: model.baseUrl,
+      ...model.registryBaseUrl !== void 0 ? { registryBaseUrl: model.registryBaseUrl } : {},
+      envKey: model.envKey,
+      fastOnly: model.fastOnly,
+      voiceOnly: model.voiceOnly,
+      visionOnly: model.visionOnly,
+      supportsImageGeneration: model.supportsImageGeneration,
+      imageOnly: model.imageOnly
+    }));
+  }
+  /**
+   * Get model configuration by authType and modelId.
+   * When baseUrl is provided, looks up the exact composite key, then a plain
+   * entry whose resolved default baseUrl matches.
+   * When baseUrl is omitted, tries the plain id first (backward compatible),
+   * then scans all entries for the first match by model id.
+   */
+  getModel(authType, modelId, baseUrl) {
+    const models = this.modelsByAuthType.get(authType);
+    if (!models) return void 0;
+    if (baseUrl !== void 0) {
+      const exact = models.get(modelRegistryKey(modelId, baseUrl ?? void 0));
+      if (exact) return exact;
+      if (baseUrl === null) return void 0;
+      const plain2 = models.get(modelId);
+      return plain2?.baseUrl === baseUrl ? plain2 : void 0;
+    }
+    const plain = models.get(modelId);
+    if (plain) return plain;
+    for (const model of models.values()) {
+      if (model.id === modelId) return model;
+    }
+    return void 0;
+  }
+  /**
+   * Check if model exists for given authType.
+   * When baseUrl is provided, checks the exact endpoint or matching default.
+   * When baseUrl is omitted, checks plain id and scans by model id.
+   */
+  hasModel(authType, modelId, baseUrl) {
+    return this.getModel(authType, modelId, baseUrl) !== void 0;
+  }
+  /**
+   * Get default model for an authType.
+   * For qwen-oauth, returns the coder model.
+   * For others, returns the first configured primary-capable model.
+   */
+  getDefaultModelForAuthType(authType) {
+    if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
+      return this.getModel(authType, DEFAULT_QWEN_MODEL);
+    }
+    const models = this.modelsByAuthType.get(authType);
+    if (!models || models.size === 0) return void 0;
+    return Array.from(models.values()).find(
+      (model) => !model.imageOnly && !model.voiceOnly
+    );
+  }
+  /**
+   * Resolve model config by applying defaults
+   */
+  resolveModelConfig(config, authType) {
+    this.validateModelConfig(config, authType);
+    const generationConfig = { ...config.generationConfig ?? {} };
+    if (generationConfig.modalities === void 0 || shouldUseCanonicalModalities(config.id)) {
+      generationConfig.modalities = defaultModalities(config.id);
+    }
+    return {
+      ...config,
+      authType,
+      name: config.name || config.id,
+      baseUrl: config.baseUrl || this.getDefaultBaseUrl(authType),
+      ...config.baseUrl ? { registryBaseUrl: config.baseUrl } : {},
+      generationConfig,
+      capabilities: config.capabilities || {}
+    };
+  }
+  /**
+   * Validate model configuration
+   */
+  validateModelConfig(config, authType) {
+    if (!config.id) {
+      throw new Error(
+        `Model config in authType '${authType}' missing required field: id`
+      );
+    }
+    const selectorOnlyCount = [
+      config.fastOnly,
+      config.voiceOnly,
+      config.visionOnly,
+      config.imageOnly
+    ].filter(Boolean).length;
+    if (selectorOnlyCount > 1) {
+      debugLogger.warn(
+        `Model "${config.id}" in authType "${authType}" has multiple selector-only flags. It will be unreachable in at least one model selector.`
+      );
+    }
+  }
+  /**
+   * Reload models from updated configuration.
+   * Clears existing user-configured models and re-registers from new config.
+   * Preserves hard-coded qwen-oauth models.
+   *
+   * @param providerProtocolConfig - Updated provider->protocol map. `undefined`
+   *   PRESERVES the existing map (so a reload carrying only modelProviders does
+   *   not lose the mapping); any object value REPLACES it, so passing `{}`
+   *   clears the mapping. Callers that want to preserve must omit the argument,
+   *   not pass `settings.providerProtocol ?? {}`.
+   */
+  reloadModels(modelProvidersConfig, providerProtocolConfig) {
+    const reloaded = new _ModelRegistry(
+      modelProvidersConfig,
+      providerProtocolConfig ?? this.providerProtocolConfig
+    );
+    this.modelsByAuthType = reloaded.modelsByAuthType;
+    this.providerProtocolConfig = reloaded.providerProtocolConfig;
+    this.modelProvidersConfig = reloaded.modelProvidersConfig;
+  }
+  /** The raw providers config this registry was last built from. */
+  getModelProvidersConfig() {
+    return this.modelProvidersConfig;
+  }
+  getProviderProtocolConfig() {
+    return this.providerProtocolConfig;
+  }
+};
+
+// packages/core/src/models/modelsConfig.ts
+init_esbuild_shims();
+import process from "node:process";
+var debugLogger2 = createDebugLogger("ModelsConfig");
+var ModelsConfig = class _ModelsConfig {
+  static {
+    __name(this, "ModelsConfig");
+  }
+  modelRegistry;
+  // Current selection state
+  currentAuthType;
+  currentRegistryBaseUrl;
+  // 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 = /* @__PURE__ */ 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,
+      options.providerProtocolConfig
+    );
+    this.onModelChange = options.onModelChange;
+    this._generationConfig = {
+      ...options.generationConfig || {}
+    };
+    this.generationConfigSources = options.generationConfigSources || {};
+    this.authTypeWasExplicitlyProvided = options.initialAuthType !== void 0;
+    this.currentAuthType = options.initialAuthType;
+    const initialModelId = this._generationConfig.model;
+    if (this.currentAuthType && initialModelId) {
+      const initialModel = this.modelRegistry.getModel(
+        this.currentAuthType,
+        initialModelId,
+        options.initialRegistryBaseUrl
+      );
+      if (initialModel) {
+        this.currentRegistryBaseUrl = initialModel.registryBaseUrl ?? null;
+      }
+    }
+  }
+  /**
+   * 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,
+      currentRegistryBaseUrl: this.currentRegistryBaseUrl
+    };
+  }
+  /**
+   * 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;
+    this.currentRegistryBaseUrl = snapshot.currentRegistryBaseUrl;
+  }
+  /**
+   * Get current model ID
+   */
+  getModel() {
+    return this._generationConfig.model || DEFAULT_QWEN_MODEL;
+  }
+  /**
+   * Get current authType
+   */
+  getCurrentAuthType() {
+    return this.currentAuthType;
+  }
+  getCurrentRegistryBaseUrl() {
+    return this.currentRegistryBaseUrl;
+  }
+  /**
+   * 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);
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueAuthTypes = [];
+    for (const authType of inputAuthTypes) {
+      if (!seen.has(authType)) {
+        seen.add(authType);
+        uniqueAuthTypes.push(authType);
+      }
+    }
+    const orderedAuthTypes = [];
+    if (uniqueAuthTypes.includes("qwen-oauth" /* QWEN_OAUTH */)) {
+      orderedAuthTypes.push("qwen-oauth" /* QWEN_OAUTH */);
+    }
+    for (const authType of uniqueAuthTypes) {
+      if (authType !== "qwen-oauth" /* QWEN_OAUTH */) {
+        orderedAuthTypes.push(authType);
+      }
+    }
+    const runtimeOption = this.getRuntimeModelOption();
+    const allModels = [];
+    for (const authType of orderedAuthTypes) {
+      if (runtimeOption && runtimeOption.authType === authType) {
+        allModels.push(runtimeOption);
+      }
+      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);
+  }
+  /**
+   * Get a fully resolved provider model config for the given authType/modelId.
+   * Returns undefined for raw runtime models that are not present in the registry.
+   */
+  getResolvedModel(authType, modelId, baseUrl) {
+    return this.modelRegistry.getModel(authType, modelId, baseUrl);
+  }
+  /**
+   * Get the display name for a model by its id.
+   * Looks up the model in the registry using the current authType and returns
+   * its resolved name. Falls back to the raw model id when the model is not
+   * found in the registry (e.g. runtime models or unknown models).
+   */
+  getModelDisplayName(modelId) {
+    if (!this.currentAuthType) return modelId;
+    const resolved = (this.currentRegistryBaseUrl !== void 0 ? this.modelRegistry.getModel(
+      this.currentAuthType,
+      modelId,
+      this.currentRegistryBaseUrl
+    ) : void 0) ?? this.modelRegistry.getModel(this.currentAuthType, modelId);
+    return resolved?.name ?? modelId;
+  }
+  /**
+   * Set model programmatically (e.g., VLM auto-switch, fallback).
+   * Supports both registry models and raw model IDs.
+   */
+  async setModel(newModel, metadata) {
+    if (this.currentAuthType === "qwen-oauth" /* QWEN_OAUTH */ && newModel === DEFAULT_QWEN_MODEL) {
+      this.strictModelProviderSelection = false;
+      this.currentRegistryBaseUrl = void 0;
+      this._generationConfig.model = newModel;
+      this.generationConfigSources["model"] = {
+        kind: "programmatic",
+        detail: metadata?.reason || "setModel"
+      };
+      this.applyRawModelDerivedDefaults(newModel);
+      if (this.onModelChange) {
+        await this.onModelChange("qwen-oauth" /* QWEN_OAUTH */, false);
+      }
+      return;
+    }
+    if (this.currentAuthType && this.modelRegistry.hasModel(this.currentAuthType, newModel)) {
+      await this.switchModel(this.currentAuthType, newModel);
+      return;
+    }
+    const rollbackSnapshot = this.createStateSnapshotForRollback();
+    try {
+      this.strictModelProviderSelection = false;
+      this.currentRegistryBaseUrl = void 0;
+      this._generationConfig.model = newModel;
+      this.generationConfigSources["model"] = {
+        kind: "programmatic",
+        detail: metadata?.reason || "setModel"
+      };
+      this.applyRawModelDerivedDefaults(newModel);
+      if (this.onModelChange && this.currentAuthType) {
+        await this.onModelChange(this.currentAuthType, true);
+      }
+    } catch (error) {
+      this.rollbackToStateSnapshot(rollbackSnapshot);
+      throw error;
+    }
+  }
+  /**
+   * Raw model switches keep the current credentials, but model-derived
+   * generation defaults must follow the new model. Otherwise a switch from a
+   * multimodal registry model to a text-only raw model can keep stale image
+   * support and send unsupported inline media.
+   */
+  applyRawModelDerivedDefaults(modelId) {
+    if (this.shouldUpdateModelDerivedDefault("modalities")) {
+      this._generationConfig.modalities = defaultModalities(modelId);
+      this.generationConfigSources["modalities"] = {
+        kind: "computed",
+        detail: "auto-detected from model"
+      };
+    }
+    if (this.shouldUpdateModelDerivedDefault("contextWindowSize")) {
+      this._generationConfig.contextWindowSize = tokenLimit(modelId, "input");
+      this.generationConfigSources["contextWindowSize"] = {
+        kind: "computed",
+        detail: "auto-detected from model"
+      };
+    }
+  }
+  shouldUpdateModelDerivedDefault(field) {
+    const source = this.generationConfigSources[field];
+    return source === void 0 || source.kind === "computed" || source.kind === "default" || source.kind === "modelProviders" || source.kind === "programmatic" || source.kind === "unknown";
+  }
+  /**
+   * 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) {
+    const runtimeModelSnapshotId = this.extractRuntimeModelSnapshotId(modelId);
+    if (runtimeModelSnapshotId) {
+      await this.switchToRuntimeModel(runtimeModelSnapshotId);
+      return;
+    }
+    const rollbackSnapshot = this.createStateSnapshotForRollback();
+    if (authType === "qwen-oauth" /* QWEN_OAUTH */ && options?.requireCachedCredentials) {
+      this.requireCachedQwenCredentialsOnce = true;
+    }
+    try {
+      const isAuthTypeChange = authType !== this.currentAuthType;
+      this.currentAuthType = authType;
+      const model = this.modelRegistry.getModel(
+        authType,
+        modelId,
+        options?.baseUrl
+      );
+      if (!model) {
+        throw new Error(
+          `Model '${modelId}' not found for authType '${authType}'`
+        );
+      }
+      if (model.imageOnly || model.voiceOnly) {
+        throw new Error(
+          `${model.imageOnly ? "Image" : "Voice"}-only model '${modelId}' cannot be used as the primary model`
+        );
+      }
+      const previousModelId = rollbackSnapshot.generationConfig.model || "";
+      const previousModel = !isAuthTypeChange && previousModelId ? this.modelRegistry.getModel(
+        authType,
+        previousModelId,
+        rollbackSnapshot.currentRegistryBaseUrl
+      ) ?? this.modelRegistry.getModel(authType, previousModelId) : void 0;
+      const canReusePreviousApiKey = authType !== "qwen-oauth" /* QWEN_OAUTH */ && !isAuthTypeChange && !!rollbackSnapshot.generationConfig.apiKey && !!model.envKey && previousModel?.envKey === model.envKey && previousModel.baseUrl === model.baseUrl;
+      const previousApiKey = canReusePreviousApiKey ? rollbackSnapshot.generationConfig.apiKey : void 0;
+      const previousApiKeySource = canReusePreviousApiKey ? rollbackSnapshot.generationConfigSources["apiKey"] : void 0;
+      this.applyResolvedModelDefaults(model);
+      if (!this._generationConfig.apiKey && previousApiKey) {
+        this._generationConfig.apiKey = previousApiKey;
+        if (previousApiKeySource) {
+          this.generationConfigSources["apiKey"] = _ModelsConfig.deepClone(previousApiKeySource);
+        }
+      }
+      this.activeRuntimeModelSnapshotId = void 0;
+      const requiresRefresh = isAuthTypeChange ? true : this.checkRequiresRefresh(previousModelId);
+      if (this.onModelChange) {
+        await this.onModelChange(authType, requiresRefresh);
+      }
+    } catch (error) {
+      this.rollbackToStateSnapshot(rollbackSnapshot);
+      throw error;
+    }
+  }
+  /**
+   * 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 buildRuntimeSnapshotId(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) {
+    if (modelId.startsWith(RUNTIME_SNAPSHOT_PREFIX)) {
+      if (this.runtimeModelSnapshots.has(modelId)) {
+        return modelId;
+      }
+      return void 0;
+    }
+    if (this.runtimeModelSnapshots.has(modelId)) {
+      return modelId;
+    }
+    return void 0;
+  }
+  /**
+   * 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) {
+        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 (credentials.apiKey || credentials.baseUrl || credentials.model) {
+      this.hasManualCredentials = true;
+      this.currentRegistryBaseUrl = void 0;
+      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"
+      };
+    }
+    this.strictModelProviderSelection = false;
+    this._generationConfig.apiKeyEnvKey = void 0;
+    if (settingsGenerationConfig) {
+      this.mergeSettingsGenerationConfig(settingsGenerationConfig);
+    }
+    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;
+    if (!model || !currentAuthType || !apiKey || !baseUrl) {
+      return;
+    }
+    if (this.modelRegistry.hasModel(currentAuthType, model, baseUrl)) {
+      return;
+    }
+    if (this.activeRuntimeModelSnapshotId && this.runtimeModelSnapshots.has(this.activeRuntimeModelSnapshotId)) {
+      const snapshot = this.runtimeModelSnapshots.get(
+        this.activeRuntimeModelSnapshotId
+      );
+      snapshot.apiKey = apiKey;
+      snapshot.baseUrl = baseUrl;
+      snapshot.modelId = model;
+      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 {
+      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") {
+        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;
+    this.currentRegistryBaseUrl = model.registryBaseUrl ?? null;
+    this.hasManualCredentials = false;
+    this._generationConfig.model = model.id;
+    this.generationConfigSources["model"] = {
+      kind: "modelProviders",
+      authType: model.authType,
+      modelId: model.id,
+      detail: "model.id"
+    };
+    if (this.currentAuthType === "qwen-oauth" /* QWEN_OAUTH */) {
+      this._generationConfig.apiKey = "QWEN_OAUTH_DYNAMIC_TOKEN";
+      this.generationConfigSources["apiKey"] = {
+        kind: "computed",
+        detail: "Qwen OAuth placeholder token"
+      };
+      this._generationConfig.apiKeyEnvKey = void 0;
+      delete this.generationConfigSources["apiKeyEnvKey"];
+    } else {
+      this._generationConfig.apiKey = void 0;
+      this._generationConfig.apiKeyEnvKey = void 0;
+    }
+    if (model.envKey !== void 0) {
+      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"
+          }
+        };
+      } else {
+        debugLogger2.debug(
+          `No API key found for model "${model.id}": process.env["${model.envKey}"] is ${apiKey === "" ? "empty string" : "not set"}. Run /auth or set ${model.envKey} in your environment.`
+        );
+      }
+      this._generationConfig.apiKeyEnvKey = model.envKey;
+      this.generationConfigSources["apiKeyEnvKey"] = {
+        kind: "modelProviders",
+        authType: model.authType,
+        modelId: model.id,
+        detail: "envKey"
+      };
+    }
+    this._generationConfig.baseUrl = model.baseUrl;
+    this.generationConfigSources["baseUrl"] = {
+      kind: "modelProviders",
+      authType: model.authType,
+      modelId: model.id,
+      detail: "baseUrl"
+    };
+    const gc = model.generationConfig;
+    for (const field of MODEL_GENERATION_CONFIG_FIELDS) {
+      this._generationConfig[field] = gc[field];
+      this.generationConfigSources[field] = {
+        kind: "modelProviders",
+        authType: model.authType,
+        modelId: model.id,
+        detail: `generationConfig.${field}`
+      };
+    }
+    if (gc.contextWindowSize === void 0) {
+      this._generationConfig.contextWindowSize = tokenLimit(model.id, "input");
+      this.generationConfigSources["contextWindowSize"] = {
+        kind: "computed",
+        detail: "auto-detected from model"
+      };
+    }
+    if (gc.modalities === void 0) {
+      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) {
+    const authType = this.currentAuthType;
+    if (!authType) {
+      return true;
+    }
+    if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
+      return false;
+    }
+    const currentModel = this.modelRegistry.getModel(
+      authType,
+      this._generationConfig.model || "",
+      this._generationConfig.baseUrl || void 0
+    );
+    const previousModel = this.modelRegistry.getModel(
+      authType,
+      previousModelId
+    );
+    if (!previousModel || !currentModel) {
+      return true;
+    }
+    const criticalFieldsChanged = previousModel.envKey !== currentModel.envKey || previousModel.baseUrl !== currentModel.baseUrl;
+    if (criticalFieldsChanged) {
+      return true;
+    }
+    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, providerBaseUrlOverride) {
+    const previousAuthType = this.currentAuthType;
+    const providerBaseUrl = providerBaseUrlOverride ?? (previousAuthType === authType && this.currentRegistryBaseUrl !== void 0 ? this.currentRegistryBaseUrl : this.generationConfigSources["baseUrl"]?.kind === "modelProviders" ? this._generationConfig.baseUrl : void 0);
+    const resolved = modelId ? this.modelRegistry.getModel(authType, modelId, providerBaseUrl) ?? this.modelRegistry.getModel(authType, modelId) : void 0;
+    if (resolved?.imageOnly || resolved?.voiceOnly) {
+      throw new Error(
+        `${resolved.imageOnly ? "Image" : "Voice"}-only model '${modelId}' cannot be used as the primary model`
+      );
+    }
+    this.strictModelProviderSelection = false;
+    this.currentAuthType = authType;
+    if (resolved) {
+      const hasBeenApplied = this.generationConfigSources["baseUrl"]?.kind === "modelProviders";
+      const isProviderChanged = hasBeenApplied && (this._generationConfig.apiKeyEnvKey !== resolved.envKey || this._generationConfig.baseUrl !== resolved.baseUrl);
+      const isUnchanged = previousAuthType === authType && this._generationConfig.model === modelId && !isProviderChanged;
+      const savedApiKey = isUnchanged ? this._generationConfig.apiKey : void 0;
+      const savedApiKeySource = isUnchanged ? this.generationConfigSources["apiKey"] ? { ...this.generationConfigSources["apiKey"] } : void 0 : void 0;
+      const baseUrlSource2 = this.generationConfigSources["baseUrl"];
+      const shouldPreserveResolvedBaseUrl = isUnchanged && !!this._generationConfig.baseUrl && (baseUrlSource2?.kind === "cli" || baseUrlSource2?.kind === "env" || baseUrlSource2?.kind === "settings");
+      const savedBaseUrl = shouldPreserveResolvedBaseUrl ? this._generationConfig.baseUrl : void 0;
+      const savedBaseUrlSource = shouldPreserveResolvedBaseUrl ? baseUrlSource2 ? { ...baseUrlSource2 } : void 0 : void 0;
+      this.applyResolvedModelDefaults(resolved);
+      if (isUnchanged && !this._generationConfig.apiKey && savedApiKey) {
+        this._generationConfig.apiKey = savedApiKey;
+        if (savedApiKeySource) {
+          this.generationConfigSources["apiKey"] = savedApiKeySource;
+        }
+      }
+      if (savedBaseUrl) {
+        this._generationConfig.baseUrl = savedBaseUrl;
+        if (savedBaseUrlSource) {
+          this.generationConfigSources["baseUrl"] = savedBaseUrlSource;
+        }
+      }
+      this.strictModelProviderSelection = true;
+      this.activeRuntimeModelSnapshotId = void 0;
+      return;
+    }
+    const apiKeySource = this.generationConfigSources["apiKey"];
+    const baseUrlSource = this.generationConfigSources["baseUrl"];
+    const hasExistingCredentials = this._generationConfig.apiKey && apiKeySource?.kind !== "modelProviders" || this._generationConfig.baseUrl && baseUrlSource?.kind !== "modelProviders";
+    const isAuthTypeChange = previousAuthType !== authType;
+    const shouldPreserveCredentials = !isAuthTypeChange && (modelId === void 0 || !this.modelRegistry.hasModel(authType, modelId)) && (this.hasManualCredentials || hasExistingCredentials);
+    if (shouldPreserveCredentials) {
+      this.currentRegistryBaseUrl = void 0;
+      if (modelId) {
+        this._generationConfig.model = modelId;
+        if (!this.generationConfigSources["model"]) {
+          this.generationConfigSources["model"] = {
+            kind: "programmatic",
+            detail: "auth refresh (preserved credentials)"
+          };
+        }
+      }
+      return;
+    }
+    const defaultModel = this.modelRegistry.getDefaultModelForAuthType(authType);
+    if (defaultModel) {
+      this.applyResolvedModelDefaults(defaultModel);
+      this.activeRuntimeModelSnapshotId = void 0;
+      return;
+    }
+    if (modelId) {
+      this.currentRegistryBaseUrl = void 0;
+      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 void 0;
+    }
+    if (this.modelRegistry.hasModel(currentAuthType, currentModel, baseUrl)) {
+      this.clearRuntimeModelSnapshotForAuthType(currentAuthType);
+      return void 0;
+    }
+    const hasValidCredentials = this._generationConfig.apiKey && this._generationConfig.baseUrl;
+    if (!hasValidCredentials) {
+      return void 0;
+    }
+    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;
+    this.currentRegistryBaseUrl = void 0;
+    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 void 0;
+    }
+    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;
+      this.currentRegistryBaseUrl = void 0;
+      this.strictModelProviderSelection = false;
+      this.hasManualCredentials = true;
+      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;
+      }
+      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 void 0;
+    }
+    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 = void 0;
+        }
+      }
+    }
+  }
+  /**
+   * 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 = /* @__PURE__ */ 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);
+    }
+    if (this.activeRuntimeModelSnapshotId && !this.runtimeModelSnapshots.has(this.activeRuntimeModelSnapshotId)) {
+      this.activeRuntimeModelSnapshotId = void 0;
+    }
+  }
+  /**
+   * Reload model providers configuration at runtime.
+   * This enables hot-reloading of modelProviders settings without restarting the CLI.
+   *
+   * @param modelProvidersConfig - The updated model providers configuration
+   * @param providerProtocolConfig - Updated provider->protocol map; `undefined`
+   *   preserves the existing map (see {@link ModelRegistry.reloadModels}).
+   */
+  reloadModelProvidersConfig(modelProvidersConfig, providerProtocolConfig) {
+    this.modelRegistry.reloadModels(
+      modelProvidersConfig,
+      providerProtocolConfig
+    );
+  }
+  /** The raw providers config the registry was last built from. */
+  getModelProvidersConfig() {
+    return this.modelRegistry.getModelProvidersConfig();
+  }
+  getProviderProtocolConfig() {
+    return this.modelRegistry.getProviderProtocolConfig();
+  }
+};
+
+export {
+  RUNTIME_SNAPSHOT_PREFIX,
+  buildRuntimeSnapshotId,
+  stripRuntimeSnapshotPrefix,
+  resolveModelId,
+  buildModelIdContext,
+  isImageGenerationCapable,
+  resolveProviderProtocol,
+  ModelsConfig
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */