@within-7/minto 0.4.1 → 0.4.3

package/dist/components/ModelSelector/ModelSelector.js

@@ -1,2068 +0,0 @@
-import React, { useState, useEffect } from "react";
-import { Text, useInput } from "ink";
-import { getModelManager } from "../../utils/model.js";
-import { useExitOnCtrlCD } from "../../hooks/useExitOnCtrlCD.js";
-import {
-  getGlobalConfig,
-  setAllPointersToModel,
-  setModelPointer
-} from "../../utils/config.js";
-import models, { providers } from "../../constants/models.js";
-import OpenAI from "openai";
-import { verifyApiKey } from "../../services/claude.js";
-import { fetchCustomModels } from "../../services/openai.js";
-import {
-  testGPT5Connection,
-  validateGPT5Config
-} from "../../services/gpt5ConnectionTest.js";
-import { SEMANTIC_COLORS } from "../../constants/colors.js";
-import { isOpenAICompatibleProvider } from "../../constants/providers.js";
-import { getEffectiveCapabilities } from "../../constants/providerRegistry.js";
-import { t } from "../../i18n/index.js";
-import { SimpleSelector } from "../SimpleSelector/SimpleSelector.js";
-import { InfoPanel } from "../InfoPanel/InfoPanel.js";
-import { BrandTextInput } from "./BrandTextInput.js";
-import {
-  CONTEXT_LENGTH_OPTIONS,
-  DEFAULT_CONTEXT_LENGTH,
-  MAX_TOKENS_OPTIONS,
-  DEFAULT_MAX_TOKENS
-} from "./constants.js";
-function ModelSelector({
-  onDone: onDoneProp,
-  abortController,
-  targetPointer,
-  isOnboarding = false,
-  onCancel,
-  skipModelType = false,
-  editingModel
-}) {
-  const config = getGlobalConfig();
-  const onDone = onDoneProp;
-  useExitOnCtrlCD(() => process.exit(0));
-  const isEditMode = !!editingModel;
-  const [screenStack, setScreenStack] = useState([isEditMode ? "testAndSave" : "provider"]);
-  const currentScreen = screenStack[screenStack.length - 1];
-  const navigateTo = (screen) => {
-    setScreenStack((prev) => [...prev, screen]);
-  };
-  const goBack = () => {
-    if (screenStack.length > 1) {
-      setScreenStack((prev) => prev.slice(0, -1));
-    } else {
-      onDone();
-    }
-  };
-  const [selectedProvider, setSelectedProvider] = useState(
-    editingModel?.provider ?? config.primaryProvider ?? "anthropic"
-  );
-  const [anthropicProviderType, setAnthropicProviderType] = useState("official");
-  const [selectedModel, setSelectedModel] = useState(
-    editingModel?.modelName ?? ""
-  );
-  const [apiKey, setApiKey] = useState(editingModel?.apiKey ?? "");
-  const [maxTokens, setMaxTokens] = useState(
-    editingModel?.maxTokens?.toString() ?? config.maxTokens?.toString() ?? DEFAULT_MAX_TOKENS.toString()
-  );
-  const [maxTokensMode, setMaxTokensMode] = useState(
-    "preset"
-  );
-  const [selectedMaxTokensPreset, setSelectedMaxTokensPreset] = useState(config.maxTokens || DEFAULT_MAX_TOKENS);
-  const [reasoningEffort, setReasoningEffort] = useState(
-    editingModel?.reasoningEffort ?? "medium"
-  );
-  const [supportsReasoningEffort, setSupportsReasoningEffort] = useState(!!editingModel?.reasoningEffort);
-  const [contextLength, setContextLength] = useState(
-    editingModel?.contextLength ?? DEFAULT_CONTEXT_LENGTH
-  );
-  const [activeFieldIndex, setActiveFieldIndex] = useState(0);
-  const [maxTokensCursorOffset, setMaxTokensCursorOffset] = useState(0);
-  const [availableModels, setAvailableModels] = useState([]);
-  const [isLoadingModels, setIsLoadingModels] = useState(false);
-  const [modelLoadError, setModelLoadError] = useState(null);
-  const [modelSearchQuery, setModelSearchQuery] = useState("");
-  const [modelSearchCursorOffset, setModelSearchCursorOffset] = useState(0);
-  const [cursorOffset, setCursorOffset] = useState(0);
-  const [apiKeyEdited, setApiKeyEdited] = useState(isEditMode);
-  const [fetchRetryCount, setFetchRetryCount] = useState(0);
-  const [isRetrying, setIsRetrying] = useState(false);
-  const [isTestingConnection, setIsTestingConnection] = useState(false);
-  const [connectionTestResult, setConnectionTestResult] = useState(null);
-  const [validationError, setValidationError] = useState(null);
-  const [isManualModelEntry, setIsManualModelEntry] = useState(false);
-  const [resourceName, setResourceName] = useState("");
-  const [resourceNameCursorOffset, setResourceNameCursorOffset] = useState(0);
-  const [customModelName, setCustomModelName] = useState("");
-  const [customModelNameCursorOffset, setCustomModelNameCursorOffset] = useState(0);
-  const [ollamaBaseUrl, setOllamaBaseUrl] = useState(
-    "http://localhost:11434/v1"
-  );
-  const [ollamaBaseUrlCursorOffset, setOllamaBaseUrlCursorOffset] = useState(0);
-  const [customBaseUrl, setCustomBaseUrl] = useState("");
-  const [customBaseUrlCursorOffset, setCustomBaseUrlCursorOffset] = useState(0);
-  const [providerBaseUrl, setProviderBaseUrl] = useState(
-    editingModel?.baseURL ?? ""
-  );
-  const [providerBaseUrlCursorOffset, setProviderBaseUrlCursorOffset] = useState(0);
-  const reasoningEffortOptions = [
-    { label: "Low - Faster responses, less thorough reasoning", value: "low" },
-    { label: "Medium - Balanced speed and reasoning depth", value: "medium" },
-    {
-      label: "High - Slower responses, more thorough reasoning",
-      value: "high"
-    }
-  ];
-  const availableProviders = Object.keys(providers).filter(
-    (provider) => provider !== "bigdream" && provider !== "opendev"
-  );
-  const providerOptions = availableProviders.map((provider) => {
-    const modelCount = models[provider]?.length || 0;
-    const label = getProviderLabel(provider, modelCount);
-    return {
-      label,
-      value: provider
-    };
-  });
-  useEffect(() => {
-    if (!apiKeyEdited && selectedProvider) {
-      if (process.env[selectedProvider.toUpperCase() + "_API_KEY"]) {
-        setApiKey(
-          process.env[selectedProvider.toUpperCase() + "_API_KEY"]
-        );
-      } else {
-        setApiKey("");
-      }
-    }
-  }, [selectedProvider, apiKey, apiKeyEdited]);
-  useEffect(() => {
-    if (currentScreen === "contextLength" && !CONTEXT_LENGTH_OPTIONS.find((opt) => opt.value === contextLength)) {
-      setContextLength(DEFAULT_CONTEXT_LENGTH);
-    }
-  }, [currentScreen, contextLength]);
-  useEffect(() => {
-    if (currentScreen === "testAndSave" && !isEditMode && !isTestingConnection && !connectionTestResult) {
-      handleConnectionTest();
-    }
-  }, [currentScreen]);
-  const ourModelNames = new Set(
-    (models[selectedProvider] || []).map(
-      (model) => model.model
-    )
-  );
-  const filteredModels = modelSearchQuery ? availableModels.filter(
-    (model) => model.model?.toLowerCase().includes(modelSearchQuery.toLowerCase())
-  ) : availableModels;
-  const sortModelsByPriority = (models2) => {
-    const priorityKeywords = [
-      "claude",
-      "kimi",
-      "deepseek",
-      "minimax",
-      "o3",
-      "gpt",
-      "qwen"
-    ];
-    return models2.sort((a, b) => {
-      const aModelLower = a.model?.toLowerCase() || "";
-      const bModelLower = b.model?.toLowerCase() || "";
-      const aHasPriority = priorityKeywords.some(
-        (keyword) => aModelLower.includes(keyword)
-      );
-      const bHasPriority = priorityKeywords.some(
-        (keyword) => bModelLower.includes(keyword)
-      );
-      if (aHasPriority && !bHasPriority) return -1;
-      if (!aHasPriority && bHasPriority) return 1;
-      return a.model.localeCompare(b.model);
-    });
-  };
-  const sortedFilteredModels = sortModelsByPriority(filteredModels);
-  const modelOptions = sortedFilteredModels.map((model) => {
-    const isInOurModels = ourModelNames.has(model.model);
-    return {
-      label: `${model.model}${getModelDetails(model)}`,
-      value: model.model
-    };
-  });
-  function getModelDetails(model) {
-    const details = [];
-    if (model.context_length) {
-      details.push(`${formatNumber(model.context_length)} tokens`);
-    } else if (model.max_tokens) {
-      details.push(`${formatNumber(model.max_tokens)} tokens`);
-    }
-    if (model.supports_vision) {
-      details.push("vision");
-    }
-    if (model.supports_function_calling) {
-      details.push("tools");
-    }
-    return details.length > 0 ? ` (${details.join(", ")})` : "";
-  }
-  function formatNumber(num) {
-    if (num >= 1e6) {
-      return `${(num / 1e6).toFixed(1)}M`;
-    } else if (num >= 1e3) {
-      return `${(num / 1e3).toFixed(0)}K`;
-    }
-    return num.toString();
-  }
-  function getProviderLabel(provider, modelCount) {
-    if (providers[provider]) {
-      return `${providers[provider].name} ${providers[provider].status === "wip" ? "(WIP)" : ""} (${modelCount} models)`;
-    }
-    return `${provider}`;
-  }
-  function handleProviderSelection(provider) {
-    const providerType = provider;
-    setSelectedProvider(providerType);
-    if (provider === "custom") {
-      saveConfiguration(providerType, selectedModel || "");
-      onDone();
-    } else if (provider === "anthropic") {
-      navigateTo("anthropicSubMenu");
-    } else {
-      const defaultBaseUrl = providers[providerType]?.baseURL || "";
-      setProviderBaseUrl(defaultBaseUrl);
-      navigateTo("baseUrl");
-    }
-  }
-  async function fetchAnthropicModels2(baseURL, apiKey2) {
-    try {
-      const response = await fetch(`${baseURL}/v1/models`, {
-        method: "GET",
-        headers: {
-          "x-api-key": apiKey2,
-          "anthropic-version": "2023-06-01",
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${apiKey2}`
-        },
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (!response.ok) {
-        if (response.status === 401) {
-          throw new Error(
-            "Invalid API key. Please check your API key and try again."
-          );
-        } else if (response.status === 403) {
-          throw new Error("API key does not have permission to access models.");
-        } else if (response.status === 404) {
-          throw new Error(
-            "API endpoint not found. This provider may not support model listing."
-          );
-        } else if (response.status === 429) {
-          throw new Error(
-            "Too many requests. Please wait a moment and try again."
-          );
-        } else if (response.status >= 500) {
-          throw new Error(
-            "API service is temporarily unavailable. Please try again later."
-          );
-        } else {
-          throw new Error(`Unable to connect to API (${response.status}).`);
-        }
-      }
-      const data = await response.json();
-      let models2 = [];
-      if (data && data.data && Array.isArray(data.data)) {
-        models2 = data.data;
-      } else if (Array.isArray(data)) {
-        models2 = data;
-      } else if (data && data.models && Array.isArray(data.models)) {
-        models2 = data.models;
-      } else {
-        throw new Error("API returned unexpected response format.");
-      }
-      return models2;
-    } catch (error) {
-      if (error instanceof Error && (error.message.includes("API key") || error.message.includes("API endpoint") || error.message.includes("API service") || error.message.includes("response format"))) {
-        throw error;
-      }
-      if (error instanceof Error && error.message.includes("fetch")) {
-        throw new Error(
-          "Unable to connect to the API. Please check the base URL and your internet connection."
-        );
-      }
-      throw new Error(
-        "Failed to fetch models from API. Please check your configuration and try again."
-      );
-    }
-  }
-  async function fetchAnthropicCompatibleModelsWithFallback(baseURL, provider, apiKeyUrl) {
-    let lastError = null;
-    try {
-      const models2 = await fetchAnthropicModels2(baseURL, apiKey);
-      return models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider,
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: model.supports_vision || true,
-        supports_function_calling: model.supports_function_calling || true,
-        supports_reasoning_effort: false
-      }));
-    } catch (error) {
-      lastError = error;
-    }
-    try {
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      return models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider,
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: model.supports_vision || false,
-        supports_function_calling: model.supports_function_calling || true,
-        supports_reasoning_effort: false
-      }));
-    } catch (error) {
-      lastError = error;
-    }
-    let errorMessage = `Failed to fetch ${provider} models using both Anthropic and OpenAI API formats`;
-    if (lastError) {
-      errorMessage = lastError.message;
-    }
-    if (errorMessage.includes("API key")) {
-      errorMessage += `
-
-\u{1F4A1} Tip: Get your API key from ${apiKeyUrl}`;
-    } else if (errorMessage.includes("permission")) {
-      errorMessage += `
-
-\u{1F4A1} Tip: Make sure your API key has access to the ${provider} API`;
-    } else if (errorMessage.includes("connection")) {
-      errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-    }
-    setModelLoadError(errorMessage);
-    throw new Error(errorMessage);
-  }
-  async function fetchAnthropicCompatibleProviderModels() {
-    let defaultBaseURL;
-    let apiKeyUrl;
-    let actualProvider;
-    switch (anthropicProviderType) {
-      case "official":
-        defaultBaseURL = "https://api.anthropic.com";
-        apiKeyUrl = "https://console.anthropic.com/settings/keys";
-        actualProvider = "anthropic";
-        break;
-      case "bigdream":
-        defaultBaseURL = "https://api-key.info";
-        apiKeyUrl = "https://api-key.info/register?aff=MSl4";
-        actualProvider = "bigdream";
-        break;
-      case "opendev":
-        defaultBaseURL = "https://api.openai-next.com";
-        apiKeyUrl = "https://api.openai-next.com/register/?aff_code=4xo7";
-        actualProvider = "opendev";
-        break;
-      case "custom":
-        defaultBaseURL = providerBaseUrl;
-        apiKeyUrl = "your custom API provider";
-        actualProvider = "anthropic";
-        break;
-      default:
-        throw new Error(
-          `Unsupported Anthropic provider type: ${anthropicProviderType}`
-        );
-    }
-    const baseURL = anthropicProviderType === "custom" ? providerBaseUrl : providerBaseUrl || defaultBaseURL;
-    return await fetchAnthropicCompatibleModelsWithFallback(
-      baseURL,
-      actualProvider,
-      apiKeyUrl
-    );
-  }
-  async function fetchKimiModels() {
-    try {
-      const baseURL = providerBaseUrl || "https://api.moonshot.cn/v1";
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      const kimiModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "kimi",
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: false,
-        // Default to false, could be enhanced
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return kimiModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch Kimi models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://platform.moonshot.cn/console/api-keys";
-      } else if (errorMessage.includes("permission")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the Kimi API";
-      } else if (errorMessage.includes("connection")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchDeepSeekModels() {
-    try {
-      const baseURL = providerBaseUrl || "https://api.deepseek.com";
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      const deepseekModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "deepseek",
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: false,
-        // Default to false, could be enhanced
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return deepseekModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch DeepSeek models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://platform.deepseek.com/api_keys";
-      } else if (errorMessage.includes("permission")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the DeepSeek API";
-      } else if (errorMessage.includes("connection")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchSiliconFlowModels() {
-    try {
-      const baseURL = providerBaseUrl || "https://api.siliconflow.cn/v1";
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      const siliconflowModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "siliconflow",
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: false,
-        // Default to false, could be enhanced
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return siliconflowModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch SiliconFlow models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://cloud.siliconflow.cn/i/oJWsm6io";
-      } else if (errorMessage.includes("permission")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the SiliconFlow API";
-      } else if (errorMessage.includes("connection")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchQwenModels() {
-    try {
-      const baseURL = providerBaseUrl || "https://dashscope.aliyuncs.com/compatible-mode/v1";
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      const qwenModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "qwen",
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: false,
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return qwenModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch Qwen models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://bailian.console.aliyun.com/?tab=model#/api-key";
-      } else if (errorMessage.includes("permission")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the Qwen API";
-      } else if (errorMessage.includes("connection")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchGLMModels() {
-    try {
-      const baseURL = providerBaseUrl || "https://open.bigmodel.cn/api/paas/v4";
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      const glmModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "glm",
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: false,
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return glmModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch GLM models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://open.bigmodel.cn (API Keys section)";
-      } else if (errorMessage.includes("permission")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the GLM API";
-      } else if (errorMessage.includes("connection")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchMinimaxModels() {
-    try {
-      const baseURL = providerBaseUrl || "https://api.minimaxi.com/v1";
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      const minimaxModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "minimax",
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: false,
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return minimaxModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch MiniMax models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://www.minimax.io/platform/user-center/basic-information";
-      } else if (errorMessage.includes("permission")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the MiniMax API";
-      } else if (errorMessage.includes("connection")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchBaiduQianfanModels() {
-    try {
-      const baseURL = providerBaseUrl || "https://qianfan.baidubce.com/v2";
-      const models2 = await fetchCustomModels(baseURL, apiKey);
-      const baiduModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "baidu-qianfan",
-        max_tokens: model.max_tokens || 8192,
-        supports_vision: false,
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return baiduModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch Baidu Qianfan models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Get your API key from https://console.bce.baidu.com/iam/#/iam/accesslist";
-      } else if (errorMessage.includes("permission")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure your API key has access to the Baidu Qianfan API";
-      } else if (errorMessage.includes("connection")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check your internet connection and try again";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchCustomOpenAIModels() {
-    try {
-      const models2 = await fetchCustomModels(customBaseUrl, apiKey);
-      const customModels = models2.map((model) => ({
-        model: model.modelName || model.id || model.name || model.model || "unknown",
-        provider: "custom-openai",
-        max_tokens: model.max_tokens || 4096,
-        supports_vision: false,
-        // Default to false, could be enhanced
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      return customModels;
-    } catch (error) {
-      let errorMessage = "Failed to fetch custom API models";
-      if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      if (errorMessage.includes("API key")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Check that your API key is valid for this endpoint";
-      } else if (errorMessage.includes("endpoint not found")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Make sure the base URL ends with /v1 and supports OpenAI-compatible API";
-      } else if (errorMessage.includes("connect")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: Verify the base URL is correct and accessible";
-      } else if (errorMessage.includes("response format")) {
-        errorMessage += "\n\n\u{1F4A1} Tip: This API may not be fully OpenAI-compatible";
-      }
-      setModelLoadError(errorMessage);
-      throw error;
-    }
-  }
-  async function fetchGeminiModels() {
-    try {
-      const response = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`,
-        { signal: AbortSignal.timeout(3e4) }
-      );
-      if (!response.ok) {
-        const errorData = await response.json();
-        throw new Error(
-          errorData.error?.message || `API error: ${response.status}`
-        );
-      }
-      const { models: models2 } = await response.json();
-      const geminiModels = models2.filter(
-        (model) => model.supportedGenerationMethods.includes("generateContent")
-      ).map((model) => ({
-        model: model.name.replace("models/", ""),
-        provider: "gemini",
-        max_tokens: model.outputTokenLimit,
-        supports_vision: model.supportedGenerationMethods.includes("generateContent"),
-        supports_function_calling: model.supportedGenerationMethods.includes("generateContent")
-      }));
-      return geminiModels;
-    } catch (error) {
-      setModelLoadError(
-        error instanceof Error ? error.message : "Unknown error"
-      );
-      throw error;
-    }
-  }
-  async function fetchOllamaModels() {
-    try {
-      const response = await fetch(`${ollamaBaseUrl}/models`, {
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP error ${response.status}: ${response.statusText}`);
-      }
-      const responseData = await response.json();
-      let models2 = [];
-      if (responseData.data && Array.isArray(responseData.data)) {
-        models2 = responseData.data;
-      } else if (Array.isArray(responseData.models)) {
-        models2 = responseData.models;
-      } else if (Array.isArray(responseData)) {
-        models2 = responseData;
-      } else {
-        throw new Error(
-          "Invalid response from Ollama API: missing models array"
-        );
-      }
-      const ollamaModels = models2.map((model) => ({
-        model: model.id ?? model.name ?? model.modelName ?? (typeof model === "string" ? model : ""),
-        provider: "ollama",
-        max_tokens: DEFAULT_MAX_TOKENS,
-        // Default output tokens (8K is reasonable)
-        supports_vision: false,
-        supports_function_calling: true,
-        supports_reasoning_effort: false
-      }));
-      const validModels = ollamaModels.filter((model) => model.model);
-      const normalizeOllamaRoot = (url) => {
-        try {
-          const u = new URL(url);
-          let pathname = u.pathname.replace(/\/+$|^$/, "");
-          if (pathname.endsWith("/v1")) {
-            pathname = pathname.slice(0, -3);
-          }
-          u.pathname = pathname;
-          return u.toString().replace(/\/+$/, "");
-        } catch {
-          return url.replace(/\/v1\/?$/, "");
-        }
-      };
-      const extractContextTokens = (data) => {
-        if (!data || typeof data !== "object") return null;
-        if (data.model_info && typeof data.model_info === "object") {
-          const modelInfo = data.model_info;
-          for (const key of Object.keys(modelInfo)) {
-            if (key.endsWith(".context_length") || key.endsWith("_context_length")) {
-              const val = modelInfo[key];
-              if (typeof val === "number" && isFinite(val) && val > 0) {
-                return val;
-              }
-            }
-          }
-        }
-        const candidates = [
-          data?.parameters?.num_ctx,
-          data?.model_info?.num_ctx,
-          data?.config?.num_ctx,
-          data?.details?.context_length,
-          data?.context_length,
-          data?.num_ctx,
-          data?.max_tokens,
-          data?.max_new_tokens
-        ].filter((v) => typeof v === "number" && isFinite(v) && v > 0);
-        if (candidates.length > 0) {
-          return Math.max(...candidates);
-        }
-        if (typeof data?.parameters === "string") {
-          const m = data.parameters.match(/num_ctx\s*[:=]\s*(\d+)/i);
-          if (m) {
-            const n = parseInt(m[1], 10);
-            if (Number.isFinite(n) && n > 0) return n;
-          }
-        }
-        return null;
-      };
-      const ollamaRoot = normalizeOllamaRoot(ollamaBaseUrl);
-      const enrichedModels = await Promise.all(
-        validModels.map(async (m) => {
-          try {
-            const showResp = await fetch(`${ollamaRoot}/api/show`, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ name: m.model }),
-              signal: AbortSignal.timeout(3e4)
-            });
-            if (showResp.ok) {
-              const showData = await showResp.json();
-              const ctx = extractContextTokens(showData);
-              if (typeof ctx === "number" && isFinite(ctx) && ctx > 0) {
-                return { ...m, context_length: ctx };
-              }
-            }
-            return m;
-          } catch {
-            return m;
-          }
-        })
-      );
-      setAvailableModels(enrichedModels);
-      if (enrichedModels.length > 0) {
-        navigateTo("model");
-      } else {
-        setModelLoadError("No models found in your Ollama installation");
-      }
-      return enrichedModels;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (errorMessage.includes("fetch")) {
-        setModelLoadError(
-          `Could not connect to Ollama server at ${ollamaBaseUrl}. Make sure Ollama is running and the URL is correct.`
-        );
-      } else {
-        setModelLoadError(`Error loading Ollama models: ${errorMessage}`);
-      }
-      return [];
-    }
-  }
-  async function fetchModelsWithRetry() {
-    const MAX_RETRIES = 2;
-    let lastError = null;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      setFetchRetryCount(attempt);
-      setIsRetrying(attempt > 1);
-      if (attempt > 1) {
-        setModelLoadError(
-          `Attempt ${attempt}/${MAX_RETRIES}: Retrying model discovery...`
-        );
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-      }
-      try {
-        const models2 = await fetchModels();
-        setFetchRetryCount(0);
-        setIsRetrying(false);
-        setModelLoadError(null);
-        return models2;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        if (attempt === MAX_RETRIES) {
-          break;
-        }
-      }
-    }
-    setIsRetrying(false);
-    const errorMessage = lastError?.message || "Unknown error";
-    const supportsManualInput = [
-      "anthropic",
-      "kimi",
-      "deepseek",
-      "siliconflow",
-      "qwen",
-      "glm",
-      "minimax",
-      "baidu-qianfan",
-      "custom-openai"
-    ].includes(selectedProvider);
-    if (supportsManualInput) {
-      setModelLoadError(
-        `Failed to auto-discover models after ${MAX_RETRIES} attempts: ${errorMessage}
-
-\u26A1 Automatically switching to manual model configuration...`
-      );
-      setTimeout(() => {
-        setModelLoadError(null);
-        navigateTo("modelInput");
-      }, 2e3);
-    } else {
-      setModelLoadError(
-        `Failed to load models after ${MAX_RETRIES} attempts: ${errorMessage}`
-      );
-    }
-    return [];
-  }
-  async function fetchModels() {
-    setIsLoadingModels(true);
-    setModelLoadError(null);
-    try {
-      if (selectedProvider === "anthropic") {
-        const anthropicModels = await fetchAnthropicCompatibleProviderModels();
-        setAvailableModels(anthropicModels);
-        navigateTo("model");
-        return anthropicModels;
-      }
-      if (selectedProvider === "custom-openai") {
-        const customModels = await fetchCustomOpenAIModels();
-        setAvailableModels(customModels);
-        navigateTo("model");
-        return customModels;
-      }
-      if (selectedProvider === "gemini") {
-        const geminiModels = await fetchGeminiModels();
-        setAvailableModels(geminiModels);
-        navigateTo("model");
-        return geminiModels;
-      }
-      if (selectedProvider === "kimi") {
-        const kimiModels = await fetchKimiModels();
-        setAvailableModels(kimiModels);
-        navigateTo("model");
-        return kimiModels;
-      }
-      if (selectedProvider === "deepseek") {
-        const deepseekModels = await fetchDeepSeekModels();
-        setAvailableModels(deepseekModels);
-        navigateTo("model");
-        return deepseekModels;
-      }
-      if (selectedProvider === "siliconflow") {
-        const siliconflowModels = await fetchSiliconFlowModels();
-        setAvailableModels(siliconflowModels);
-        navigateTo("model");
-        return siliconflowModels;
-      }
-      if (selectedProvider === "qwen") {
-        const qwenModels = await fetchQwenModels();
-        setAvailableModels(qwenModels);
-        navigateTo("model");
-        return qwenModels;
-      }
-      if (selectedProvider === "glm") {
-        const glmModels = await fetchGLMModels();
-        setAvailableModels(glmModels);
-        navigateTo("model");
-        return glmModels;
-      }
-      if (selectedProvider === "baidu-qianfan") {
-        const baiduModels = await fetchBaiduQianfanModels();
-        setAvailableModels(baiduModels);
-        navigateTo("model");
-        return baiduModels;
-      }
-      if (selectedProvider === "azure") {
-        navigateTo("modelInput");
-        return [];
-      }
-      let baseURL = providerBaseUrl || providers[selectedProvider]?.baseURL;
-      if (selectedProvider === "custom-openai") {
-        baseURL = customBaseUrl;
-      }
-      const openai = new OpenAI({
-        apiKey: apiKey || "dummy-key-for-ollama",
-        // Ollama doesn't need a real key
-        baseURL,
-        dangerouslyAllowBrowser: true
-      });
-      const response = await openai.models.list();
-      const fetchedModels = [];
-      for (const model of response.data) {
-        const modelName = model.modelName || model.id || model.name || model.model || "unknown";
-        const modelInfo = models[selectedProvider]?.find(
-          (m) => m.model === modelName
-        );
-        fetchedModels.push({
-          model: modelName,
-          provider: selectedProvider,
-          max_tokens: modelInfo?.max_output_tokens,
-          supports_vision: modelInfo?.supports_vision || false,
-          supports_function_calling: modelInfo?.supports_function_calling || false,
-          supports_reasoning_effort: modelInfo?.supports_reasoning_effort || false
-        });
-      }
-      setAvailableModels(fetchedModels);
-      navigateTo("model");
-      return fetchedModels;
-    } catch (error) {
-      throw error;
-    } finally {
-      setIsLoadingModels(false);
-    }
-  }
-  function handleApiKeySubmit(key) {
-    setApiKey(key);
-    if (isEditMode) {
-      goBack();
-      return;
-    }
-    if (selectedProvider === "azure") {
-      navigateTo("resourceName");
-      return;
-    }
-    fetchModelsWithRetry().catch(() => {
-    });
-  }
-  function handleResourceNameSubmit(name) {
-    setResourceName(name);
-    navigateTo("modelInput");
-  }
-  function handleOllamaBaseUrlSubmit(url) {
-    setOllamaBaseUrl(url);
-    setIsLoadingModels(true);
-    setModelLoadError(null);
-    fetchOllamaModels().finally(() => {
-      setIsLoadingModels(false);
-    });
-  }
-  function handleCustomBaseUrlSubmit(url) {
-    const cleanUrl = url.replace(/\/+$/, "");
-    setCustomBaseUrl(cleanUrl);
-    setProviderBaseUrl(cleanUrl);
-    if (isEditMode) {
-      goBack();
-      return;
-    }
-    navigateTo("apiKey");
-  }
-  function handleProviderBaseUrlSubmit(url) {
-    const cleanUrl = url.replace(/\/+$/, "");
-    setProviderBaseUrl(cleanUrl);
-    if (isEditMode) {
-      goBack();
-      return;
-    }
-    if (selectedProvider === "ollama") {
-      setOllamaBaseUrl(cleanUrl);
-      setIsLoadingModels(true);
-      setModelLoadError(null);
-      fetchOllamaModels().finally(() => {
-        setIsLoadingModels(false);
-      });
-    } else {
-      navigateTo("apiKey");
-    }
-  }
-  function handleAnthropicProviderSelection(providerType) {
-    setAnthropicProviderType(providerType);
-    if (providerType === "custom") {
-      setProviderBaseUrl("");
-      navigateTo("baseUrl");
-    } else {
-      const defaultUrls = {
-        official: "https://api.anthropic.com",
-        bigdream: "https://api-key.info",
-        opendev: "https://api.openai-next.com"
-      };
-      setProviderBaseUrl(defaultUrls[providerType]);
-      navigateTo("apiKey");
-    }
-  }
-  function handleCustomModelSubmit(model) {
-    setCustomModelName(model);
-    setSelectedModel(model);
-    setIsManualModelEntry(true);
-    setSupportsReasoningEffort(false);
-    setReasoningEffort(null);
-    setMaxTokensMode("preset");
-    setSelectedMaxTokensPreset(DEFAULT_MAX_TOKENS);
-    setMaxTokens(DEFAULT_MAX_TOKENS.toString());
-    setMaxTokensCursorOffset(DEFAULT_MAX_TOKENS.toString().length);
-    navigateTo("modelParams");
-    setActiveFieldIndex(0);
-  }
-  function handleModelSelection(model) {
-    setSelectedModel(model);
-    setIsManualModelEntry(false);
-    const modelInfo = availableModels.find((m) => m.model === model);
-    setSupportsReasoningEffort(modelInfo?.supports_reasoning_effort || false);
-    if (!modelInfo?.supports_reasoning_effort) {
-      setReasoningEffort(null);
-    }
-    if (modelInfo?.context_length) {
-      setContextLength(modelInfo.context_length);
-    } else {
-      setContextLength(DEFAULT_CONTEXT_LENGTH);
-    }
-    if (modelInfo?.max_tokens) {
-      const modelMaxTokens = modelInfo.max_tokens;
-      const matchingPreset = MAX_TOKENS_OPTIONS.find(
-        (option) => option.value === modelMaxTokens
-      );
-      if (matchingPreset) {
-        setMaxTokensMode("preset");
-        setSelectedMaxTokensPreset(modelMaxTokens);
-        setMaxTokens(modelMaxTokens.toString());
-      } else {
-        setMaxTokensMode("custom");
-        setMaxTokens(modelMaxTokens.toString());
-      }
-      setMaxTokensCursorOffset(modelMaxTokens.toString().length);
-    } else {
-      setMaxTokensMode("preset");
-      setSelectedMaxTokensPreset(DEFAULT_MAX_TOKENS);
-      setMaxTokens(DEFAULT_MAX_TOKENS.toString());
-      setMaxTokensCursorOffset(DEFAULT_MAX_TOKENS.toString().length);
-    }
-    navigateTo("modelParams");
-    setActiveFieldIndex(0);
-  }
-  const handleModelParamsSubmit = () => {
-    if (isEditMode) {
-      goBack();
-      return;
-    }
-    if (!isManualModelEntry) {
-      const modelInfo = availableModels.find((m) => m.model === selectedModel);
-      if (modelInfo?.context_length || modelInfo?.max_input_tokens) {
-        navigateTo("testAndSave");
-        return;
-      }
-    }
-    if (!CONTEXT_LENGTH_OPTIONS.find((opt) => opt.value === contextLength)) {
-      setContextLength(DEFAULT_CONTEXT_LENGTH);
-    }
-    navigateTo("contextLength");
-  };
-  async function testConnection() {
-    setIsTestingConnection(true);
-    setConnectionTestResult(null);
-    try {
-      let testBaseURL = providerBaseUrl || providers[selectedProvider]?.baseURL || "";
-      if (selectedProvider === "azure") {
-        testBaseURL = `https://${resourceName}.openai.azure.com/openai/deployments/${selectedModel}`;
-      } else if (selectedProvider === "custom-openai") {
-        testBaseURL = customBaseUrl;
-      }
-      if (isOpenAICompatibleProvider(selectedProvider)) {
-        const isGPT5 = selectedModel?.toLowerCase().includes("gpt-5");
-        if (isGPT5) {
-          const configValidation = validateGPT5Config({
-            model: selectedModel,
-            apiKey,
-            baseURL: testBaseURL,
-            maxTokens: parseInt(maxTokens) || 8192,
-            provider: selectedProvider
-          });
-          if (!configValidation.valid) {
-            return {
-              success: false,
-              message: "\u274C GPT-5 configuration validation failed",
-              details: configValidation.errors.join("\n")
-            };
-          }
-          const gpt5Result = await testGPT5Connection({
-            model: selectedModel,
-            apiKey,
-            baseURL: testBaseURL,
-            maxTokens: parseInt(maxTokens) || 8192,
-            provider: selectedProvider
-          });
-          return gpt5Result;
-        }
-        const endpointsToTry = [];
-        if (selectedProvider === "minimax") {
-          endpointsToTry.push(
-            {
-              path: "/text/chatcompletion_v2",
-              name: "MiniMax v2 (recommended)"
-            },
-            { path: "/chat/completions", name: "Standard OpenAI" }
-          );
-        } else {
-          endpointsToTry.push({
-            path: "/chat/completions",
-            name: "Standard OpenAI"
-          });
-        }
-        let lastError = null;
-        for (const endpoint of endpointsToTry) {
-          try {
-            const testResult = await testChatEndpoint(
-              testBaseURL,
-              endpoint.path,
-              endpoint.name
-            );
-            if (testResult.success) {
-              return testResult;
-            }
-            lastError = testResult;
-          } catch (error) {
-            lastError = {
-              success: false,
-              message: `Failed to test ${endpoint.name}`,
-              endpoint: endpoint.path,
-              details: error instanceof Error ? error.message : String(error)
-            };
-          }
-        }
-        return lastError || {
-          success: false,
-          message: "All endpoints failed",
-          details: "No endpoints could be reached"
-        };
-      } else {
-        return await testProviderSpecificEndpoint(testBaseURL);
-      }
-    } catch (error) {
-      return {
-        success: false,
-        message: "Connection test failed",
-        details: error instanceof Error ? error.message : String(error)
-      };
-    } finally {
-      setIsTestingConnection(false);
-    }
-  }
-  async function testChatEndpoint(baseURL, endpointPath, endpointName) {
-    const testURL = `${baseURL.replace(/\/+$/, "")}${endpointPath}`;
-    const testPayload = {
-      model: selectedModel,
-      messages: [
-        {
-          role: "user",
-          content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.'
-        }
-      ],
-      max_tokens: Math.max(parseInt(maxTokens) || 8192, 8192),
-      // Ensure minimum 8192 tokens for connection test
-      temperature: 0,
-      stream: false
-    };
-    if (selectedModel && selectedProvider) {
-      const caps = getEffectiveCapabilities(selectedProvider, selectedModel);
-      if (caps.maxTokensField !== "max_tokens" && testPayload.max_tokens) {
-        testPayload[caps.maxTokensField] = testPayload.max_tokens;
-        delete testPayload.max_tokens;
-      }
-      if (caps.temperatureRange === "omit") {
-        delete testPayload.temperature;
-      } else if (typeof caps.temperatureRange === "object") {
-        testPayload.temperature = Math.min(
-          testPayload.temperature,
-          caps.temperatureRange.max
-        );
-      }
-    }
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (selectedProvider === "azure") {
-      headers["api-key"] = apiKey;
-    } else {
-      headers["Authorization"] = `Bearer ${apiKey}`;
-    }
-    try {
-      const response = await fetch(testURL, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(testPayload),
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (response.ok) {
-        const data = await response.json();
-        let responseContent = "";
-        if (data.choices && data.choices.length > 0) {
-          responseContent = data.choices[0]?.message?.content || "";
-        } else if (data.reply) {
-          responseContent = data.reply;
-        } else if (data.output) {
-          responseContent = data.output?.text || data.output || "";
-        }
-        const containsYes = responseContent.toLowerCase().includes("yes");
-        if (containsYes) {
-          return {
-            success: true,
-            message: `\u2705 Connection test passed with ${endpointName}`,
-            endpoint: endpointPath,
-            details: `Model responded correctly: "${responseContent.trim()}"`
-          };
-        } else {
-          return {
-            success: false,
-            message: `\u26A0\uFE0F ${endpointName} connected but model response unexpected`,
-            endpoint: endpointPath,
-            details: `Expected "YES" but got: "${responseContent.trim() || "(empty response)"}"`
-          };
-        }
-      } else {
-        const errorData = await response.json().catch(() => null);
-        const errorMessage = errorData?.error?.message || errorData?.message || response.statusText;
-        return {
-          success: false,
-          message: `\u274C ${endpointName} failed (${response.status})`,
-          endpoint: endpointPath,
-          details: `Error: ${errorMessage}`
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        message: `\u274C ${endpointName} connection failed`,
-        endpoint: endpointPath,
-        details: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  async function testResponsesEndpoint(baseURL, endpointPath, endpointName) {
-    const testURL = `${baseURL.replace(/\/+$/, "")}${endpointPath}`;
-    const testPayload = {
-      model: selectedModel,
-      input: [
-        {
-          role: "user",
-          content: 'Please respond with exactly "YES" (in capital letters) to confirm this connection is working.'
-        }
-      ],
-      max_completion_tokens: Math.max(parseInt(maxTokens) || 8192, 8192),
-      temperature: 1,
-      // GPT-5 only supports temperature=1
-      // 🚀 Add reasoning configuration for better GPT-5 performance
-      reasoning: {
-        effort: "low"
-        // Fast response for connection test
-      }
-    };
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`
-    };
-    try {
-      const response = await fetch(testURL, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(testPayload),
-        signal: AbortSignal.timeout(3e4)
-      });
-      if (response.ok) {
-        const data = await response.json();
-        let responseContent = "";
-        if (data.output_text) {
-          responseContent = data.output_text;
-        } else if (data.output) {
-          responseContent = typeof data.output === "string" ? data.output : data.output.text || "";
-        }
-        const containsYes = responseContent.toLowerCase().includes("yes");
-        if (containsYes) {
-          return {
-            success: true,
-            message: `\u2705 Connection test passed with ${endpointName}`,
-            endpoint: endpointPath,
-            details: `GPT-5 responded correctly via Responses API: "${responseContent.trim()}"`
-          };
-        } else {
-          return {
-            success: false,
-            message: `\u26A0\uFE0F ${endpointName} connected but model response unexpected`,
-            endpoint: endpointPath,
-            details: `Expected "YES" but got: "${responseContent.trim() || "(empty response)"}"`
-          };
-        }
-      } else {
-        const errorData = await response.json().catch(() => null);
-        const errorMessage = errorData?.error?.message || errorData?.message || response.statusText;
-        let details = `Responses API Error: ${errorMessage}`;
-        if (response.status === 400 && errorMessage.includes("max_tokens")) {
-          details += "\n\u{1F527} Note: This appears to be a parameter compatibility issue. The fallback to Chat Completions should handle this.";
-        } else if (response.status === 404) {
-          details += "\n\u{1F527} Note: Responses API endpoint may not be available for this model or provider.";
-        } else if (response.status === 401) {
-          details += "\n\u{1F527} Note: API key authentication failed.";
-        }
-        return {
-          success: false,
-          message: `\u274C ${endpointName} failed (${response.status})`,
-          endpoint: endpointPath,
-          details
-        };
-      }
-    } catch (error) {
-      return {
-        success: false,
-        message: `\u274C ${endpointName} connection failed`,
-        endpoint: endpointPath,
-        details: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  async function testProviderSpecificEndpoint(baseURL) {
-    if (selectedProvider === "anthropic" || selectedProvider === "bigdream") {
-      try {
-        let testBaseURL = void 0;
-        if (selectedProvider === "bigdream") {
-          testBaseURL = baseURL || "https://api-key.info";
-        } else if (selectedProvider === "anthropic") {
-          testBaseURL = baseURL && baseURL !== "https://api.anthropic.com" ? baseURL : void 0;
-        }
-        const isValid = await verifyApiKey(
-          apiKey,
-          testBaseURL,
-          selectedProvider
-        );
-        if (isValid) {
-          return {
-            success: true,
-            message: `\u2705 ${selectedProvider} connection test passed`,
-            endpoint: "/messages",
-            details: "API key verified using official Anthropic SDK"
-          };
-        } else {
-          return {
-            success: false,
-            message: `\u274C ${selectedProvider} API key verification failed`,
-            endpoint: "/messages",
-            details: "Invalid API key. Please check your API key and try again."
-          };
-        }
-      } catch (error) {
-        return {
-          success: false,
-          message: `\u274C ${selectedProvider} connection failed`,
-          endpoint: "/messages",
-          details: error instanceof Error ? error.message : String(error)
-        };
-      }
-    }
-    return {
-      success: true,
-      message: `\u2705 Configuration saved for ${selectedProvider}`,
-      details: "Provider-specific testing not implemented yet"
-    };
-  }
-  async function handleConnectionTest() {
-    const result = await testConnection();
-    setConnectionTestResult(result);
-  }
-  const handleContextLengthSubmit = () => {
-    if (isEditMode) {
-      goBack();
-      return;
-    }
-    navigateTo("testAndSave");
-  };
-  async function saveConfiguration(provider, model) {
-    let baseURL = providerBaseUrl || providers[provider]?.baseURL || "";
-    let actualProvider = provider;
-    if (provider === "anthropic") {
-      switch (anthropicProviderType) {
-        case "official":
-          actualProvider = "anthropic";
-          baseURL = baseURL || "https://api.anthropic.com";
-          break;
-        case "bigdream":
-          actualProvider = "bigdream";
-          baseURL = baseURL || "https://api-key.info";
-          break;
-        case "custom":
-          actualProvider = "anthropic";
-          break;
-      }
-    }
-    if (provider === "azure") {
-      baseURL = `https://${resourceName}.openai.azure.com/openai/deployments/${model}`;
-    } else if (provider === "custom-openai") {
-      baseURL = customBaseUrl;
-    }
-    try {
-      const modelManager = getModelManager();
-      const modelConfig = {
-        name: `${actualProvider} ${model}`,
-        provider: actualProvider,
-        modelName: model,
-        baseURL,
-        apiKey: apiKey || "",
-        maxTokens: parseInt(maxTokens) || DEFAULT_MAX_TOKENS,
-        contextLength: contextLength || DEFAULT_CONTEXT_LENGTH,
-        reasoningEffort
-      };
-      return await modelManager.addModel(modelConfig);
-    } catch (error) {
-      setValidationError(
-        error instanceof Error ? error.message : "Failed to add model"
-      );
-      return null;
-    }
-  }
-  async function handleConfirmation() {
-    setValidationError(null);
-    if (isEditMode && editingModel) {
-      try {
-        const modelManager = getModelManager();
-        modelManager.updateModel(editingModel.modelName, {
-          baseURL: providerBaseUrl || editingModel.baseURL,
-          apiKey: apiKey || editingModel.apiKey,
-          maxTokens: parseInt(maxTokens) || editingModel.maxTokens,
-          contextLength: contextLength || editingModel.contextLength,
-          reasoningEffort
-        });
-        onDone();
-      } catch (error) {
-        setValidationError(
-          error instanceof Error ? error.message : "Failed to update model"
-        );
-      }
-      return;
-    }
-    const modelId = await saveConfiguration(selectedProvider, selectedModel);
-    if (!modelId) {
-      return;
-    }
-    if (modelId && (isOnboarding || targetPointer)) {
-      if (isOnboarding) {
-        setAllPointersToModel(modelId);
-      } else if (targetPointer) {
-        setModelPointer(targetPointer, modelId);
-      }
-    }
-    onDone();
-  }
-  const handleBack = () => {
-    if (currentScreen === "provider") {
-      if (onCancel) {
-        onCancel();
-      } else {
-        onDone();
-      }
-    } else {
-      if (currentScreen === "testAndSave") {
-        setConnectionTestResult(null);
-        setIsTestingConnection(false);
-        setValidationError(null);
-      }
-      const prevScreen = screenStack[screenStack.length - 2];
-      if (prevScreen === "modelParams") {
-        const formFields = getFormFieldsForModelParams();
-        const submitIndex = formFields.findIndex((f) => f.name === "submit");
-        setActiveFieldIndex(Math.max(0, submitIndex - 1));
-      }
-      setScreenStack((prev) => prev.slice(0, -1));
-    }
-  };
-  function handleCursorOffsetChange(offset) {
-    setCursorOffset(offset);
-  }
-  function handleApiKeyChange(value) {
-    setApiKeyEdited(true);
-    setApiKey(value);
-  }
-  function handleModelSearchChange(value) {
-    setModelSearchQuery(value);
-    setModelSearchCursorOffset(value.length);
-  }
-  function handleModelSearchCursorOffsetChange(offset) {
-    setModelSearchCursorOffset(offset);
-  }
-  const textScreens = ["apiKey", "baseUrl", "resourceName", "modelInput"];
-  useInput((input, key) => {
-    if (!textScreens.includes(currentScreen)) return;
-    if (key.escape) {
-      handleBack();
-      return;
-    }
-    if (currentScreen === "apiKey" && key.return) {
-      if (apiKey) {
-        handleApiKeySubmit(apiKey);
-      }
-      return;
-    }
-    if (currentScreen === "apiKey" && key.tab) {
-      if (selectedProvider === "anthropic" || selectedProvider === "kimi" || selectedProvider === "deepseek" || selectedProvider === "qwen" || selectedProvider === "glm" || selectedProvider === "minimax" || selectedProvider === "baidu-qianfan" || selectedProvider === "siliconflow" || selectedProvider === "custom-openai") {
-        navigateTo("modelInput");
-        return;
-      }
-      fetchModelsWithRetry().catch(() => {
-      });
-      return;
-    }
-    if (currentScreen === "resourceName" && key.return) {
-      if (resourceName) {
-        handleResourceNameSubmit(resourceName);
-      }
-      return;
-    }
-    if (currentScreen === "baseUrl" && key.return) {
-      if (selectedProvider === "custom-openai") {
-        handleCustomBaseUrlSubmit(customBaseUrl);
-      } else {
-        handleProviderBaseUrlSubmit(providerBaseUrl);
-      }
-      return;
-    }
-    if (currentScreen === "modelInput" && key.return) {
-      if (customModelName) {
-        handleCustomModelSubmit(customModelName);
-      }
-      return;
-    }
-  });
-  function getFormFieldsForModelParams() {
-    return [
-      {
-        name: "maxTokens",
-        label: "Maximum Tokens",
-        description: "Select the maximum number of tokens to generate.",
-        value: parseInt(maxTokens),
-        component: "select",
-        options: MAX_TOKENS_OPTIONS.map((option) => ({
-          label: option.label,
-          value: option.value.toString()
-        })),
-        defaultValue: maxTokens
-      },
-      ...supportsReasoningEffort ? [
-        {
-          name: "reasoningEffort",
-          label: "Reasoning Effort",
-          description: "Controls reasoning depth for complex problems.",
-          value: reasoningEffort,
-          component: "select"
-        }
-      ] : [],
-      {
-        name: "submit",
-        label: "Continue \u2192",
-        component: "button"
-      }
-    ];
-  }
-  if (currentScreen === "apiKey") {
-    const providerLabel = getProviderLabel(selectedProvider, 0).split(" (")[0];
-    const apiKeyUrls = {
-      kimi: "https://platform.moonshot.cn/console/api-keys",
-      deepseek: "https://platform.deepseek.com/api_keys",
-      siliconflow: "https://cloud.siliconflow.cn/i/oJWsm6io",
-      qwen: "https://bailian.console.aliyun.com/?tab=model#/api-key",
-      glm: "https://open.bigmodel.cn (API Keys section)",
-      minimax: "https://www.minimax.io/platform/user-center/basic-information",
-      "baidu-qianfan": "https://console.bce.baidu.com/iam/#/iam/accesslist",
-      openai: "https://platform.openai.com/api-keys"
-    };
-    let apiKeyUrl = apiKeyUrls[selectedProvider] || "";
-    if (selectedProvider === "anthropic") {
-      apiKeyUrl = anthropicProviderType === "official" ? "https://console.anthropic.com/settings/keys" : anthropicProviderType === "bigdream" ? "https://api-key.info/register?aff=MSl4" : anthropicProviderType === "opendev" ? "https://api.openai-next.com/register/?aff_code=4xo7" : "your custom API provider";
-    }
-    const supportsManualInput = selectedProvider === "anthropic" || selectedProvider === "kimi" || selectedProvider === "deepseek" || selectedProvider === "qwen" || selectedProvider === "glm" || selectedProvider === "minimax" || selectedProvider === "baidu-qianfan" || selectedProvider === "siliconflow" || selectedProvider === "custom-openai";
-    const tabHintText = supportsManualInput ? t("modelSelector.apiKeyTabHintManual") : t("modelSelector.apiKeyTabHintSkip");
-    const apiKeyHint = apiKeyUrl ? /* @__PURE__ */ React.createElement(Text, { color: SEMANTIC_COLORS.dim }, "Get your API key from:", " ", /* @__PURE__ */ React.createElement(Text, { color: SEMANTIC_COLORS.info }, apiKeyUrl)) : void 0;
-    return /* @__PURE__ */ React.createElement(
-      BrandTextInput,
-      {
-        title: `${t("modelSelector.apiKeyTitle")} \u2014 ${providerLabel}`,
-        description: t("modelSelector.apiKeyDesc"),
-        placeholder: "sk-...",
-        value: apiKey,
-        onChange: handleApiKeyChange,
-        onSubmit: handleApiKeySubmit,
-        mask: "*",
-        error: modelLoadError ? `Error: ${modelLoadError}` : null,
-        isLoading: isLoadingModels,
-        loadingText: "Loading available models...",
-        hint: apiKeyHint,
-        footerHint: `Enter continue \xB7 Tab ${tabHintText} \xB7 Esc back`,
-        cursorOffset,
-        onChangeCursorOffset: handleCursorOffsetChange
-      }
-    );
-  }
-  if (currentScreen === "model") {
-    const providerLabel = getProviderLabel(
-      selectedProvider,
-      availableModels.length
-    ).split(" (")[0];
-    const modelSelectorItems = modelOptions.map((opt) => ({
-      id: opt.value,
-      label: opt.label
-    }));
-    const subtitle = modelOptions.length > 0 ? `${modelOptions.length}/${availableModels.length} models` : availableModels.length > 0 ? t("modelSelector.noModelsMatch") : t("modelSelector.noModelsAvailable");
-    return /* @__PURE__ */ React.createElement(
-      SimpleSelector,
-      {
-        title: `${t("modelSelector.modelSelectionTitle")} \u2014 ${providerLabel}`,
-        subtitle,
-        items: modelSelectorItems,
-        onSelect: (item) => handleModelSelection(item.id),
-        onClose: handleBack
-      }
-    );
-  }
-  if (currentScreen === "modelParams") {
-    const formFields = getFormFieldsForModelParams();
-    const currentField = formFields[activeFieldIndex];
-    if (currentField?.name === "maxTokens") {
-      const maxTokensItems = MAX_TOKENS_OPTIONS.map((opt) => ({
-        id: opt.value.toString(),
-        label: opt.label,
-        isCurrent: opt.value === parseInt(maxTokens)
-      }));
-      return /* @__PURE__ */ React.createElement(
-        SimpleSelector,
-        {
-          title: `${t("modelSelector.modelParamsTitle")} \u2014 ${t("modelSelector.maxTokens")}`,
-          subtitle: selectedModel,
-          items: maxTokensItems,
-          onSelect: (item) => {
-            const numValue = parseInt(item.id);
-            setMaxTokens(numValue.toString());
-            setSelectedMaxTokensPreset(numValue);
-            setMaxTokensCursorOffset(numValue.toString().length);
-            setActiveFieldIndex(activeFieldIndex + 1);
-          },
-          onClose: handleBack
-        }
-      );
-    }
-    if (currentField?.name === "reasoningEffort") {
-      const effortItems = reasoningEffortOptions.map((opt) => ({
-        id: opt.value,
-        label: opt.label,
-        isCurrent: opt.value === reasoningEffort
-      }));
-      return /* @__PURE__ */ React.createElement(
-        SimpleSelector,
-        {
-          title: `${t("modelSelector.modelParamsTitle")} \u2014 ${t("modelSelector.reasoningEffort")}`,
-          subtitle: selectedModel,
-          items: effortItems,
-          onSelect: (item) => {
-            setReasoningEffort(item.id);
-            setActiveFieldIndex(activeFieldIndex + 1);
-          },
-          onClose: () => {
-            setActiveFieldIndex(0);
-          }
-        }
-      );
-    }
-    handleModelParamsSubmit();
-    return null;
-  }
-  if (currentScreen === "resourceName") {
-    return /* @__PURE__ */ React.createElement(
-      BrandTextInput,
-      {
-        title: t("modelSelector.resourceNameTitle"),
-        description: t("modelSelector.resourceNameDesc"),
-        placeholder: "myazureresource",
-        value: resourceName,
-        onChange: setResourceName,
-        onSubmit: handleResourceNameSubmit,
-        footerHint: t("modelSelector.footerEnterContinue"),
-        cursorOffset: resourceNameCursorOffset,
-        onChangeCursorOffset: setResourceNameCursorOffset
-      }
-    );
-  }
-  if (currentScreen === "baseUrl") {
-    const isCustomOpenAI = selectedProvider === "custom-openai";
-    if (isCustomOpenAI) {
-      return /* @__PURE__ */ React.createElement(
-        BrandTextInput,
-        {
-          title: t("modelSelector.customApiTitle"),
-          description: t("modelSelector.customApiDesc"),
-          placeholder: "https://api.example.com/v1",
-          value: customBaseUrl,
-          onChange: setCustomBaseUrl,
-          onSubmit: handleCustomBaseUrlSubmit,
-          isLoading: isLoadingModels,
-          loadingText: "Connecting...",
-          error: modelLoadError ? `Error: ${modelLoadError}` : null,
-          footerHint: t("modelSelector.footerEnterContinue"),
-          cursorOffset: customBaseUrlCursorOffset,
-          onChangeCursorOffset: setCustomBaseUrlCursorOffset
-        }
-      );
-    }
-    const providerName = providers[selectedProvider]?.name || selectedProvider;
-    const defaultUrl = providers[selectedProvider]?.baseURL || "";
-    const desc = selectedProvider === "ollama" ? t("modelSelector.baseUrlOllamaDesc") : `${t("modelSelector.baseUrlDesc")} You can modify this URL or press Enter to use the default.`;
-    return /* @__PURE__ */ React.createElement(
-      BrandTextInput,
-      {
-        title: `${t("modelSelector.baseUrlTitle")} \u2014 ${providerName}`,
-        description: desc,
-        placeholder: defaultUrl,
-        value: providerBaseUrl,
-        onChange: setProviderBaseUrl,
-        onSubmit: handleProviderBaseUrlSubmit,
-        isLoading: isLoadingModels,
-        loadingText: selectedProvider === "ollama" ? "Connecting to Ollama server..." : `Connecting to ${providerName}...`,
-        error: modelLoadError ? `Error: ${modelLoadError}` : null,
-        footerHint: t("modelSelector.footerEnterContinue"),
-        cursorOffset: providerBaseUrlCursorOffset,
-        onChangeCursorOffset: setProviderBaseUrlCursorOffset
-      }
-    );
-  }
-  if (currentScreen === "modelInput") {
-    const modelInputConfig = {
-      azure: {
-        title: "Azure Model Setup",
-        placeholder: "gpt-4",
-        examples: 'e.g. "gpt-4", "gpt-35-turbo"'
-      },
-      anthropic: {
-        title: "Claude Model Setup",
-        placeholder: "claude-3-5-sonnet-latest",
-        examples: 'e.g. "claude-3-5-sonnet-latest", "claude-3-5-haiku-latest"'
-      },
-      bigdream: {
-        title: "BigDream Model Setup",
-        placeholder: "claude-3-5-sonnet-latest",
-        examples: 'e.g. "claude-3-5-sonnet-latest", "claude-3-5-haiku-latest"'
-      },
-      kimi: {
-        title: "Kimi Model Setup",
-        placeholder: "kimi-k2-0711-preview",
-        examples: 'e.g. "kimi-k2-0711-preview"'
-      },
-      deepseek: {
-        title: "DeepSeek Model Setup",
-        placeholder: "deepseek-chat",
-        examples: 'e.g. "deepseek-chat", "deepseek-coder", "deepseek-reasoner"'
-      },
-      siliconflow: {
-        title: "SiliconFlow Model Setup",
-        placeholder: "Qwen/Qwen2.5-72B-Instruct",
-        examples: 'e.g. "Qwen/Qwen2.5-72B-Instruct"'
-      },
-      qwen: {
-        title: "Qwen Model Setup",
-        placeholder: "qwen-plus",
-        examples: 'e.g. "qwen-plus", "qwen-turbo", "qwen-max"'
-      },
-      glm: {
-        title: "GLM Model Setup",
-        placeholder: "glm-4",
-        examples: 'e.g. "glm-4", "glm-4v", "glm-3-turbo"'
-      },
-      minimax: {
-        title: "MiniMax Model Setup",
-        placeholder: "abab6.5s-chat",
-        examples: 'e.g. "abab6.5s-chat", "abab6.5g-chat"'
-      },
-      "baidu-qianfan": {
-        title: "Baidu Qianfan Model Setup",
-        placeholder: "ERNIE-4.0-8K",
-        examples: 'e.g. "ERNIE-4.0-8K", "ERNIE-3.5-8K"'
-      },
-      "custom-openai": {
-        title: "Custom API Model Setup",
-        placeholder: "model-name",
-        examples: "Enter the exact model name supported by your API endpoint."
-      }
-    };
-    const cfg = modelInputConfig[selectedProvider] || {
-      title: t("modelSelector.modelInputTitle"),
-      placeholder: "gpt-4",
-      examples: 'e.g. "gpt-4", "gpt-3.5-turbo"'
-    };
-    return /* @__PURE__ */ React.createElement(
-      BrandTextInput,
-      {
-        title: cfg.title,
-        description: cfg.examples,
-        placeholder: cfg.placeholder,
-        value: customModelName,
-        onChange: setCustomModelName,
-        onSubmit: handleCustomModelSubmit,
-        footerHint: t("modelSelector.footerEnterContinue"),
-        cursorOffset: customModelNameCursorOffset,
-        onChangeCursorOffset: setCustomModelNameCursorOffset
-      }
-    );
-  }
-  if (currentScreen === "contextLength") {
-    const contextItems = CONTEXT_LENGTH_OPTIONS.map((opt) => ({
-      id: opt.value.toString(),
-      label: opt.value === DEFAULT_CONTEXT_LENGTH ? `${opt.label} (${t("modelSelector.recommended")})` : opt.label,
-      isCurrent: opt.value === contextLength
-    }));
-    return /* @__PURE__ */ React.createElement(
-      SimpleSelector,
-      {
-        title: t("modelSelector.contextLengthTitle"),
-        subtitle: t("modelSelector.contextLengthDesc"),
-        items: contextItems,
-        onSelect: (item) => {
-          setContextLength(parseInt(item.id));
-          handleContextLengthSubmit();
-        },
-        onClose: handleBack
-      }
-    );
-  }
-  if (currentScreen === "testAndSave") {
-    const providerDisplayName = getProviderLabel(selectedProvider, 0).split(
-      " ("
-    )[0];
-    const showsApiKey = selectedProvider !== "ollama";
-    const contextLengthLabel = CONTEXT_LENGTH_OPTIONS.find((opt) => opt.value === contextLength)?.label || `${contextLength.toLocaleString()} tokens`;
-    if (isEditMode) {
-      const editItems = [];
-      if (showsApiKey) {
-        editItems.push({
-          id: "__edit_apiKey__",
-          label: "API Key",
-          description: apiKey ? `****${apiKey.slice(-4)}` : "(not set)",
-          category: t("modelSelector.testAndSaveDesc")
-        });
-      }
-      if (selectedProvider === "custom-openai" || providerBaseUrl !== providers[selectedProvider]?.baseURL) {
-        editItems.push({
-          id: "__edit_baseUrl__",
-          label: "Base URL",
-          description: providerBaseUrl || customBaseUrl || "(not set)",
-          category: t("modelSelector.testAndSaveDesc")
-        });
-      }
-      editItems.push({
-        id: "__edit_modelParams__",
-        label: "Max Tokens",
-        description: maxTokens,
-        category: t("modelSelector.testAndSaveDesc")
-      });
-      editItems.push({
-        id: "__edit_contextLength__",
-        label: "Context Length",
-        description: contextLengthLabel,
-        category: t("modelSelector.testAndSaveDesc")
-      });
-      if (connectionTestResult) {
-        editItems.push({
-          id: "__test_status__",
-          label: "Connection",
-          description: connectionTestResult.message,
-          statusIcon: connectionTestResult.success ? "\u2713" : "\u2715",
-          statusColor: connectionTestResult.success ? SEMANTIC_COLORS.success : SEMANTIC_COLORS.error,
-          category: t("modelSelector.testAndSaveDesc")
-        });
-      }
-      editItems.push({
-        id: "__save__",
-        label: t("modelSelector.confirmationSave"),
-        category: t("commands.model.actionsCategory"),
-        statusIcon: "\u2713",
-        statusColor: SEMANTIC_COLORS.success
-      });
-      editItems.push({
-        id: "__test__",
-        label: t("modelSelector.connectionTestRetry"),
-        category: t("commands.model.actionsCategory")
-      });
-      const editTitle = t("commands.model.editTitle").replace(
-        "{model}",
-        editingModel?.name ?? selectedModel
-      );
-      const editOverlay = isTestingConnection ? {
-        type: "loading",
-        message: t("modelSelector.autoTesting")
-      } : validationError ? { type: "error", message: validationError } : null;
-      return /* @__PURE__ */ React.createElement(
-        SimpleSelector,
-        {
-          title: editTitle,
-          items: editItems,
-          groupByCategory: true,
-          onSelect: (item) => {
-            if (item.id === "__edit_apiKey__") {
-              navigateTo("apiKey");
-            } else if (item.id === "__edit_baseUrl__") {
-              navigateTo("baseUrl");
-            } else if (item.id === "__edit_modelParams__") {
-              setActiveFieldIndex(0);
-              navigateTo("modelParams");
-            } else if (item.id === "__edit_contextLength__") {
-              navigateTo("contextLength");
-            } else if (item.id === "__save__") {
-              handleConfirmation().catch((error) => {
-                setValidationError(
-                  error instanceof Error ? error.message : "Unexpected error occurred"
-                );
-              });
-            } else if (item.id === "__test__") {
-              setConnectionTestResult(null);
-              handleConnectionTest();
-            }
-          },
-          onClose: handleBack,
-          statusOverlay: editOverlay
-        }
-      );
-    }
-    const configItems = [
-      { label: "Provider", value: providerDisplayName },
-      ...selectedProvider === "azure" ? [{ label: "Resource Name", value: resourceName }] : [],
-      ...selectedProvider === "ollama" ? [{ label: "Server URL", value: ollamaBaseUrl }] : [],
-      ...selectedProvider === "custom-openai" ? [{ label: "API Base URL", value: customBaseUrl }] : [],
-      { label: "Model", value: selectedModel },
-      ...apiKey && showsApiKey ? [{ label: "API Key", value: `****${apiKey.slice(-4)}` }] : [],
-      ...maxTokens ? [{ label: "Max Tokens", value: maxTokens }] : [],
-      { label: "Context Length", value: contextLengthLabel },
-      ...supportsReasoningEffort ? [{ label: "Reasoning Effort", value: reasoningEffort }] : []
-    ];
-    if (connectionTestResult) {
-      configItems.push({
-        label: "Connection",
-        value: connectionTestResult.message,
-        valueColor: connectionTestResult.success ? SEMANTIC_COLORS.success : SEMANTIC_COLORS.error
-      });
-      if (connectionTestResult.details && !connectionTestResult.success) {
-        configItems.push({
-          label: "Details",
-          value: connectionTestResult.details
-        });
-      }
-    }
-    const testAndSaveSections = [
-      {
-        title: t("modelSelector.testAndSaveDesc"),
-        items: configItems
-      }
-    ];
-    if (validationError) {
-      testAndSaveSections.unshift({
-        title: t("modelSelector.configError"),
-        items: [
-          {
-            label: "Error",
-            value: validationError,
-            valueColor: SEMANTIC_COLORS.error
-          }
-        ]
-      });
-    }
-    const testAndSaveActions = [];
-    if (connectionTestResult?.success) {
-      testAndSaveActions.push({
-        key: "return",
-        keyLabel: "Enter",
-        description: t("modelSelector.confirmationSave"),
-        onPress: () => {
-          handleConfirmation().catch((error) => {
-            setValidationError(
-              error instanceof Error ? error.message : "Unexpected error occurred"
-            );
-          });
-        }
-      });
-    } else if (connectionTestResult && !connectionTestResult.success) {
-      testAndSaveActions.push({
-        key: "return",
-        keyLabel: "Enter",
-        description: t("modelSelector.connectionTestRetry"),
-        onPress: () => {
-          setConnectionTestResult(null);
-          handleConnectionTest();
-        }
-      });
-      testAndSaveActions.push({
-        key: "s",
-        keyLabel: "s",
-        description: t("modelSelector.saveAnyway"),
-        onPress: () => {
-          handleConfirmation().catch((error) => {
-            setValidationError(
-              error instanceof Error ? error.message : "Unexpected error occurred"
-            );
-          });
-        }
-      });
-    }
-    const testAndSaveOverlay = isTestingConnection ? {
-      type: "loading",
-      message: t("modelSelector.autoTesting")
-    } : null;
-    return /* @__PURE__ */ React.createElement(
-      InfoPanel,
-      {
-        title: t("modelSelector.testAndSaveTitle"),
-        sections: testAndSaveSections,
-        actions: testAndSaveActions,
-        onClose: handleBack,
-        statusOverlay: testAndSaveOverlay
-      }
-    );
-  }
-  if (currentScreen === "anthropicSubMenu") {
-    const anthropicItems = [
-      {
-        id: "official",
-        label: t("modelSelector.anthropicOfficial"),
-        description: t("modelSelector.anthropicOfficialDesc")
-      },
-      {
-        id: "bigdream",
-        label: t("modelSelector.anthropicBigdream"),
-        description: t("modelSelector.anthropicBigdreamDesc")
-      },
-      {
-        id: "opendev",
-        label: t("modelSelector.anthropicOpendev"),
-        description: t("modelSelector.anthropicOpendevDesc")
-      },
-      {
-        id: "custom",
-        label: t("modelSelector.anthropicCustom"),
-        description: t("modelSelector.anthropicCustomDesc")
-      }
-    ];
-    return /* @__PURE__ */ React.createElement(
-      SimpleSelector,
-      {
-        title: t("modelSelector.anthropicSubMenu"),
-        subtitle: t("modelSelector.anthropicSubMenuDesc"),
-        items: anthropicItems,
-        onSelect: (item) => handleAnthropicProviderSelection(
-          item.id
-        ),
-        onClose: handleBack
-      }
-    );
-  }
-  const providerSelectorItems = providerOptions.map((opt) => ({
-    id: opt.value,
-    label: opt.label
-  }));
-  return /* @__PURE__ */ React.createElement(
-    SimpleSelector,
-    {
-      title: t("modelSelector.providerSelection"),
-      subtitle: t("modelSelector.providerSelectionDesc"),
-      items: providerSelectorItems,
-      onSelect: (item) => handleProviderSelection(item.id),
-      onClose: () => {
-        if (onCancel) {
-          onCancel();
-        } else {
-          onDone();
-        }
-      }
-    }
-  );
-}
-export {
-  ModelSelector
-};
-//# sourceMappingURL=ModelSelector.js.map