@shareai-lab/kode 1.1.23 → 2.0.1

package/dist/{utils/model.js → chunk-IZVMU4S2.js}

@@ -1,29 +1,29 @@
-import { memoize } from "lodash-es";
-import { getDynamicConfig } from "../services/statsig.js";
-import { logError } from "./log.js";
+import { createRequire as __kodeCreateRequire } from "node:module";
+const require = __kodeCreateRequire(import.meta.url);
 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 = {
+} from "./chunk-LC4TVOCZ.js";
+import {
+  debug
+} from "./chunk-STSX7GIX.js";
+import {
+  logError
+} from "./chunk-YXYYDIMI.js";
+
+// src/utils/model/index.ts
+import { memoize } from "lodash-es";
+var USE_BEDROCK = !!(process.env.KODE_USE_BEDROCK ?? process.env.CLAUDE_CODE_USE_BEDROCK);
+var USE_VERTEX = !!(process.env.KODE_USE_VERTEX ?? process.env.CLAUDE_CODE_USE_VERTEX);
+var 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() {
-  try {
-    return await getDynamicConfig(
-      "tengu-capable-model-config",
-      DEFAULT_MODEL_CONFIG
-    );
-  } catch (error) {
-    logError(error);
-    return DEFAULT_MODEL_CONFIG;
-  }
+  return DEFAULT_MODEL_CONFIG;
 }
-const getSlowAndCapableModel = memoize(async () => {
+var getSlowAndCapableModel = memoize(async () => {
   const config = await getGlobalConfig();
   const modelManager = new ModelManager(config);
   const model = modelManager.getMainAgentModel();
@@ -47,17 +47,13 @@ function getVertexRegionForModel(model) {
     return process.env.VERTEX_REGION_CLAUDE_3_7_SONNET;
   }
 }
-class ModelManager {
+var ModelManager = class {
   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) {
@@ -68,9 +64,6 @@ class ModelManager {
     }
     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) {
@@ -85,9 +78,6 @@ class ModelManager {
     }
     return null;
   }
-  /**
-   * Get the task tool default model (for Task tool sub-agents)
-   */
   getTaskToolModel() {
     const taskModelName = this.config.modelPointers?.task;
     if (taskModelName) {
@@ -98,13 +88,6 @@ class ModelManager {
     }
     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) {
@@ -113,127 +96,151 @@ class ModelManager {
         modelName: null,
         previousModelName: null,
         contextOverflow: false,
-        usagePercentage: 0
+        usagePercentage: 0,
+        currentContextTokens
       };
     }
-    allProfiles.sort((a, b) => {
-      return a.createdAt - b.createdAt;
-    });
+    allProfiles.sort((a, b) => 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;
+    const budgetForModel = (model) => {
+      const contextLength = Number(model.contextLength);
+      if (!Number.isFinite(contextLength) || contextLength <= 0) {
+        return { budgetTokens: null, usagePercentage: 0, compatible: true };
       }
-      this.setPointer("main", firstModel.modelName);
-      this.updateLastUsed(firstModel.modelName);
-      const analysis2 = this.analyzeContextCompatibility(
-        firstModel,
-        currentContextTokens
-      );
+      const budgetTokens = Math.floor(contextLength * 0.9);
+      const usagePercentage = budgetTokens > 0 ? currentContextTokens / budgetTokens * 100 : 0;
       return {
-        success: true,
-        modelName: firstModel.name,
-        previousModelName: null,
-        contextOverflow: !analysis2.compatible,
-        usagePercentage: analysis2.usagePercentage
+        budgetTokens,
+        usagePercentage,
+        compatible: budgetTokens > 0 ? currentContextTokens <= budgetTokens : true
       };
-    }
-    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
-      );
+    };
+    const currentIndex = currentMainModelName ? allProfiles.findIndex((p) => p.modelName === currentMainModelName) : -1;
+    const startIndex = currentIndex >= 0 ? currentIndex : -1;
+    if (allProfiles.length === 1) {
       return {
-        success: true,
-        modelName: firstModel.name,
+        success: false,
+        modelName: null,
         previousModelName,
-        contextOverflow: !analysis2.compatible,
-        usagePercentage: analysis2.usagePercentage
+        contextOverflow: false,
+        usagePercentage: 0,
+        currentContextTokens
       };
     }
-    if (allProfiles.length === 1) {
+    const maxOffsets = startIndex === -1 ? allProfiles.length : allProfiles.length - 1;
+    const skippedModels = [];
+    let selected = null;
+    let selectedUsagePercentage = 0;
+    for (let offset = 1; offset <= maxOffsets; offset++) {
+      const candidateIndex = (startIndex + offset + allProfiles.length) % allProfiles.length;
+      const candidate = allProfiles[candidateIndex];
+      if (!candidate) continue;
+      const { budgetTokens, usagePercentage, compatible } = budgetForModel(candidate);
+      if (compatible) {
+        selected = candidate;
+        selectedUsagePercentage = usagePercentage;
+        break;
+      }
+      skippedModels.push({
+        name: candidate.name,
+        provider: candidate.provider,
+        contextLength: candidate.contextLength,
+        budgetTokens,
+        usagePercentage
+      });
+    }
+    if (!selected) {
+      const firstSkipped = skippedModels[0];
       return {
         success: false,
         modelName: null,
         previousModelName,
-        contextOverflow: false,
-        usagePercentage: 0
+        contextOverflow: true,
+        usagePercentage: firstSkipped?.usagePercentage ?? 0,
+        currentContextTokens,
+        skippedModels
       };
     }
-    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();
+    if (!selected.isActive) {
+      selected.isActive = true;
     }
+    this.setPointer("main", selected.modelName);
+    this.updateLastUsed(selected.modelName);
     return {
       success: true,
-      modelName: nextModel.name,
+      modelName: selected.name,
       previousModelName,
-      contextOverflow: !analysis.compatible,
-      usagePercentage: analysis.usagePercentage
+      contextOverflow: false,
+      usagePercentage: selectedUsagePercentage,
+      currentContextTokens,
+      skippedModels
     };
   }
-  /**
-   * 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 formatTokens = (tokens) => {
+      if (!Number.isFinite(tokens)) return "unknown";
+      if (tokens >= 1e3) return `${Math.round(tokens / 1e3)}k`;
+      return String(Math.round(tokens));
+    };
+    const allModels = this.getAllConfiguredModels();
+    if (allModels.length === 0) {
+      return {
+        success: false,
+        modelName: null,
+        blocked: false,
+        message: "\u274C No models configured. Use /model to add models."
+      };
+    }
+    if (allModels.length === 1) {
+      return {
+        success: false,
+        modelName: null,
+        blocked: false,
+        message: `\u26A0\uFE0F Only one model configured (${allModels[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;
+    const modelsSorted = [...allModels].sort(
+      (a, b) => a.createdAt - b.createdAt
+    );
+    const currentIndex = modelsSorted.findIndex(
+      (m) => m.modelName === currentModel?.modelName
+    );
+    const totalModels = modelsSorted.length;
+    if (result.success && result.modelName) {
+      const skippedCount = result.skippedModels?.length ?? 0;
+      const skippedSuffix = skippedCount > 0 ? ` \xB7 skipped ${skippedCount} incompatible` : "";
+      const contextSuffix = currentModel?.contextLength && result.currentContextTokens ? ` \xB7 context ~${formatTokens(result.currentContextTokens)}/${formatTokens(currentModel.contextLength)}` : "";
+      return {
+        success: true,
+        modelName: result.modelName,
+        blocked: false,
+        message: `\u2705 Switched to ${result.modelName} (${currentIndex + 1}/${totalModels})${currentModel?.provider ? ` [${currentModel.provider}]` : ""}${skippedSuffix}${contextSuffix}`
+      };
+    }
+    if (result.contextOverflow) {
+      const attempted = result.skippedModels?.[0];
+      const attemptedContext = attempted?.contextLength;
+      const attemptedBudget = attempted?.budgetTokens;
+      const currentLabel = currentModel?.name || currentModel?.modelName || "current model";
+      const attemptedText = attempted ? `Can't switch to ${attempted.name}: current ~${formatTokens(result.currentContextTokens)} tokens exceeds safe budget (~${formatTokens(attemptedBudget ?? 0)} tokens, 90% of ${formatTokens(attemptedContext ?? 0)}).` : `Can't switch models due to context size (~${formatTokens(result.currentContextTokens)} tokens).`;
+      return {
+        success: false,
+        modelName: null,
+        blocked: true,
+        message: `\u26A0\uFE0F ${attemptedText} Keeping ${currentLabel}.`
+      };
+    }
     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`
+      success: false,
+      modelName: null,
+      blocked: false,
+      message: "\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
@@ -245,9 +252,6 @@ class ModelManager {
     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;
@@ -274,9 +278,6 @@ class ModelManager {
       };
     }
   }
-  /**
-   * Switch to next model with enhanced context analysis
-   */
   switchToNextModelWithAnalysis(currentContextTokens = 0) {
     const result = this.switchToNextModel(currentContextTokens);
     if (!result.success || !result.modelName) {
@@ -307,22 +308,13 @@ class ModelManager {
       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":
@@ -335,22 +327,12 @@ class ModelManager {
         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) {
@@ -359,28 +341,16 @@ class ModelManager {
     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");
+  getCompactModel() {
+    return this.getModelName("compact") || 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
@@ -404,17 +374,25 @@ class ModelManager {
       this.config.modelPointers = {
         main: config.modelName,
         task: config.modelName,
-        reasoning: config.modelName,
+        compact: config.modelName,
         quick: config.modelName
       };
       this.config.defaultModelName = config.modelName;
+    } else {
+      if (!this.config.modelPointers) {
+        this.config.modelPointers = {
+          main: config.modelName,
+          task: "",
+          compact: "",
+          quick: ""
+        };
+      } else {
+        this.config.modelPointers.main = 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`);
@@ -423,40 +401,25 @@ class ModelManager {
       this.config.modelPointers = {
         main: "",
         task: "",
-        reasoning: "",
+        compact: "",
         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;
@@ -475,9 +438,6 @@ class ModelManager {
       modelPointers: this.config.modelPointers || {}
     };
   }
-  /**
-   * Remove a model profile
-   */
   removeModel(modelName) {
     this.modelProfiles = this.modelProfiles.filter(
       (p) => p.modelName !== modelName
@@ -491,9 +451,6 @@ class ModelManager {
     }
     this.saveConfig();
   }
-  /**
-   * Get default model profile
-   */
   getDefaultModel() {
     if (this.config.defaultModelId) {
       const profile = this.findModelProfile(this.config.defaultModelId);
@@ -503,9 +460,6 @@ class ModelManager {
     }
     return this.modelProfiles.find((p) => p.isActive) || null;
   }
-  /**
-   * Save configuration changes
-   */
   saveConfig() {
     const updatedConfig = {
       ...this.config,
@@ -513,22 +467,14 @@ class ModelManager {
     };
     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)) {
+    if (["main", "task", "compact", "quick"].includes(modelParam)) {
       const pointerId = this.config.modelPointers?.[modelParam];
       if (pointerId) {
         let profile2 = this.findModelProfile(pointerId);
@@ -553,15 +499,16 @@ class ModelManager {
     if (profile && profile.isActive) {
       return profile;
     }
+    if (typeof modelParam === "string") {
+      const qualified = this.resolveProviderQualifiedModel(modelParam);
+      if (qualified && qualified.isActive) {
+        return qualified;
+      }
+    }
     return this.getDefaultModel();
   }
-  /**
-   * 解析模型参数并返回完整信息
-   */
   resolveModelWithInfo(modelParam) {
-    const isPointer = ["main", "task", "reasoning", "quick"].includes(
-      modelParam
-    );
+    const isPointer = ["main", "task", "compact", "quick"].includes(modelParam);
     if (isPointer) {
       const pointerId = this.config.modelPointers?.[modelParam];
       if (!pointerId) {
@@ -601,11 +548,14 @@ class ModelManager {
       if (!profile) {
         profile = this.findModelProfileByName(modelParam);
       }
+      if (!profile && typeof modelParam === "string") {
+        profile = this.resolveProviderQualifiedModel(modelParam);
+      }
       if (!profile) {
         return {
           success: false,
           profile: null,
-          error: `Model '${modelParam}' not found. Use /model to add models.`
+          error: `Model '${modelParam}' not found. Use /model to add models, or run 'kode models list' to see configured profiles.`
         };
       }
       if (!profile.isActive) {
@@ -621,7 +571,23 @@ class ModelManager {
       };
     }
   }
-  // Private helper methods
+  resolveProviderQualifiedModel(input) {
+    const trimmed = input.trim();
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex <= 0 || colonIndex >= trimmed.length - 1) return null;
+    const provider = trimmed.slice(0, colonIndex).trim().toLowerCase();
+    const modelOrName = trimmed.slice(colonIndex + 1).trim();
+    if (!provider || !modelOrName) return null;
+    const providerProfiles = this.modelProfiles.filter(
+      (p) => String(p.provider).trim().toLowerCase() === provider
+    );
+    if (providerProfiles.length === 0) return null;
+    const byModelName = providerProfiles.find((p) => p.modelName === modelOrName);
+    if (byModelName) return byModelName;
+    const byName = providerProfiles.find((p) => p.name === modelOrName);
+    if (byName) return byName;
+    return null;
+  }
   findModelProfile(modelName) {
     return this.modelProfiles.find((p) => p.modelName === modelName) || null;
   }
@@ -637,19 +603,17 @@ class ModelManager {
       profile.lastUsed = Date.now();
     }
   }
-}
-let globalModelManager = null;
-const getModelManager = () => {
+};
+var globalModelManager = null;
+var getModelManager = () => {
   try {
     if (!globalModelManager) {
       const config = getGlobalConfig();
       if (!config) {
-        console.warn(
-          "No global config available, creating ModelManager with empty config"
-        );
+        debug.warn("MODEL_MANAGER_GLOBAL_CONFIG_MISSING", {});
         globalModelManager = new ModelManager({
           modelProfiles: [],
-          modelPointers: { main: "", task: "", reasoning: "", quick: "" }
+          modelPointers: { main: "", task: "", compact: "", quick: "" }
         });
       } else {
         globalModelManager = new ModelManager(config);
@@ -657,31 +621,34 @@ const getModelManager = () => {
     }
     return globalModelManager;
   } catch (error) {
-    console.error("Error creating ModelManager:", error);
+    logError(error);
+    debug.error("MODEL_MANAGER_CREATE_FAILED", {
+      error: error instanceof Error ? error.message : String(error)
+    });
     return new ModelManager({
       modelProfiles: [],
-      modelPointers: { main: "", task: "", reasoning: "", quick: "" }
+      modelPointers: { main: "", task: "", compact: "", quick: "" }
     });
   }
 };
-const reloadModelManager = () => {
+var reloadModelManager = () => {
   globalModelManager = null;
   getModelManager();
 };
-const getQuickModel = () => {
+var 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
+  getVertexRegionForModel,
+  ModelManager,
+  getModelManager,
+  reloadModelManager,
+  getQuickModel
 };
-//# sourceMappingURL=model.js.map