@within-7/minto 0.4.1 → 0.4.3

package/dist/utils/model.js

@@ -1,846 +0,0 @@
-import {
-  getGlobalConfig,
-  saveGlobalConfig
-} from "./config.js";
-const USE_BEDROCK = !!process.env.CLAUDE_CODE_USE_BEDROCK;
-const USE_VERTEX = !!process.env.CLAUDE_CODE_USE_VERTEX;
-const DEFAULT_MODEL_CONFIG = {
-  bedrock: "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
-  vertex: "claude-3-7-sonnet@20250219",
-  firstParty: "claude-sonnet-4-20250514"
-};
-async function getModelConfig() {
-  return DEFAULT_MODEL_CONFIG;
-}
-const getSlowAndCapableModel = async () => {
-  const config = await getGlobalConfig();
-  const modelManager = new ModelManager(config);
-  const model = modelManager.getMainAgentModel();
-  if (model) {
-    return model;
-  }
-  const hasConfiguredModels = modelManager.hasConfiguredModels();
-  if (hasConfiguredModels) {
-    throw new Error(
-      "No main model configured. Please use /model to set your default model."
-    );
-  }
-  const modelConfig = await getModelConfig();
-  if (USE_BEDROCK) return modelConfig.bedrock;
-  if (USE_VERTEX) return modelConfig.vertex;
-  throw new Error(
-    "No models configured. Please run /model to add and configure your AI models."
-  );
-};
-function getModelContextLength(pointerType = "main") {
-  const config = getGlobalConfig();
-  const modelManager = getModelManager();
-  let modelName = null;
-  switch (pointerType) {
-    case "main":
-      modelName = modelManager.getMainAgentModel();
-      break;
-    case "task":
-      modelName = modelManager.getTaskToolModel();
-      break;
-    default:
-      modelName = modelManager.getMainAgentModel();
-  }
-  if (modelName) {
-    const profile = config.modelProfiles?.find(
-      (p) => p.modelName === modelName && p.isActive
-    );
-    if (profile && profile.contextLength) {
-      return profile.contextLength;
-    }
-  }
-  return 2e5;
-}
-async function isDefaultSlowAndCapableModel() {
-  try {
-    const configuredModel = await getSlowAndCapableModel();
-    return !process.env.ANTHROPIC_MODEL || process.env.ANTHROPIC_MODEL === configuredModel;
-  } catch {
-    return !process.env.ANTHROPIC_MODEL;
-  }
-}
-function getVertexRegionForModel(model) {
-  if (model?.startsWith("claude-3-5-haiku")) {
-    return process.env.VERTEX_REGION_CLAUDE_3_5_HAIKU;
-  } else if (model?.startsWith("claude-3-5-sonnet")) {
-    return process.env.VERTEX_REGION_CLAUDE_3_5_SONNET;
-  } else if (model?.startsWith("claude-3-7-sonnet")) {
-    return process.env.VERTEX_REGION_CLAUDE_3_7_SONNET;
-  }
-  return void 0;
-}
-class ModelManager {
-  config;
-  // Using any to handle legacy properties
-  modelProfiles;
-  constructor(config) {
-    this.config = config;
-    this.modelProfiles = config.modelProfiles || [];
-  }
-  /**
-   * Get the current terminal model (for interactive CLI sessions)
-   */
-  getCurrentModel() {
-    const mainModelName = this.config.modelPointers?.main;
-    if (mainModelName) {
-      const profile = this.findModelProfile(mainModelName);
-      if (profile && profile.isActive) {
-        return profile.modelName;
-      }
-    }
-    return this.getMainAgentModel();
-  }
-  /**
-   * Get the main agent default model (for non-terminal mode and MCP calls)
-   */
-  getMainAgentModel() {
-    const mainModelName = this.config.modelPointers?.main;
-    if (mainModelName) {
-      const profile = this.findModelProfile(mainModelName);
-      if (profile && profile.isActive) {
-        return profile.modelName;
-      }
-    }
-    const activeProfile = this.modelProfiles.find((p) => p.isActive);
-    if (activeProfile) {
-      return activeProfile.modelName;
-    }
-    return null;
-  }
-  /**
-   * Get the task tool default model (for Task tool sub-agents)
-   */
-  getTaskToolModel() {
-    const taskModelName = this.config.modelPointers?.task;
-    if (taskModelName) {
-      const profile = this.findModelProfile(taskModelName);
-      if (profile && profile.isActive) {
-        return profile.modelName;
-      }
-    }
-    return this.getMainAgentModel();
-  }
-  /**
-   * Switch to the next available model with enhanced context overflow handling
-   * If target model can't handle current context, shows warning and reverts after delay
-   *
-   * @param currentContextTokens - Current conversation token count for validation
-   * @returns Object with detailed model name and context status information
-   */
-  switchToNextModelWithContextCheck(currentContextTokens = 0) {
-    const allProfiles = this.getAllConfiguredModels();
-    if (allProfiles.length === 0) {
-      return {
-        success: false,
-        modelName: null,
-        previousModelName: null,
-        contextOverflow: false,
-        usagePercentage: 0,
-        currentContextTokens,
-        targetContextLimit: 0,
-        skippedModels: [],
-        totalAvailableModels: 0
-      };
-    }
-    allProfiles.sort((a, b) => {
-      return a.createdAt - b.createdAt;
-    });
-    const currentMainModelName = this.config.modelPointers?.main;
-    const currentModel = currentMainModelName ? this.findModelProfile(currentMainModelName) : null;
-    const previousModelName = currentModel?.name || null;
-    if (!currentMainModelName) {
-      const firstModel = allProfiles[0];
-      if (!firstModel.isActive) {
-        firstModel.isActive = true;
-      }
-      this.setPointer("main", firstModel.modelName);
-      this.updateLastUsed(firstModel.modelName);
-      const analysis2 = this.analyzeContextCompatibility(
-        firstModel,
-        currentContextTokens
-      );
-      return {
-        success: true,
-        modelName: firstModel.name,
-        previousModelName: null,
-        contextOverflow: !analysis2.compatible,
-        usagePercentage: analysis2.usagePercentage,
-        currentContextTokens,
-        targetContextLimit: firstModel.contextLength,
-        skippedModels: [],
-        totalAvailableModels: allProfiles.length
-      };
-    }
-    const currentIndex = allProfiles.findIndex(
-      (p) => p.modelName === currentMainModelName
-    );
-    if (currentIndex === -1) {
-      const firstModel = allProfiles[0];
-      if (!firstModel.isActive) {
-        firstModel.isActive = true;
-      }
-      this.setPointer("main", firstModel.modelName);
-      this.updateLastUsed(firstModel.modelName);
-      const analysis2 = this.analyzeContextCompatibility(
-        firstModel,
-        currentContextTokens
-      );
-      return {
-        success: true,
-        modelName: firstModel.name,
-        previousModelName,
-        contextOverflow: !analysis2.compatible,
-        usagePercentage: analysis2.usagePercentage,
-        currentContextTokens,
-        targetContextLimit: firstModel.contextLength,
-        skippedModels: [],
-        totalAvailableModels: allProfiles.length
-      };
-    }
-    if (allProfiles.length === 1) {
-      const currentModel2 = allProfiles[0];
-      return {
-        success: false,
-        modelName: null,
-        previousModelName,
-        contextOverflow: false,
-        usagePercentage: 0,
-        currentContextTokens,
-        targetContextLimit: currentModel2?.contextLength || 0,
-        skippedModels: [],
-        totalAvailableModels: 1
-      };
-    }
-    const nextIndex = (currentIndex + 1) % allProfiles.length;
-    const nextModel = allProfiles[nextIndex];
-    const wasInactive = !nextModel.isActive;
-    if (!nextModel.isActive) {
-      nextModel.isActive = true;
-    }
-    const analysis = this.analyzeContextCompatibility(
-      nextModel,
-      currentContextTokens
-    );
-    this.setPointer("main", nextModel.modelName);
-    this.updateLastUsed(nextModel.modelName);
-    if (wasInactive) {
-      this.saveConfig();
-    }
-    return {
-      success: true,
-      modelName: nextModel.name,
-      previousModelName,
-      contextOverflow: !analysis.compatible,
-      usagePercentage: analysis.usagePercentage,
-      currentContextTokens,
-      targetContextLimit: nextModel.contextLength,
-      skippedModels: [],
-      // In simple round-robin, no models are skipped
-      totalAvailableModels: allProfiles.length
-    };
-  }
-  /**
-   * Simple model switching for UI components (compatible interface)
-   * @param currentContextTokens - Current conversation token count for validation
-   * @returns Compatible interface for PromptInput component
-   */
-  switchToNextModel(currentContextTokens = 0) {
-    const result = this.switchToNextModelWithContextCheck(currentContextTokens);
-    if (!result.success) {
-      const allModels2 = this.getAllConfiguredModels();
-      if (allModels2.length === 0) {
-        return {
-          success: false,
-          modelName: null,
-          blocked: false,
-          message: "\u274C No models configured. Use /model to add models."
-        };
-      } else if (allModels2.length === 1) {
-        return {
-          success: false,
-          modelName: null,
-          blocked: false,
-          message: `\u26A0\uFE0F Only one model configured (${allModels2[0].modelName}). Use /model to add more models for switching.`
-        };
-      }
-    }
-    const currentModel = this.findModelProfile(this.config.modelPointers?.main);
-    const allModels = this.getAllConfiguredModels();
-    const currentIndex = allModels.findIndex(
-      (m) => m.modelName === currentModel?.modelName
-    );
-    const totalModels = allModels.length;
-    return {
-      success: result.success,
-      modelName: result.modelName,
-      blocked: result.contextOverflow,
-      message: result.success ? result.contextOverflow ? `\u26A0\uFE0F Context usage: ${result.usagePercentage.toFixed(1)}% - ${result.modelName}` : `\u2705 Switched to ${result.modelName} (${currentIndex + 1}/${totalModels})${currentModel?.provider ? ` [${currentModel.provider}]` : ""}` : `\u274C Failed to switch models`
-    };
-  }
-  /**
-   * Revert to previous model (used when context overflow requires rollback)
-   */
-  revertToPreviousModel(previousModelName) {
-    const previousModel = this.modelProfiles.find(
-      (p) => p.name === previousModelName && p.isActive
-    );
-    if (!previousModel) {
-      return false;
-    }
-    this.setPointer("main", previousModel.modelName);
-    this.updateLastUsed(previousModel.modelName);
-    return true;
-  }
-  /**
-   * Enhanced context validation with different severity levels
-   */
-  analyzeContextCompatibility(model, contextTokens) {
-    const usableContext = Math.floor(model.contextLength * 0.8);
-    const usagePercentage = contextTokens / usableContext * 100;
-    if (usagePercentage <= 70) {
-      return {
-        compatible: true,
-        severity: "safe",
-        usagePercentage,
-        recommendation: "Full context preserved"
-      };
-    } else if (usagePercentage <= 90) {
-      return {
-        compatible: true,
-        severity: "warning",
-        usagePercentage,
-        recommendation: "Context usage high, consider compression"
-      };
-    } else {
-      return {
-        compatible: false,
-        severity: "critical",
-        usagePercentage,
-        recommendation: "Auto-compression or message truncation required"
-      };
-    }
-  }
-  /**
-   * Switch to next model with enhanced context analysis
-   */
-  switchToNextModelWithAnalysis(currentContextTokens = 0) {
-    const result = this.switchToNextModel(currentContextTokens);
-    if (!result.success || !result.modelName) {
-      return {
-        modelName: null,
-        contextAnalysis: null,
-        requiresCompression: false,
-        estimatedTokensAfterSwitch: 0
-      };
-    }
-    const newModel = this.getModel("main");
-    if (!newModel) {
-      return {
-        modelName: result.modelName,
-        contextAnalysis: null,
-        requiresCompression: false,
-        estimatedTokensAfterSwitch: currentContextTokens
-      };
-    }
-    const analysis = this.analyzeContextCompatibility(
-      newModel,
-      currentContextTokens
-    );
-    return {
-      modelName: result.modelName,
-      contextAnalysis: analysis,
-      requiresCompression: analysis.severity === "critical",
-      estimatedTokensAfterSwitch: currentContextTokens
-    };
-  }
-  /**
-   * Check if a model can handle the given context size (legacy method)
-   */
-  canModelHandleContext(model, contextTokens) {
-    const analysis = this.analyzeContextCompatibility(model, contextTokens);
-    return analysis.compatible;
-  }
-  /**
-   * Find the first model that can handle the given context size
-   */
-  findModelWithSufficientContext(models, contextTokens) {
-    return models.find((model) => this.canModelHandleContext(model, contextTokens)) || null;
-  }
-  /**
-   * Unified model getter for different contexts
-   */
-  getModelForContext(contextType) {
-    switch (contextType) {
-      case "terminal":
-        return this.getCurrentModel();
-      case "main-agent":
-        return this.getMainAgentModel();
-      case "task-tool":
-        return this.getTaskToolModel();
-      default:
-        return this.getMainAgentModel();
-    }
-  }
-  /**
-   * Get all active model profiles
-   */
-  getActiveModelProfiles() {
-    return this.modelProfiles.filter((p) => p.isActive);
-  }
-  /**
-   * Check if any models are configured
-   */
-  hasConfiguredModels() {
-    return this.getActiveModelProfiles().length > 0;
-  }
-  // New model pointer system methods
-  /**
-   * Get model by pointer type (main, task, reasoning, quick)
-   */
-  getModel(pointer) {
-    const pointerId = this.config.modelPointers?.[pointer];
-    if (!pointerId) {
-      return this.getDefaultModel();
-    }
-    const profile = this.findModelProfile(pointerId);
-    return profile && profile.isActive ? profile : this.getDefaultModel();
-  }
-  /**
-   * Get model name by pointer type
-   */
-  getModelName(pointer) {
-    const profile = this.getModel(pointer);
-    return profile ? profile.modelName : null;
-  }
-  /**
-   * Get reasoning model (with fallback)
-   */
-  getReasoningModel() {
-    return this.getModelName("reasoning") || this.getModelName("main");
-  }
-  /**
-   * Get quick model (with fallback)
-   */
-  getQuickModel() {
-    return this.getModelName("quick") || this.getModelName("task") || this.getModelName("main");
-  }
-  /**
-   * Get compact model for context compression/summarization (with fallback)
-   * Fallback chain: compact -> quick -> task -> main
-   */
-  getCompactModel() {
-    return this.getModelName("compact") || this.getModelName("quick") || this.getModelName("task") || this.getModelName("main");
-  }
-  /**
-   * Add a new model profile with duplicate validation
-   */
-  async addModel(config) {
-    const existingByModelName = this.modelProfiles.find(
-      (p) => p.modelName === config.modelName
-    );
-    if (existingByModelName) {
-      throw new Error(
-        `Model with modelName '${config.modelName}' already exists: ${existingByModelName.name}`
-      );
-    }
-    const existingByName = this.modelProfiles.find((p) => p.name === config.name);
-    if (existingByName) {
-      throw new Error(`Model with name '${config.name}' already exists`);
-    }
-    const newModel = {
-      ...config,
-      createdAt: Date.now(),
-      isActive: true
-    };
-    this.modelProfiles.push(newModel);
-    if (this.modelProfiles.length === 1) {
-      this.config.modelPointers = {
-        main: config.modelName,
-        task: config.modelName,
-        reasoning: config.modelName,
-        quick: config.modelName,
-        compact: config.modelName
-      };
-      this.config.defaultModelName = config.modelName;
-    }
-    this.saveConfig();
-    return config.modelName;
-  }
-  /**
-   * Set model pointer assignment
-   */
-  setPointer(pointer, modelName) {
-    if (!this.findModelProfile(modelName)) {
-      throw new Error(`Model '${modelName}' not found`);
-    }
-    if (!this.config.modelPointers) {
-      this.config.modelPointers = {
-        main: "",
-        task: "",
-        reasoning: "",
-        quick: "",
-        compact: ""
-      };
-    }
-    this.config.modelPointers[pointer] = modelName;
-    this.saveConfig();
-  }
-  /**
-   * Get all active models for pointer assignment
-   */
-  getAvailableModels() {
-    return this.modelProfiles.filter((p) => p.isActive);
-  }
-  /**
-   * Get all configured models (both active and inactive) for switching
-   */
-  getAllConfiguredModels() {
-    return this.modelProfiles;
-  }
-  /**
-   * Get all available model names (modelName field) - active only
-   */
-  getAllAvailableModelNames() {
-    return this.getAvailableModels().map((p) => p.modelName);
-  }
-  /**
-   * Get all configured model names (both active and inactive)
-   */
-  getAllConfiguredModelNames() {
-    return this.getAllConfiguredModels().map((p) => p.modelName);
-  }
-  /**
-   * Debug method to get detailed model switching information
-   */
-  getModelSwitchingDebugInfo() {
-    const availableModels = this.getAvailableModels();
-    const currentMainModelName = this.config.modelPointers?.main;
-    return {
-      totalModels: this.modelProfiles.length,
-      activeModels: availableModels.length,
-      inactiveModels: this.modelProfiles.length - availableModels.length,
-      currentMainModel: currentMainModelName || null,
-      availableModels: this.modelProfiles.map((p) => ({
-        name: p.name,
-        modelName: p.modelName,
-        provider: p.provider,
-        isActive: p.isActive,
-        lastUsed: p.lastUsed
-      })),
-      modelPointers: this.config.modelPointers || {}
-    };
-  }
-  /**
-   * Update an existing model profile
-   * modelName is the primary key and cannot be changed
-   */
-  updateModel(modelName, updates) {
-    const profile = this.findModelProfile(modelName);
-    if (!profile) {
-      throw new Error(`Model '${modelName}' not found`);
-    }
-    if (updates.name && updates.name !== profile.name) {
-      const existingByName = this.modelProfiles.find(
-        (p) => p.name === updates.name && p.modelName !== modelName
-      );
-      if (existingByName) {
-        throw new Error(`Model with name '${updates.name}' already exists`);
-      }
-    }
-    Object.assign(profile, updates);
-    this.saveConfig();
-  }
-  /**
-   * Remove a model profile
-   */
-  removeModel(modelName) {
-    this.modelProfiles = this.modelProfiles.filter(
-      (p) => p.modelName !== modelName
-    );
-    if (this.config.modelPointers) {
-      Object.keys(this.config.modelPointers).forEach((pointer) => {
-        if (this.config.modelPointers[pointer] === modelName) {
-          this.config.modelPointers[pointer] = this.config.defaultModelName || "";
-        }
-      });
-    }
-    this.saveConfig();
-  }
-  /**
-   * Get default model profile
-   */
-  getDefaultModel() {
-    if (this.config.defaultModelId) {
-      const profile = this.findModelProfile(this.config.defaultModelId);
-      if (profile && profile.isActive) {
-        return profile;
-      }
-    }
-    return this.modelProfiles.find((p) => p.isActive) || null;
-  }
-  /**
-   * Save configuration changes
-   * Note: This updates the global config file. The singleton instance
-   * is automatically refreshed to avoid stale data issues.
-   */
-  saveConfig() {
-    const updatedConfig = {
-      ...this.config,
-      modelProfiles: this.modelProfiles
-    };
-    saveGlobalConfig(updatedConfig);
-    refreshGlobalModelManagerInstance(this);
-  }
-  /**
-   * Get a fallback model when no specific model is configured
-   */
-  async getFallbackModel() {
-    const modelConfig = await getModelConfig();
-    if (USE_BEDROCK) return modelConfig.bedrock;
-    if (USE_VERTEX) return modelConfig.vertex;
-    return modelConfig.firstParty;
-  }
-  /**
-   * 统一的模型解析方法：支持指针、model ID 和真实模型名称
-   * @param modelParam - 可以是模型指针 ('main', 'task', etc.)、内部model ID 或真实模型名称 ('gpt-4o', 'claude-3-5-sonnet')
-   * @returns ModelProfile 或 null
-   */
-  resolveModel(modelParam) {
-    if (["main", "task", "reasoning", "quick", "compact"].includes(modelParam)) {
-      const pointerId = this.config.modelPointers?.[modelParam];
-      if (pointerId) {
-        let profile2 = this.findModelProfile(pointerId);
-        if (!profile2) {
-          profile2 = this.findModelProfileByModelName(pointerId);
-        }
-        if (profile2 && profile2.isActive) {
-          return profile2;
-        }
-      }
-      return this.getDefaultModel();
-    }
-    let profile = this.findModelProfile(modelParam);
-    if (profile && profile.isActive) {
-      return profile;
-    }
-    profile = this.findModelProfileByModelName(modelParam);
-    if (profile && profile.isActive) {
-      return profile;
-    }
-    profile = this.findModelProfileByName(modelParam);
-    if (profile && profile.isActive) {
-      return profile;
-    }
-    return this.getDefaultModel();
-  }
-  /**
-   * 解析模型参数并返回完整信息
-   */
-  resolveModelWithInfo(modelParam) {
-    const isPointer = [
-      "main",
-      "task",
-      "reasoning",
-      "quick",
-      "compact"
-    ].includes(modelParam);
-    if (isPointer) {
-      const pointerId = this.config.modelPointers?.[modelParam];
-      if (!pointerId) {
-        return {
-          success: false,
-          profile: null,
-          error: `Model pointer '${modelParam}' is not configured. Use /model to set up models.`
-        };
-      }
-      let profile = this.findModelProfile(pointerId);
-      if (!profile) {
-        profile = this.findModelProfileByModelName(pointerId);
-      }
-      if (!profile) {
-        return {
-          success: false,
-          profile: null,
-          error: `Model pointer '${modelParam}' points to invalid model '${pointerId}'. Use /model to reconfigure.`
-        };
-      }
-      if (!profile.isActive) {
-        return {
-          success: false,
-          profile: null,
-          error: `Model '${profile.name}' (pointed by '${modelParam}') is inactive. Use /model to activate it.`
-        };
-      }
-      return {
-        success: true,
-        profile
-      };
-    } else {
-      let profile = this.findModelProfile(modelParam);
-      if (!profile) {
-        profile = this.findModelProfileByModelName(modelParam);
-      }
-      if (!profile) {
-        profile = this.findModelProfileByName(modelParam);
-      }
-      if (!profile) {
-        return {
-          success: false,
-          profile: null,
-          error: `Model '${modelParam}' not found. Use /model to add models.`
-        };
-      }
-      if (!profile.isActive) {
-        return {
-          success: false,
-          profile: null,
-          error: `Model '${profile.name}' is inactive. Use /model to activate it.`
-        };
-      }
-      return {
-        success: true,
-        profile
-      };
-    }
-  }
-  // Private helper methods
-  findModelProfile(modelName) {
-    return this.modelProfiles.find((p) => p.modelName === modelName) || null;
-  }
-  /** @deprecated Use findModelProfile instead - identical implementation */
-  findModelProfileByModelName(modelName) {
-    return this.findModelProfile(modelName);
-  }
-  findModelProfileByName(name) {
-    return this.modelProfiles.find((p) => p.name === name) || null;
-  }
-  updateLastUsed(modelName) {
-    const profile = this.findModelProfile(modelName);
-    if (profile) {
-      profile.lastUsed = Date.now();
-    }
-  }
-  /**
-   * Find model profile by provider-qualified name (e.g., "openai:gpt-4o", "anthropic:claude-3-5-sonnet")
-   * @param qualifiedName - Format: "provider:modelName" or just "modelName"
-   * @returns ModelProfile or null
-   */
-  findModelByProviderQualified(qualifiedName) {
-    if (qualifiedName.includes(":")) {
-      const [provider, modelName] = qualifiedName.split(":", 2);
-      return this.modelProfiles.find(
-        (p) => p.provider.toLowerCase() === provider.toLowerCase() && (p.modelName === modelName || p.modelName.toLowerCase() === modelName.toLowerCase() || p.name.toLowerCase() === modelName.toLowerCase())
-      ) || null;
-    }
-    return this.findModelProfile(qualifiedName) || this.findModelProfileByName(qualifiedName);
-  }
-  /**
-   * Enhanced model resolution supporting provider:model format
-   * @param modelParam - Can be pointer, provider:model, modelName, or friendly name
-   * @returns ModelProfile or null
-   */
-  resolveProviderQualifiedModel(modelParam) {
-    if (modelParam.includes(":") && !["main", "task", "reasoning", "quick", "compact"].includes(
-      modelParam.split(":")[0]
-    )) {
-      const [provider, modelId] = modelParam.split(":", 2);
-      const profile2 = this.findModelByProviderQualified(modelParam);
-      return { profile: profile2, provider, modelId };
-    }
-    const profile = this.resolveModel(modelParam);
-    return { profile };
-  }
-  /**
-   * Get all models from a specific provider
-   */
-  getModelsByProvider(provider) {
-    return this.modelProfiles.filter(
-      (p) => p.provider.toLowerCase() === provider.toLowerCase()
-    );
-  }
-  /**
-   * Get list of unique providers
-   */
-  getUniqueProviders() {
-    const providers = new Set(this.modelProfiles.map((p) => p.provider));
-    return Array.from(providers);
-  }
-}
-let globalModelManager = null;
-function refreshGlobalModelManagerInstance(instance) {
-  globalModelManager = instance;
-}
-const getModelManager = () => {
-  try {
-    if (!globalModelManager) {
-      const config = getGlobalConfig();
-      if (!config) {
-        console.warn(
-          "No global config available, creating ModelManager with empty config"
-        );
-        globalModelManager = new ModelManager({
-          modelProfiles: [],
-          modelPointers: {
-            main: "",
-            task: "",
-            reasoning: "",
-            quick: "",
-            compact: ""
-          }
-        });
-      } else {
-        globalModelManager = new ModelManager(config);
-      }
-    }
-    return globalModelManager;
-  } catch (error) {
-    console.error("Error creating ModelManager:", error);
-    return new ModelManager({
-      modelProfiles: [],
-      modelPointers: {
-        main: "",
-        task: "",
-        reasoning: "",
-        quick: "",
-        compact: ""
-      }
-    });
-  }
-};
-const reloadModelManager = () => {
-  globalModelManager = null;
-  getModelManager();
-};
-const getQuickModel = () => {
-  const manager = getModelManager();
-  const quickModelName = manager.getQuickModel();
-  if (quickModelName) return quickModelName;
-  const mainModel = manager.getMainAgentModel();
-  return mainModel || "";
-};
-const getCompactModel = () => {
-  const manager = getModelManager();
-  const compactModelName = manager.getCompactModel();
-  if (compactModelName) return compactModelName;
-  const mainModel = manager.getMainAgentModel();
-  return mainModel || "";
-};
-export {
-  ModelManager,
-  USE_BEDROCK,
-  USE_VERTEX,
-  getCompactModel,
-  getModelContextLength,
-  getModelManager,
-  getQuickModel,
-  getSlowAndCapableModel,
-  getVertexRegionForModel,
-  isDefaultSlowAndCapableModel,
-  reloadModelManager
-};
-//# sourceMappingURL=model.js.map