@within-7/minto 0.0.5-dev.1

package/dist/utils/model.js

@@ -0,0 +1,677 @@
+import { memoize } from "lodash-es";
+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 = memoize(async () => {
+  const config = await getGlobalConfig();
+  const modelManager = new ModelManager(config);
+  const model = modelManager.getMainAgentModel();
+  if (model) {
+    return model;
+  }
+  const modelConfig = await getModelConfig();
+  if (USE_BEDROCK) return modelConfig.bedrock;
+  if (USE_VERTEX) return modelConfig.vertex;
+  return modelConfig.firstParty;
+});
+async function isDefaultSlowAndCapableModel() {
+  return !process.env.ANTHROPIC_MODEL || process.env.ANTHROPIC_MODEL === await getSlowAndCapableModel();
+}
+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;
+  }
+}
+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 simple 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 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
+      };
+    }
+    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
+      };
+    }
+    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
+      };
+    }
+    if (allProfiles.length === 1) {
+      return {
+        success: false,
+        modelName: null,
+        previousModelName,
+        contextOverflow: false,
+        usagePercentage: 0
+      };
+    }
+    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
+    };
+  }
+  /**
+   * 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");
+  }
+  /**
+   * 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
+      };
+      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: ""
+      };
+    }
+    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 || {}
+    };
+  }
+  /**
+   * 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
+   */
+  saveConfig() {
+    const updatedConfig = {
+      ...this.config,
+      modelProfiles: this.modelProfiles
+    };
+    saveGlobalConfig(updatedConfig);
+  }
+  /**
+   * 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"].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"].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;
+  }
+  findModelProfileByModelName(modelName) {
+    return this.modelProfiles.find((p) => p.modelName === modelName) || null;
+  }
+  findModelProfileByName(name) {
+    return this.modelProfiles.find((p) => p.name === name) || null;
+  }
+  updateLastUsed(modelName) {
+    const profile = this.findModelProfile(modelName);
+    if (profile) {
+      profile.lastUsed = Date.now();
+    }
+  }
+}
+let globalModelManager = null;
+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: "" }
+        });
+      } else {
+        globalModelManager = new ModelManager(config);
+      }
+    }
+    return globalModelManager;
+  } catch (error) {
+    console.error("Error creating ModelManager:", error);
+    return new ModelManager({
+      modelProfiles: [],
+      modelPointers: { main: "", task: "", reasoning: "", quick: "" }
+    });
+  }
+};
+const reloadModelManager = () => {
+  globalModelManager = null;
+  getModelManager();
+};
+const getQuickModel = () => {
+  const manager = getModelManager();
+  const quickModel = manager.getModel("quick");
+  return quickModel?.modelName || "quick";
+};
+export {
+  ModelManager,
+  USE_BEDROCK,
+  USE_VERTEX,
+  getModelManager,
+  getQuickModel,
+  getSlowAndCapableModel,
+  getVertexRegionForModel,
+  isDefaultSlowAndCapableModel,
+  reloadModelManager
+};
+//# sourceMappingURL=model.js.map