@iaforged/context-code 1.0.56 → 1.0.58

package/README.md

@@ -129,6 +129,8 @@ La metadata de proveedores y perfiles ahora se apoya en una base SQLite autogene
 - archivo: `~/.context/provider-state.sqlite3`
 - se crea sola al arrancar si no existe
 - si hay configuracion legacy previa, intenta migrarla en el primer arranque
+- en Windows/Linux, las credenciales de proveedores tambien se almacenan en esta misma DB
+- esas credenciales se guardan cifradas localmente antes de persistirse en `secure_storage`
 
 Que se guarda ahi:
 
@@ -137,10 +139,14 @@ Que se guarda ahi:
 - proveedor activo
 - ultimo modelo por proveedor
 - estado runtime necesario para restaurar contexto rapido
+- API keys, tokens OAuth y credenciales scoped por perfil, mediante la tabla `secure_storage`
+- el contenido de `secure_storage.value` ya no queda en JSON legible; se cifra localmente antes de escribirse
 
-Que no se guarda ahi en texto plano:
+Migracion de credenciales:
 
-- API keys y tokens OAuth siguen yendo al storage seguro del proyecto
+- si existe `~/.context/.credentials.json`, se importa automaticamente a SQLite la primera vez que se lee el storage seguro
+- si la importacion termina bien, el archivo legacy `.credentials.json` se elimina para evitar dos fuentes de verdad
+- en macOS se mantiene el flujo de keychain con fallback, segun el backend disponible
 
 Compatibilidad:
 

package/context-bootstrap.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env node
-import { homedir } from 'os'
-import { join, dirname } from 'path'
 import { existsSync } from 'fs'
-import { fileURLToPath } from 'url'
-
+import { homedir } from 'os'
+import { dirname, join } from 'path'
 import { fileURLToPath, pathToFileURL } from 'url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -14,17 +12,17 @@ if (!process.env.CLAUDE_CONFIG_DIR) {
 
 // Prefer the bundled CLI if it exists (production)
 const bundledCli = join(__dirname, 'cli.js')
-const recoveryCli = join(__dirname, 'dist-recovery', 'src', 'entrypoints', 'cli.js')
+const distCli = join(__dirname, 'dist', 'src', 'entrypoints', 'cli.js')
 
 if (existsSync(bundledCli)) {
   await import(pathToFileURL(bundledCli).href)
-} else if (existsSync(recoveryCli)) {
-  await import(pathToFileURL(recoveryCli).href)
+} else if (existsSync(distCli)) {
+  await import(pathToFileURL(distCli).href)
 } else {
   // Ultimo recurso: intentar importacion relativa
   try {
     await import('./cli.js')
   } catch (e) {
-    await import('./dist-recovery/src/entrypoints/cli.js')
+    await import('./dist/src/entrypoints/cli.js')
   }
 }

package/{dist-recovery → dist}/src/commands/install.js

@@ -32,7 +32,7 @@ function getInstallTargets() {
 }
 async function installLocalLauncher() {
     const root = getProjectRoot();
-    const cliPath = join(root, 'dist-recovery', 'src', 'entrypoints', 'cli.js');
+    const cliPath = join(root, 'dist', 'src', 'entrypoints', 'cli.js');
     const { displayPath, shellPath, commandName } = getInstallTargets();
     await mkdir(dirname(shellPath), { recursive: true });
     if (env.platform === 'win32') {

package/{dist-recovery → dist}/src/commands/model/model.js

@@ -13,10 +13,16 @@ import { checkOpus1mAccess, checkSonnet1mAccess } from '../../utils/model/check1
 import { getDefaultMainLoopModelSetting, isOpus1mMergeEnabled, renderDefaultModelSetting } from '../../utils/model/model.js';
 import { isModelAllowed } from '../../utils/model/modelAllowlist.js';
 import { isProfiledProvider, setProviderProfileLastModel } from '../../utils/model/providerProfiles.js';
+import { setStoredLastModelForProvider } from '../../utils/model/providerProfilesDb.js';
+import { toProviderPreference } from '../../utils/model/providerSwitch.js';
 import { getAPIProvider } from '../../utils/model/providers.js';
 import { validateModel } from '../../utils/model/validateModel.js';
-function isProfileBackedModelProvider(provider) {
-    return isProfiledProvider(provider);
+function persistModelForActiveProvider(model) {
+    const provider = toProviderPreference(getAPIProvider());
+    if (isProfiledProvider(provider)) {
+        setProviderProfileLastModel(provider, model);
+    }
+    setStoredLastModelForProvider(provider, model);
 }
 export function ModelPickerWrapper(t0) {
     const $ = _c(17);
@@ -47,15 +53,12 @@ export function ModelPickerWrapper(t0) {
     let t2;
     if ($[3] !== isFastMode || $[4] !== mainLoopModel || $[5] !== onDone || $[6] !== setAppState) {
         t2 = function handleSelect(model, effort) {
-            const provider = getAPIProvider();
             logEvent("tengu_model_command_menu", {
                 action: model,
                 from_model: mainLoopModel,
                 to_model: model
             });
-            if (isProfileBackedModelProvider(provider)) {
-                setProviderProfileLastModel(provider, model);
-            }
+            persistModelForActiveProvider(model);
             setAppState(prev => ({
                 ...prev,
                 mainLoopModel: model,
@@ -193,10 +196,7 @@ function SetModelAndClose({ args, onDone }) {
             }
         }
         function setModel(modelValue) {
-            const provider = getAPIProvider();
-            if (isProfileBackedModelProvider(provider)) {
-                setProviderProfileLastModel(provider, modelValue);
-            }
+            persistModelForActiveProvider(modelValue);
             setAppState(prev => ({
                 ...prev,
                 mainLoopModel: modelValue,

package/{dist-recovery → dist}/src/commands/profile/profile.js

@@ -293,7 +293,7 @@ function SwitchProfileOnMount({ onDone, context, provider, profileName, }) {
                 setAppState(prev => ({
                     ...prev,
                     mainLoopModel: restoredModel,
-                    mainLoopModelForSession: restoredModel,
+                    mainLoopModelForSession: null,
                 }));
                 const profile = getLastUsedProviderProfile(provider);
                 onDone(restoredModel

package/{dist-recovery → dist}/src/commands/provider/provider.js

@@ -252,7 +252,7 @@ function SwitchProviderOnMount({ onDone, context, target, baseUrlMessage, target
                 setAppState(prev => ({
                     ...prev,
                     mainLoopModel: result.restoredModel,
-                    mainLoopModelForSession: result.restoredModel,
+                    mainLoopModelForSession: null,
                 }));
                 onDone(baseUrlMessage ? `${baseUrlMessage} - ${result.message}` : result.message);
             }
@@ -332,7 +332,7 @@ function ProviderPicker({ onDone, context, }) {
             setAppState(prev => ({
                 ...prev,
                 mainLoopModel: result.restoredModel,
-                mainLoopModelForSession: result.restoredModel,
+                mainLoopModelForSession: null,
             }));
             onDone(result.message);
         }

package/{dist-recovery → dist}/src/mirrors/shared.js

@@ -118,6 +118,55 @@ function truncate(text, max) {
         return text;
     return `${text.slice(0, max - 1)}…`;
 }
+/** Escapa caracteres especiales de HTML para envío seguro a Telegram con parse_mode HTML. */
+export function escapeHTML(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+/**
+ * Convierte Markdown básico a HTML compatible con Telegram.
+ * Soporta: bloques de código, código inline, negritas, itálicas, tachado.
+ * El texto fuera de esos patrones se escapa para evitar errores de parseo.
+ */
+export function markdownToTelegramHTML(text) {
+    const result = [];
+    // Procesa bloque a bloque para no escapar lo que ya es HTML
+    const codeBlockRe = /```(\w*)\n?([\s\S]*?)```/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = codeBlockRe.exec(text)) !== null) {
+        // Texto antes del bloque de código
+        if (match.index > lastIndex) {
+            result.push(inlineMarkdownToHTML(text.slice(lastIndex, match.index)));
+        }
+        const code = match[2] ?? '';
+        result.push(`<pre><code>${escapeHTML(code.trimEnd())}</code></pre>`);
+        lastIndex = match.index + match[0].length;
+    }
+    // Resto del texto
+    if (lastIndex < text.length) {
+        result.push(inlineMarkdownToHTML(text.slice(lastIndex)));
+    }
+    return result.join('');
+}
+function inlineMarkdownToHTML(text) {
+    // Escape HTML primero, luego restauramos los marcadores de formato
+    let out = escapeHTML(text);
+    // Código inline: `...`
+    out = out.replace(/`([^`]+)`/g, '<code>$1</code>');
+    // Negrita: **texto** o __texto__
+    out = out.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
+    out = out.replace(/__(.+?)__/g, '<b>$1</b>');
+    // Itálica: *texto* o _texto_ (no conflicta con negrita ya procesada)
+    out = out.replace(/\*(.+?)\*/g, '<i>$1</i>');
+    out = out.replace(/_(.+?)_/g, '<i>$1</i>');
+    // Tachado: ~~texto~~
+    out = out.replace(/~~(.+?)~~/g, '<s>$1</s>');
+    return out;
+}
 /** Divide un texto en trozos ≤ `max` chars, cortando en newline cuando se puede. */
 export function splitForChannel(text, max) {
     if (text.length <= max)

package/{dist-recovery → dist}/src/recovery/bunBundleShim.js

@@ -5,7 +5,7 @@ export function feature(name) {
 }
 
 export const MACRO = {
-  VERSION: pkg.version ?? '0.0.0-recovery',
+  VERSION: pkg.version ?? '0.0.0',
   PACKAGE_URL: pkg.name ?? '@iaforged/context-code',
-  BUILD_TIME: 'recovery-build'
+  BUILD_TIME: 'build'
 };

package/{dist-recovery → dist}/src/services/api/client.js

@@ -250,7 +250,7 @@ export async function getAnthropicClient({ apiKey, maxRetries, model, fetchOverr
                 ? null
                 : apiKey || getAnthropicApiKey(),
         authToken: provider === 'minimax'
-            ? undefined
+            ? minimaxApiKey
             : isClaudeAISubscriber()
                 ? getClaudeAIOAuthTokens()?.accessToken
                 : undefined,

package/{dist-recovery → dist}/src/services/api/errors.js

@@ -740,6 +740,9 @@ function get3PModelFallbackSuggestion(model) {
         return undefined;
     }
     // @[MODEL LAUNCH]: Add a fallback suggestion chain for the new model → previous version for 3P
+    if (typeof model !== 'string' || model.trim().length === 0) {
+        return undefined;
+    }
     const m = model.toLowerCase();
     // If the failing model looks like an Opus 4.7 variant, suggest Opus 4.6
     if (m.includes('opus-4-7') || m.includes('opus_4_7')) {

package/{dist-recovery → dist}/src/services/api/withRetry.js

@@ -418,6 +418,13 @@ function isOAuthTokenRevokedError(error) {
         error.status === 403 &&
         (error.message?.includes('OAuth token has been revoked') ?? false));
 }
+function isMiniMaxInsufficientBalanceError(error) {
+    if (!(error instanceof APIError)) {
+        return false;
+    }
+    const message = error.message?.toLowerCase() ?? '';
+    return message.includes('insufficient balance') || message.includes('(1008)');
+}
 function isBedrockAuthError(error) {
     if (isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK)) {
         // AWS libs reject without an API call if .aws holds a past Expiration value
@@ -503,6 +510,11 @@ function shouldRetry(error) {
     if (parseMaxTokensContextOverflowError(error)) {
         return true;
     }
+    // MiniMax reports account/quota exhaustion as an API error. Retrying the same
+    // request only burns time and obscures the real problem for the user.
+    if (isMiniMaxInsufficientBalanceError(error)) {
+        return false;
+    }
     // Note this is not a standard header.
     const shouldRetryHeader = error.headers?.get('x-should-retry');
     // If the server explicitly says whether or not to retry, obey.

package/{dist-recovery → dist}/src/telegram/bridge.js

@@ -5,6 +5,7 @@ import { getOpenAICompatibleAccessToken } from '../utils/auth.js';
 import { getConfiguredProviderBaseUrl } from '../utils/model/providerBaseUrls.js';
 import { getStoredActiveProviderPreference, getStoredLastModelForProvider, setStoredActiveProviderPreference, setStoredLastModelForProvider, } from '../utils/model/providerProfilesDb.js';
 import { setMirrorBot } from './mirror.js';
+import { markdownToTelegramHTML, escapeHTML } from '../mirrors/shared.js';
 let activeBotInstance = null;
 let inboundHandler = null;
 export function setTelegramInboundHandler(handler) {
@@ -159,14 +160,14 @@ export async function startTelegramBridge() {
             }
             const model = getActiveModel();
             const provider = getActiveProvider();
-            await ctx.reply(`🚀 *Context Code Bridge Activo*\n\n` +
-                `📡 Proveedor: *${provider}*\n` +
-                `🤖 Modelo: *${model}*\n\n` +
+            await ctx.reply(`🚀 <b>Context Code Bridge Activo</b>\n\n` +
+                `📡 Proveedor: <b>${escapeHTML(provider)}</b>\n` +
+                `🤖 Modelo: <b>${escapeHTML(model)}</b>\n\n` +
                 `Escríbeme cualquier pregunta y la enviaré al modelo.\n\n` +
-                `Comandos disponibles:\n` +
+                `<b>Comandos disponibles:</b>\n` +
                 `/status - Ver estado actual\n` +
-                `/model <nombre> - Cambiar modelo\n` +
-                `/provider <nombre> - Cambiar proveedor`, { parse_mode: 'Markdown' });
+                `/model &lt;nombre&gt; - Cambiar modelo\n` +
+                `/provider &lt;nombre&gt; - Cambiar proveedor`, { parse_mode: 'HTML' });
         });
         // Comando /status
         bot.command('status', async (ctx) => {
@@ -176,10 +177,10 @@ export async function startTelegramBridge() {
                 return;
             const model = getActiveModel();
             const provider = getActiveProvider();
-            await ctx.reply(`📊 *Estado de Context Code*\n\n` +
-                `📡 Proveedor: *${provider}*\n` +
-                `🤖 Modelo: *${model}*\n` +
-                `🔗 Bridge: ✅ Conectado`, { parse_mode: 'Markdown' });
+            await ctx.reply(`📊 <b>Estado de Context Code</b>\n\n` +
+                `📡 Proveedor: <b>${escapeHTML(provider)}</b>\n` +
+                `🤖 Modelo: <b>${escapeHTML(model)}</b>\n` +
+                `🔗 Bridge: ✅ Conectado`, { parse_mode: 'HTML' });
         });
         // Comando /model
         bot.command('model', async (ctx) => {
@@ -190,15 +191,15 @@ export async function startTelegramBridge() {
             const newModel = ctx.match?.trim();
             if (!newModel) {
                 const model = getActiveModel();
-                await ctx.reply(`🤖 Modelo actual: *${model}*`, {
-                    parse_mode: 'Markdown',
+                await ctx.reply(`🤖 Modelo actual: <b>${escapeHTML(model)}</b>`, {
+                    parse_mode: 'HTML',
                 });
                 return;
             }
             const provider = getActiveProvider();
             setStoredLastModelForProvider(provider, newModel);
-            await ctx.reply(`✅ Modelo cambiado a *${newModel}*`, {
-                parse_mode: 'Markdown',
+            await ctx.reply(`✅ Modelo cambiado a <b>${escapeHTML(newModel)}</b>`, {
+                parse_mode: 'HTML',
             });
         });
         // Comando /provider
@@ -210,8 +211,8 @@ export async function startTelegramBridge() {
             const newProvider = ctx.match?.trim();
             if (!newProvider) {
                 const provider = getActiveProvider();
-                await ctx.reply(`📡 Proveedor actual: *${provider}*`, {
-                    parse_mode: 'Markdown',
+                await ctx.reply(`📡 Proveedor actual: <b>${escapeHTML(provider)}</b>`, {
+                    parse_mode: 'HTML',
                 });
                 return;
             }
@@ -229,8 +230,8 @@ export async function startTelegramBridge() {
                 return;
             }
             setStoredActiveProviderPreference(newProvider.toLowerCase());
-            await ctx.reply(`✅ Proveedor cambiado a *${newProvider}*`, {
-                parse_mode: 'Markdown',
+            await ctx.reply(`✅ Proveedor cambiado a <b>${escapeHTML(newProvider)}</b>`, {
+                parse_mode: 'HTML',
             });
         });
         // Mensajes de texto libre
@@ -266,13 +267,15 @@ export async function startTelegramBridge() {
             const provider = getActiveProvider();
             await ctx.replyWithChatAction('typing');
             const response = await queryModel(ctx.message.text, model, provider);
-            const chunks = splitMessage(response);
+            const htmlResponse = markdownToTelegramHTML(response);
+            const chunks = splitMessage(htmlResponse);
             for (const chunk of chunks) {
                 try {
-                    await ctx.reply(chunk, { parse_mode: 'Markdown' });
+                    await ctx.reply(chunk, { parse_mode: 'HTML' });
                 }
                 catch {
-                    await ctx.reply(chunk);
+                    // Fallback: texto plano sin formato
+                    await ctx.reply(chunk.replace(/<[^>]+>/g, ''));
                 }
             }
         });

package/{dist-recovery → dist}/src/telegram/mirror.js

@@ -1,10 +1,23 @@
 import { getPrimaryChatId } from './config.js';
-import { consumeInjectedMarkIfSameOrigin, markInjected, splitForChannel, } from '../mirrors/shared.js';
+import { consumeInjectedMarkIfSameOrigin, markInjected, markdownToTelegramHTML, escapeHTML, splitForChannel, } from '../mirrors/shared.js';
 const PREFIX = {
     user: '👤',
     assistant: '🤖',
     tool: '🔧',
 };
+function formatMirrorMessage(role, text) {
+    const icon = PREFIX[role];
+    if (role === 'assistant') {
+        // Convierte Markdown del modelo a HTML
+        return `${icon} ${markdownToTelegramHTML(text)}`;
+    }
+    if (role === 'tool') {
+        // Herramientas en bloque de código inline para distinguirlas
+        return `${icon} <code>${escapeHTML(text)}</code>`;
+    }
+    // Usuario: texto plano escapado
+    return `${icon} <b>${escapeHTML(text)}</b>`;
+}
 const TELEGRAM_MAX = 4000;
 const SEND_INTERVAL_MS = 150;
 const MAX_QUEUE = 200;
@@ -49,14 +62,20 @@ async function drain() {
             const chatId = getPrimaryChatId();
             if (!chatId)
                 break;
-            const chunks = splitForChannel(`${PREFIX[item.role]} ${item.text}`, TELEGRAM_MAX);
+            const formatted = formatMirrorMessage(item.role, item.text);
+            const chunks = splitForChannel(formatted, TELEGRAM_MAX);
             for (const chunk of chunks) {
                 try {
-                    await botRef.api.sendMessage(chatId, chunk);
+                    await botRef.api.sendMessage(chatId, chunk, { parse_mode: 'HTML' });
                 }
                 catch {
-                    // Si el send falla (token inválido, user bloqueó, etc.) no reintentamos
-                    // este item — seguimos con la cola para no bloquear mensajes nuevos.
+                    // Fallback sin formato si el HTML falla (e.g. tag roto por corte de chunk)
+                    try {
+                        await botRef.api.sendMessage(chatId, `${PREFIX[item.role]} ${item.text}`.slice(0, TELEGRAM_MAX));
+                    }
+                    catch {
+                        // Si el send falla (token inválido, user bloqueó, etc.) no reintentamos
+                    }
                     break;
                 }
                 await sleep(SEND_INTERVAL_MS);

package/{dist-recovery → dist}/src/utils/logoV2Utils.js

@@ -4,6 +4,9 @@ import { stringWidth } from '../ink/stringWidth.js';
 import { getSubscriptionName, isClaudeAISubscriber } from './auth.js';
 import { getCwd } from './cwd.js';
 import { getDisplayPath } from './file.js';
+import { getAPIProvider } from './model/providers.js';
+import { getActiveProviderProfile, } from './model/providerProfiles.js';
+import { getStoredActiveProviderPreference } from './model/providerProfilesDb.js';
 import { truncate, truncateToWidth, truncateToWidthNoEllipsis, } from './format.js';
 import { getStoredChangelogFromMemory, parseChangelog } from './releaseNotes.js';
 import { gt } from './semver.js';
@@ -15,6 +18,35 @@ const MAX_USERNAME_LENGTH = 20;
 const BORDER_PADDING = 4;
 const DIVIDER_WIDTH = 1;
 const CONTENT_PADDING = 2;
+function normalizeActiveProvider() {
+    const storedProvider = getStoredActiveProviderPreference();
+    if (storedProvider) {
+        return storedProvider;
+    }
+    const apiProvider = getAPIProvider();
+    return apiProvider === 'firstParty' ? 'claude' : apiProvider;
+}
+function getProviderAccountLabel() {
+    const activeProvider = normalizeActiveProvider();
+    switch (activeProvider) {
+        case 'claude':
+            return 'Claude';
+        case 'openai':
+            return 'OpenAI';
+        case 'openrouter':
+            return 'OpenRouter';
+        case 'ollama':
+            return 'Ollama Local';
+        case 'ollama-cloud':
+            return 'Ollama Cloud';
+        case 'zai':
+            return 'Z.AI';
+        case 'minimax':
+            return 'MiniMax Code Plan';
+        default:
+            return isClaudeAISubscriber() ? getSubscriptionName() : 'Context API';
+    }
+}
 /**
  * Determines the layout mode based on terminal width
  */
@@ -184,10 +216,8 @@ export function getLogoDisplayData() {
     const cwd = serverUrl
         ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, '')}`
         : displayPath;
-    const billingType = isClaudeAISubscriber()
-        ? getSubscriptionName()
-        : 'Facturación por uso de API';
-    const agentName = getInitialSettings().agent;
+    const billingType = getProviderAccountLabel();
+    const agentName = getActiveProviderProfile()?.agentName ?? getInitialSettings().agent;
     return {
         version,
         cwd,
@@ -223,7 +253,8 @@ export function formatModelAndBilling(modelName, billingType, availableWidth) {
 export function getRecentReleaseNotesSync(maxItems) {
     // For ants, use bundled changelog
     if (process.env.USER_TYPE === 'ant') {
-        const changelog = MACRO.VERSION_CHANGELOG;
+        const changelog = MACRO
+            .VERSION_CHANGELOG;
         if (changelog) {
             const commits = changelog.trim().split('\n').filter(Boolean);
             return commits.slice(0, maxItems);

package/{dist-recovery → dist}/src/utils/model/model.js

@@ -189,6 +189,8 @@ export function getDefaultMainLoopModel() {
  * module top-level (see MODEL_COSTS in modelCost.ts).
  */
 export function firstPartyNameToCanonical(name) {
+    if (!name)
+        return name;
     name = name.toLowerCase();
     // Special cases for Claude 4+ models to differentiate versions
     // Order matters: check more specific versions first (4-5 before 4)

package/{dist-recovery → dist}/src/utils/model/modelCapabilities.js

@@ -60,6 +60,8 @@ const loadCache = memoize((path) => {
 export function getModelCapability(model) {
     if (!isModelCapabilitiesEligible())
         return undefined;
+    if (!model)
+        return undefined;
     const cached = loadCache(getCachePath());
     if (!cached || cached.length === 0)
         return undefined;

package/{dist-recovery → dist}/src/utils/model/providerModels.js

@@ -221,6 +221,7 @@ export async function checkProviderHealth(provider, options = {}) {
     const headers = provider === 'minimax'
         ? {
             'x-api-key': getMiniMaxAccessToken() ?? '',
+            Authorization: `Bearer ${getMiniMaxAccessToken() ?? ''}`,
             'Content-Type': 'application/json',
         }
         : buildProviderHeaders(provider);

package/{dist-recovery → dist}/src/utils/model/providers.js

@@ -126,47 +126,32 @@ export function getAPIProvider() {
     if (isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY)) {
         return 'foundry';
     }
+    try {
+        const preference = getStoredActiveProviderPreference();
+        if (preference === 'claude')
+            return 'firstParty';
+        if (preference === 'openai')
+            return 'openai';
+        if (preference === 'openrouter')
+            return 'openrouter';
+        if (preference === 'ollama')
+            return 'ollama';
+        if (preference === 'ollama-cloud')
+            return 'ollama-cloud';
+        if (preference === 'zai')
+            return 'zai';
+        if (preference === 'minimax')
+            return 'minimax';
+    }
+    catch {
+        // Config no disponible en arranque temprano.
+    }
     const openAIConfigured = isOpenAIProviderConfigured();
     const openRouterConfigured = isOpenRouterProviderConfigured();
     const ollamaConfigured = isOllamaProviderConfigured();
     const ollamaCloudConfigured = isOllamaCloudProviderConfigured();
     const zaiConfigured = isZAIProviderConfigured();
     const minimaxConfigured = isMiniMaxProviderConfigured();
-    const claudeConfigured = hasStoredClaudeAIOAuthToken();
-    if (openAIConfigured ||
-        openRouterConfigured ||
-        ollamaConfigured ||
-        ollamaCloudConfigured ||
-        zaiConfigured ||
-        minimaxConfigured ||
-        claudeConfigured) {
-        try {
-            const preference = getStoredActiveProviderPreference();
-            if (preference === 'openai' && openAIConfigured)
-                return 'openai';
-            if (preference === 'openrouter' && openRouterConfigured) {
-                return 'openrouter';
-            }
-            if (preference === 'ollama' && ollamaConfigured) {
-                return 'ollama';
-            }
-            if (preference === 'ollama-cloud' && ollamaCloudConfigured) {
-                return 'ollama-cloud';
-            }
-            if (preference === 'zai' && zaiConfigured) {
-                return 'zai';
-            }
-            if (preference === 'minimax' && minimaxConfigured) {
-                return 'minimax';
-            }
-            if (preference === 'claude' && claudeConfigured) {
-                return 'firstParty';
-            }
-        }
-        catch {
-            // Config no disponible en arranque temprano.
-        }
-    }
     if (openAIConfigured) {
         return 'openai';
     }

package/{dist-recovery → dist}/src/utils/model/validateModel.js

@@ -85,9 +85,11 @@ async function validateAgainstProviderCatalog(modelName, provider) {
     if (providerModels.length === 0) {
         return null;
     }
-    const normalizedLower = modelName.toLowerCase();
-    const match = providerModels.some(option => option.value.toLowerCase() === normalizedLower ||
-        option.label.toLowerCase() === normalizedLower);
+    const normalizedLower = modelName?.toLowerCase() ?? '';
+    if (!normalizedLower)
+        return null;
+    const match = providerModels.some(option => option.value?.toLowerCase() === normalizedLower ||
+        option.label?.toLowerCase() === normalizedLower);
     if (match) {
         if (provider === 'ollama') {
             return null;
@@ -219,6 +221,9 @@ function get3PFallbackSuggestion(model) {
     if (getAPIProvider() === 'firstParty') {
         return undefined;
     }
+    if (typeof model !== 'string' || model.trim().length === 0) {
+        return undefined;
+    }
     const lowerModel = model.toLowerCase();
     if (lowerModel.includes('opus-4-7') || lowerModel.includes('opus_4_7')) {
         return getModelStrings().opus46;