dexto 1.5.7 → 1.6.0

package/dist/cli/commands/setup.js

@@ -1,15 +1,18 @@
 // packages/cli/src/cli/commands/setup.ts
 import chalk from 'chalk';
 import { z } from 'zod';
-import { getDefaultModelForProvider, LLM_PROVIDERS, LLM_REGISTRY, isValidProviderModel, getSupportedModels, acceptsAnyModel, supportsCustomModels, requiresApiKey, isReasoningCapableModel, } from '@dexto/core';
+import open from 'open';
+import { getDefaultModelForProvider, LLM_PROVIDERS, LLM_REGISTRY, isValidProviderModel, getSupportedModels, acceptsAnyModel, supportsCustomModels, requiresApiKey, isReasoningCapableModel, getCuratedModelsForProvider, } from '@dexto/core';
 import { resolveApiKeyForProvider } from '@dexto/core';
-import { createInitialPreferences, saveGlobalPreferences, loadGlobalPreferences, getGlobalPreferencesPath, updateGlobalPreferences, setActiveModel, isDextoAuthEnabled, } from '@dexto/agent-management';
+import { createInitialPreferences, saveGlobalPreferences, loadGlobalPreferences, getGlobalPreferencesPath, updateGlobalPreferences, setActiveModel, isDextoAuthEnabled, loadCustomModels, saveCustomModel, deleteCustomModel, } from '@dexto/agent-management';
 import { interactiveApiKeySetup, hasApiKeyConfigured } from '../utils/api-key-setup.js';
 import { selectProvider, getProviderDisplayName, getProviderEnvVar, providerRequiresBaseURL, getDefaultModel, } from '../utils/provider-setup.js';
 import { setupLocalModels, setupOllamaModels, hasSelectedModel, getModelFromResult, } from '../utils/local-model-setup.js';
 import { requiresSetup } from '../utils/setup-utils.js';
 import { canUseDextoProvider } from '../utils/dexto-setup.js';
 import { handleBrowserLogin } from './auth/login.js';
+import { loadAuth, getDextoApiClient } from '../auth/index.js';
+import { DEXTO_CREDITS_URL } from '../auth/constants.js';
 import * as p from '@clack/prompts';
 import { logger } from '@dexto/core';
 import { capture } from '../../analytics/index.js';
@@ -145,7 +148,7 @@ export async function handleSetupCommand(options) {
     }
     // Handle quick start
     if (validated.quickStart) {
-        await handleQuickStart();
+        await handleQuickStart({ onCancel: 'exit' });
         return;
     }
     // Handle interactive full setup
@@ -156,157 +159,243 @@ export async function handleSetupCommand(options) {
     // Handle non-interactive setup with provided options
     await handleNonInteractiveSetup(validated);
 }
-/**
- * Quick start flow - pick a free provider with minimal prompts
- */
-async function handleQuickStart() {
+async function handleQuickStart(options = { onCancel: 'exit' }) {
     console.log(chalk.cyan('\n🚀 Quick Start\n'));
     p.intro(chalk.cyan('Quick Setup'));
-    // Let user pick from popular free providers
-    const quickProvider = await p.select({
-        message: 'Choose a provider',
-        options: [
-            {
-                value: 'google',
-                label: `${chalk.green('●')} Google Gemini`,
-                hint: 'Free, 1M+ context (recommended)',
-            },
-            {
-                value: 'groq',
-                label: `${chalk.green('●')} Groq`,
-                hint: 'Free, ultra-fast',
-            },
-            {
-                value: 'local',
-                label: `${chalk.cyan('●')} Local Models`,
-                hint: 'Free, private, runs on your machine',
-            },
-        ],
-    });
-    if (p.isCancel(quickProvider)) {
-        p.cancel('Setup cancelled');
-        process.exit(0);
-    }
-    // Handle local models with dedicated setup flow
-    if (quickProvider === 'local') {
-        const localResult = await setupLocalModels();
-        if (!hasSelectedModel(localResult)) {
-            p.cancel('Setup cancelled');
-            process.exit(0);
+    while (true) {
+        // Let user pick from popular free providers
+        const quickProvider = await p.select({
+            message: 'Choose a provider',
+            options: [
+                {
+                    value: 'google',
+                    label: `${chalk.green('●')} Google Gemini`,
+                    hint: 'Free, 1M+ context (recommended)',
+                },
+                {
+                    value: 'groq',
+                    label: `${chalk.green('●')} Groq`,
+                    hint: 'Free, ultra-fast',
+                },
+                {
+                    value: 'openrouter',
+                    label: `${chalk.green('●')} OpenRouter (Free)`,
+                    hint: 'Use free-tier models via OpenRouter',
+                },
+                {
+                    value: 'local',
+                    label: `${chalk.cyan('●')} Local Models`,
+                    hint: 'Free, private, runs on your machine',
+                },
+                { value: '_back', label: chalk.gray('← Back'), hint: 'Return' },
+            ],
+        });
+        if (p.isCancel(quickProvider) || quickProvider === '_back') {
+            if (options.onCancel === 'exit') {
+                p.cancel('Setup cancelled');
+            }
+            return 'cancelled';
         }
-        const model = getModelFromResult(localResult);
-        // CLI mode confirmation for local
+        // Handle local models with dedicated setup flow
+        if (quickProvider === 'local') {
+            const localResult = await setupLocalModels();
+            if (!hasSelectedModel(localResult)) {
+                if (options.onCancel === 'exit') {
+                    p.cancel('Setup cancelled');
+                    return 'cancelled';
+                }
+                continue;
+            }
+            const model = getModelFromResult(localResult);
+            // CLI mode confirmation for local
+            const useCli = await p.confirm({
+                message: 'Start in Terminal mode? (You can change this later)',
+                initialValue: true,
+            });
+            if (p.isCancel(useCli)) {
+                if (options.onCancel === 'exit') {
+                    p.cancel('Setup cancelled');
+                    return 'cancelled';
+                }
+                continue;
+            }
+            const defaultMode = useCli ? 'cli' : await selectDefaultMode();
+            if (defaultMode === null) {
+                if (options.onCancel === 'exit') {
+                    p.cancel('Setup cancelled');
+                    return 'cancelled';
+                }
+                continue;
+            }
+            // Sync the active model for local provider
+            await setActiveModel(model);
+            const preferences = createInitialPreferences({
+                provider: 'local',
+                model,
+                defaultMode,
+                setupCompleted: true,
+                apiKeyPending: false,
+            });
+            await saveGlobalPreferences(preferences);
+            capture('dexto_setup', {
+                provider: 'local',
+                model,
+                setupMode: 'interactive',
+                setupVariant: 'quick-start',
+                defaultMode,
+                apiKeySkipped: false,
+            });
+            await showSetupComplete('local', model, defaultMode, false);
+            return 'completed';
+        }
+        // Cloud provider flow (google, groq, openrouter)
+        const provider = quickProvider;
+        let model;
+        if (provider === 'openrouter') {
+            const selected = await p.select({
+                message: 'Select a model for OpenRouter',
+                options: [
+                    {
+                        value: 'openrouter/free',
+                        label: 'OpenRouter Free Models',
+                        hint: 'Free-tier access via OpenRouter',
+                    },
+                    {
+                        value: 'custom',
+                        label: 'Enter a model ID',
+                        hint: 'e.g., anthropic/claude-3.5-sonnet',
+                    },
+                    { value: '_back', label: chalk.gray('← Back'), hint: 'Return' },
+                ],
+            });
+            if (p.isCancel(selected) || selected === '_back') {
+                if (options.onCancel === 'exit') {
+                    p.cancel('Setup cancelled');
+                    return 'cancelled';
+                }
+                continue;
+            }
+            if (selected === 'openrouter/free') {
+                model = 'openrouter/free';
+            }
+            else {
+                const modelInput = await p.text({
+                    message: 'Enter model name for OpenRouter',
+                    placeholder: 'e.g., anthropic/claude-3.5-sonnet',
+                    validate: (value) => {
+                        const trimmed = typeof value === 'string' ? value.trim() : '';
+                        if (!trimmed)
+                            return 'Model name is required';
+                        return undefined;
+                    },
+                });
+                if (p.isCancel(modelInput)) {
+                    if (options.onCancel === 'exit') {
+                        p.cancel('Setup cancelled');
+                        return 'cancelled';
+                    }
+                    continue;
+                }
+                model = modelInput.trim();
+            }
+        }
+        else {
+            model =
+                getDefaultModelForProvider(provider) ||
+                    (provider === 'google' ? 'gemini-2.5-pro' : 'llama-3.3-70b-versatile');
+        }
+        const apiKeyVar = getProviderEnvVar(provider);
+        let apiKeySkipped = false;
+        // Check if API key exists
+        const hasKey = hasApiKeyConfigured(provider);
+        if (!hasKey) {
+            const providerName = getProviderDisplayName(provider);
+            p.note(`${providerName} is ${chalk.green('free')} to use!\n\n` +
+                `We'll help you get an API key in just a few seconds.`, 'Free AI Access');
+            const result = await interactiveApiKeySetup(provider, {
+                exitOnCancel: false, // Don't exit - allow skipping
+                model,
+            });
+            if (result.cancelled) {
+                if (options.onCancel === 'exit') {
+                    p.cancel('Setup cancelled');
+                    return 'cancelled';
+                }
+                continue;
+            }
+            if (result.skipped || !result.success) {
+                apiKeySkipped = true;
+            }
+        }
+        else {
+            p.log.success(`API key for ${getProviderDisplayName(provider)} already configured`);
+        }
+        // CLI mode confirmation
         const useCli = await p.confirm({
             message: 'Start in Terminal mode? (You can change this later)',
             initialValue: true,
         });
         if (p.isCancel(useCli)) {
-            p.cancel('Setup cancelled');
-            process.exit(0);
+            if (options.onCancel === 'exit') {
+                p.cancel('Setup cancelled');
+                return 'cancelled';
+            }
+            continue;
         }
         const defaultMode = useCli ? 'cli' : await selectDefaultMode();
+        // Handle cancellation
         if (defaultMode === null) {
-            p.cancel('Setup cancelled');
-            process.exit(0);
+            if (options.onCancel === 'exit') {
+                p.cancel('Setup cancelled');
+                return 'cancelled';
+            }
+            continue;
         }
-        // Sync the active model for local provider
-        await setActiveModel(model);
-        const preferences = createInitialPreferences({
-            provider: 'local',
+        // Save preferences
+        const preferencesOptions = {
+            provider,
             model,
             defaultMode,
             setupCompleted: true,
-            apiKeyPending: false,
-        });
+            apiKeyPending: apiKeySkipped,
+        };
+        // Only include apiKeyVar if not skipped
+        if (!apiKeySkipped) {
+            preferencesOptions.apiKeyVar = apiKeyVar;
+        }
+        const preferences = createInitialPreferences(preferencesOptions);
         await saveGlobalPreferences(preferences);
         capture('dexto_setup', {
-            provider: 'local',
+            provider,
             model,
             setupMode: 'interactive',
             setupVariant: 'quick-start',
             defaultMode,
-            apiKeySkipped: false,
-        });
-        await showSetupComplete('local', model, defaultMode, false);
-        return;
-    }
-    // Cloud provider flow (google or groq)
-    const provider = quickProvider;
-    const model = getDefaultModelForProvider(provider) ||
-        (provider === 'google' ? 'gemini-2.5-pro' : 'llama-3.3-70b-versatile');
-    const apiKeyVar = getProviderEnvVar(provider);
-    let apiKeySkipped = false;
-    // Check if API key exists
-    const hasKey = hasApiKeyConfigured(provider);
-    if (!hasKey) {
-        const providerName = getProviderDisplayName(provider);
-        p.note(`${providerName} is ${chalk.green('free')} to use!\n\n` +
-            `We'll help you get an API key in just a few seconds.`, 'Free AI Access');
-        const result = await interactiveApiKeySetup(provider, {
-            exitOnCancel: false, // Don't exit - allow skipping
-            model,
+            apiKeySkipped,
         });
-        if (result.cancelled) {
-            p.cancel('Setup cancelled');
-            process.exit(0);
-        }
-        if (result.skipped || !result.success) {
-            apiKeySkipped = true;
-        }
-    }
-    else {
-        p.log.success(`API key for ${getProviderDisplayName(provider)} already configured`);
-    }
-    // CLI mode confirmation
-    const useCli = await p.confirm({
-        message: 'Start in Terminal mode? (You can change this later)',
-        initialValue: true,
-    });
-    if (p.isCancel(useCli)) {
-        p.cancel('Setup cancelled');
-        process.exit(0);
-    }
-    const defaultMode = useCli ? 'cli' : await selectDefaultMode();
-    // Handle cancellation
-    if (defaultMode === null) {
-        p.cancel('Setup cancelled');
-        process.exit(0);
-    }
-    // Save preferences
-    const preferencesOptions = {
-        provider,
-        model,
-        defaultMode,
-        setupCompleted: true,
-        apiKeyPending: apiKeySkipped,
-    };
-    // Only include apiKeyVar if not skipped
-    if (!apiKeySkipped) {
-        preferencesOptions.apiKeyVar = apiKeyVar;
+        await showSetupComplete(provider, model, defaultMode, apiKeySkipped);
+        return 'completed';
     }
-    const preferences = createInitialPreferences(preferencesOptions);
-    await saveGlobalPreferences(preferences);
-    capture('dexto_setup', {
-        provider,
-        model,
-        setupMode: 'interactive',
-        setupVariant: 'quick-start',
-        defaultMode,
-        apiKeySkipped,
-    });
-    await showSetupComplete(provider, model, defaultMode, apiKeySkipped);
 }
 /**
  * Dexto setup flow - login if needed, select model, save preferences
  *
  * Config storage:
- * - provider: 'dexto' (the gateway provider)
+ * - provider: 'dexto-nova' (the gateway provider)
  * - model: OpenRouter-style ID (e.g., 'anthropic/claude-haiku-4.5')
  *
  * Runtime handles routing requests through the Dexto gateway to the underlying provider.
  */
-async function handleDextoProviderSetup() {
-    console.log(chalk.magenta('\n★ Dexto Setup\n'));
+async function handleDextoProviderSetup(options = {}) {
+    const exitOnCancel = options.exitOnCancel ?? true;
+    const abort = (message, exitCode = 0) => {
+        p.cancel(message);
+        if (exitOnCancel) {
+            process.exit(exitCode);
+        }
+        return false;
+    };
+    console.log(chalk.magenta('\n★ Dexto Nova Setup\n'));
     // Check if user already has DEXTO_API_KEY
     const hasKey = await canUseDextoProvider();
     if (!hasKey) {
@@ -317,32 +406,53 @@ async function handleDextoProviderSetup() {
             initialValue: true,
         });
         if (p.isCancel(shouldLogin) || !shouldLogin) {
-            p.cancel('Setup cancelled');
-            process.exit(0);
+            return abort('Setup cancelled');
         }
         try {
             await handleBrowserLogin();
             // Verify key was actually provisioned (provisionKeys silently catches errors)
             if (!(await canUseDextoProvider())) {
                 p.log.error('API key provisioning failed. Please try again or use `dexto setup` with a different provider.');
-                process.exit(1);
+                return abort('Setup cancelled', 1);
             }
             p.log.success('Login successful! Continuing with setup...');
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             p.log.error(`Login failed: ${errorMessage}`);
-            p.cancel('Setup cancelled - login required for Dexto');
-            process.exit(1);
+            return abort('Setup cancelled - login required for Dexto', 1);
         }
     }
     else {
-        p.log.success('Already logged in to Dexto');
+        const auth = await loadAuth();
+        const userLabel = auth?.email || auth?.userId || 'unknown';
+        p.log.success(`Logged in to Dexto as: ${userLabel}`);
+    }
+    const balance = await getCreditsBalance();
+    if (balance !== null) {
+        p.note(`$${balance.toFixed(2)} remaining`, 'Dexto Nova balance');
+    }
+    const shouldOpenCredits = await p.confirm({
+        message: 'Want to buy or top up Dexto Nova credits now?',
+        initialValue: false,
+    });
+    if (p.isCancel(shouldOpenCredits)) {
+        return abort('Setup cancelled');
+    }
+    if (shouldOpenCredits) {
+        await openCreditsPage();
+        const continueSetup = await p.confirm({
+            message: 'Continue choosing a model?',
+            initialValue: true,
+        });
+        if (p.isCancel(continueSetup) || !continueSetup) {
+            return abort('Setup cancelled');
+        }
     }
     // Model selection - show popular models in OpenRouter format
     // NOTE: This list is intentionally hardcoded (not from registry) to include
     // curated hints for onboarding UX. Keep model IDs in sync with:
-    // packages/core/src/llm/registry.ts (LLM_REGISTRY.dexto.models)
+    // packages/core/src/llm/registry/index.ts (LLM_REGISTRY['dexto-nova'].models)
     const model = await p.select({
         message: 'Select a model to start with',
         options: [
@@ -406,24 +516,27 @@ async function handleDextoProviderSetup() {
                 label: 'Minimax M2.1',
                 hint: 'Fast model with 196k context',
             },
+            {
+                value: 'moonshotai/kimi-k2.5',
+                label: 'Kimi K2.5',
+                hint: 'Multimodal coding model, 262k context',
+            },
         ],
     });
     if (p.isCancel(model)) {
-        p.cancel('Setup cancelled');
-        process.exit(0);
+        return abort('Setup cancelled');
     }
-    // Dexto setup always uses 'dexto' provider with OpenRouter model IDs
-    const provider = 'dexto';
+    // Dexto setup always uses 'dexto-nova' provider with OpenRouter model IDs
+    const provider = 'dexto-nova';
     // Cast model to string (prompts library typing)
     const selectedModel = model;
     p.log.info(`${chalk.dim('Tip:')} You can switch models anytime with ${chalk.cyan('/model')}`);
     // Ask about default mode
     const defaultMode = await selectDefaultMode();
     if (defaultMode === null) {
-        p.cancel('Setup cancelled');
-        process.exit(0);
+        return abort('Setup cancelled');
     }
-    // Save preferences with explicit dexto provider and OpenRouter model ID
+    // Save preferences with explicit dexto-nova provider and OpenRouter model ID
     const preferences = createInitialPreferences({
         provider,
         model: selectedModel,
@@ -437,17 +550,41 @@ async function handleDextoProviderSetup() {
         provider,
         model: selectedModel,
         setupMode: 'interactive',
-        setupVariant: 'dexto',
+        setupVariant: 'dexto-nova',
         defaultMode,
     });
     await showSetupComplete(provider, selectedModel, defaultMode, false);
+    return true;
+}
+async function openCreditsPage() {
+    try {
+        await open(DEXTO_CREDITS_URL);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        p.log.warn(`Unable to open browser: ${errorMessage}`);
+        p.log.info(`Open this link to buy credits: ${DEXTO_CREDITS_URL}`);
+    }
+}
+async function getCreditsBalance() {
+    try {
+        const auth = await loadAuth();
+        if (!auth?.dextoApiKey)
+            return null;
+        const apiClient = getDextoApiClient();
+        const usage = await apiClient.getUsageSummary(auth.dextoApiKey);
+        return usage.credits_usd;
+    }
+    catch {
+        return null;
+    }
 }
 /**
  * Full interactive setup flow with wizard navigation.
  * Users can go back to previous steps to change their selections.
  */
 async function handleInteractiveSetup(_options) {
-    console.log(chalk.cyan('\n🗿 Dexto Setup\n'));
+    console.log(chalk.cyan('\n🗿 Dexto Nova Setup\n'));
     p.intro(chalk.cyan("Let's configure your AI agent"));
     // Initialize wizard state
     let state = { step: 'setupType' };
@@ -484,12 +621,12 @@ async function handleInteractiveSetup(_options) {
  * Wizard Step: Setup Type (Quick Start vs Custom)
  */
 async function wizardStepSetupType(state) {
-    // Build options list - only show Dexto Credits when feature is enabled
+    // Build options list - only show Dexto Nova when feature is enabled
     const options = [];
     if (isDextoAuthEnabled()) {
         options.push({
-            value: 'dexto',
-            label: `${chalk.magenta('★')} Dexto Credits`,
+            value: 'dexto-nova',
+            label: `${chalk.magenta('★')} Dexto Nova`,
             hint: 'All models, one account - login to get started (recommended)',
         });
     }
@@ -510,14 +647,17 @@ async function wizardStepSetupType(state) {
         p.cancel('Setup cancelled');
         process.exit(0);
     }
-    if (setupType === 'dexto') {
-        // Handle Dexto Credits flow - login if needed, then proceed to model selection
+    if (setupType === 'dexto-nova') {
+        // Handle Dexto Nova flow - login if needed, then proceed to model selection
         await handleDextoProviderSetup();
         return { ...state, step: 'complete', quickStartHandled: true };
     }
     if (setupType === 'quick') {
         // Quick start bypasses the wizard - handle it directly
-        await handleQuickStart();
+        const result = await handleQuickStart({ onCancel: 'back' });
+        if (result === 'cancelled') {
+            return { ...state, step: 'setupType' };
+        }
         return { ...state, step: 'complete', quickStartHandled: true };
     }
     return { ...state, step: 'provider', setupType: 'custom' };
@@ -529,8 +669,9 @@ async function wizardStepProvider(state) {
     showStepProgress('provider', state.provider);
     const provider = await selectProvider();
     if (provider === null) {
-        p.cancel('Setup cancelled');
-        process.exit(0);
+        // Treat prompt cancellation as "back" to avoid accidentally exiting the setup wizard.
+        // Users can still cancel setup from the initial setup type step.
+        return { ...state, step: 'setupType', provider: undefined };
     }
     if (provider === '_back') {
         return { ...state, step: 'setupType', provider: undefined };
@@ -578,10 +719,11 @@ async function wizardStepModel(state) {
         baseURL = result;
     }
     // Cloud provider model selection with back option
-    const model = await selectModelWithBack(provider);
-    if (model === '_back') {
+    const selection = await selectModelWithBack(provider);
+    if (selection === '_back') {
         return { ...state, step: 'provider', model: undefined, baseURL: undefined };
     }
+    const model = selection.model;
     // Check if model supports reasoning effort
     const nextStep = isReasoningCapableModel(model) ? 'reasoningEffort' : 'apiKey';
     return { ...state, step: nextStep, model, baseURL };
@@ -619,8 +761,8 @@ async function wizardStepReasoningEffort(state) {
         ],
     });
     if (p.isCancel(result)) {
-        p.cancel('Setup cancelled');
-        process.exit(0);
+        // Treat prompt cancellation as "back" to avoid accidentally exiting the setup wizard.
+        return { ...state, step: 'model', reasoningEffort: undefined };
     }
     if (result === '_back') {
         return { ...state, step: 'model', reasoningEffort: undefined };
@@ -690,22 +832,103 @@ async function wizardStepMode(state) {
 async function selectModelWithBack(provider) {
     const providerInfo = LLM_REGISTRY[provider];
     if (providerInfo?.models && providerInfo.models.length > 0) {
-        const modelOptions = providerInfo.models.map((m) => ({
+        const curatedModels = getCuratedModelsForProvider(provider);
+        if (provider === 'openrouter') {
+            const curatedOptions = curatedModels
+                .slice(0, 8)
+                .filter((m) => m.name !== 'openrouter/free')
+                .map((m) => ({
+                value: m.name,
+                label: m.displayName || m.name,
+            }));
+            if (supportsCustomModels(provider)) {
+                p.log.info(chalk.gray('Tip: You can add or edit custom models via /model'));
+                const manageCustomModels = await p.confirm({
+                    message: 'Manage custom models now?',
+                    initialValue: false,
+                });
+                if (p.isCancel(manageCustomModels)) {
+                    return '_back';
+                }
+                if (manageCustomModels) {
+                    const customModel = await handleCustomModelManagement(provider);
+                    if (customModel) {
+                        return { model: customModel, isCustomSelection: true };
+                    }
+                }
+            }
+            const result = await p.select({
+                message: `Select a model for ${getProviderDisplayName(provider)}`,
+                options: [
+                    {
+                        value: 'openrouter/free',
+                        label: 'OpenRouter Free Models',
+                        hint: '(recommended)',
+                    },
+                    ...curatedOptions,
+                    {
+                        value: '_back',
+                        label: chalk.gray('← Back'),
+                        hint: 'Change provider',
+                    },
+                ],
+            });
+            if (p.isCancel(result)) {
+                return '_back';
+            }
+            return { model: result };
+        }
+        const defaultModel = curatedModels.find((m) => m.default) ??
+            providerInfo.models.find((m) => m.default) ??
+            curatedModels[0] ??
+            providerInfo.models[0];
+        if (!defaultModel) {
+            p.log.warn('No models available for this provider');
+            return '_back';
+        }
+        const curatedOptions = curatedModels
+            .slice(0, 8)
+            .filter((m) => m.name !== defaultModel.name)
+            .map((m) => ({
             value: m.name,
             label: m.displayName || m.name,
         }));
+        if (supportsCustomModels(provider)) {
+            p.log.info(chalk.gray('Tip: You can add or edit custom models via /model'));
+            const manageCustomModels = await p.confirm({
+                message: 'Manage custom models now?',
+                initialValue: false,
+            });
+            if (p.isCancel(manageCustomModels)) {
+                return '_back';
+            }
+            if (manageCustomModels) {
+                const customModel = await handleCustomModelManagement(provider);
+                if (customModel) {
+                    return { model: customModel, isCustomSelection: true };
+                }
+            }
+        }
         const result = await p.select({
             message: `Select a model for ${getProviderDisplayName(provider)}`,
             options: [
-                ...modelOptions,
-                { value: '_back', label: chalk.gray('← Back'), hint: 'Change provider' },
+                {
+                    value: defaultModel.name,
+                    label: defaultModel.displayName || defaultModel.name,
+                    hint: '(recommended)',
+                },
+                ...curatedOptions,
+                {
+                    value: '_back',
+                    label: chalk.gray('← Back'),
+                    hint: 'Change provider',
+                },
             ],
         });
         if (p.isCancel(result)) {
-            p.cancel('Setup cancelled');
-            process.exit(0);
+            return '_back';
         }
-        return result;
+        return { model: result };
     }
     // For providers that accept any model, show text input with back hint
     p.log.info(chalk.gray('Press Ctrl+C to go back'));
@@ -714,7 +937,8 @@ async function selectModelWithBack(provider) {
         message: `Enter model name for ${getProviderDisplayName(provider)}`,
         placeholder: defaultModel || 'e.g., gpt-4-turbo',
         validate: (value) => {
-            if (!value.trim())
+            const trimmed = typeof value === 'string' ? value.trim() : '';
+            if (!trimmed)
                 return 'Model name is required';
             return undefined;
         },
@@ -722,11 +946,255 @@ async function selectModelWithBack(provider) {
     if (p.isCancel(model)) {
         return '_back';
     }
-    return model;
+    return { model: typeof model === 'string' ? model.trim() : '' };
 }
 /**
  * Select default mode with back option
  */
+async function handleCustomModelManagement(providerOverride) {
+    const models = await loadCustomModels();
+    const choices = [
+        { value: 'add', label: 'Add custom model' },
+        ...(models.length > 0 ? [{ value: 'edit', label: 'Edit custom model' }] : []),
+        ...(models.length > 0 ? [{ value: 'delete', label: 'Delete custom model' }] : []),
+        { value: 'back', label: 'Back' },
+    ];
+    const action = await p.select({
+        message: 'Custom models',
+        options: choices,
+    });
+    if (p.isCancel(action) || action === 'back') {
+        return null;
+    }
+    if (action === 'add') {
+        const created = await runCustomModelWizard(null, providerOverride);
+        return created?.name ?? null;
+    }
+    if (action === 'edit') {
+        const selected = await selectCustomModel(models);
+        if (!selected) {
+            return null;
+        }
+        const updated = await runCustomModelWizard(selected, providerOverride);
+        return updated?.name ?? null;
+    }
+    if (action === 'delete') {
+        const model = await selectCustomModel(models);
+        if (!model) {
+            return null;
+        }
+        const confirm = await p.confirm({
+            message: `Delete custom model "${model.displayName || model.name}"?`,
+            initialValue: false,
+        });
+        if (p.isCancel(confirm) || !confirm) {
+            return null;
+        }
+        await deleteCustomModel(model.name);
+        p.log.success(`Deleted ${model.displayName || model.name}`);
+        return null;
+    }
+    return null;
+}
+async function selectCustomModel(models) {
+    if (models.length === 0) {
+        p.log.info('No custom models available.');
+        return null;
+    }
+    const selection = await p.select({
+        message: 'Select a custom model',
+        options: models.map((model) => ({
+            value: model.name,
+            label: model.displayName || model.name,
+        })),
+    });
+    if (p.isCancel(selection)) {
+        return null;
+    }
+    return models.find((model) => model.name === selection) ?? null;
+}
+async function runCustomModelWizard(initialModel, providerOverride) {
+    const values = await promptCustomModelValues(initialModel ?? null, providerOverride);
+    if (!values) {
+        return null;
+    }
+    const model = {
+        name: values.name,
+        provider: values.provider,
+        ...(values.baseURL ? { baseURL: values.baseURL } : {}),
+        ...(values.displayName ? { displayName: values.displayName } : {}),
+        ...(values.maxInputTokens ? { maxInputTokens: values.maxInputTokens } : {}),
+        ...(values.apiKey ? { apiKey: values.apiKey } : {}),
+        ...(values.filePath ? { filePath: values.filePath } : {}),
+        ...(values.reasoningEffort ? { reasoningEffort: values.reasoningEffort } : {}),
+    };
+    await saveCustomModel(model);
+    if (initialModel && initialModel.name !== model.name) {
+        await deleteCustomModel(initialModel.name);
+    }
+    p.log.success(`${initialModel ? 'Updated' : 'Saved'} ${model.displayName || model.name}`);
+    return model;
+}
+async function promptCustomModelValues(initialModel, providerOverride) {
+    const providers = [
+        'openai-compatible',
+        'openrouter',
+        'litellm',
+        'glama',
+        'bedrock',
+        'ollama',
+        'local',
+        'vertex',
+        ...(isDextoAuthEnabled() ? ['dexto-nova'] : []),
+    ];
+    const effectiveProvider = initialModel?.provider ?? providerOverride;
+    let provider;
+    if (effectiveProvider) {
+        provider = effectiveProvider;
+    }
+    else {
+        provider = (await p.select({
+            message: 'Custom model provider',
+            options: providers.map((value) => ({ value, label: value })),
+            initialValue: 'openai-compatible',
+        }));
+        if (p.isCancel(provider)) {
+            return null;
+        }
+    }
+    const name = await p.text({
+        message: 'Model name',
+        initialValue: initialModel?.name ?? '',
+        validate: (value) => {
+            const trimmed = typeof value === 'string' ? value.trim() : '';
+            return trimmed ? undefined : 'Model name is required';
+        },
+    });
+    if (p.isCancel(name)) {
+        return null;
+    }
+    const trimmedName = typeof name === 'string' ? name.trim() : '';
+    if (provider === 'openrouter' || provider === 'glama' || provider === 'dexto-nova') {
+        const isValidFormat = trimmedName.includes('/');
+        if (!isValidFormat) {
+            p.log.warn('Model name should include a provider prefix, e.g. anthropic/claude-3.5');
+        }
+    }
+    const displayName = await p.text({
+        message: 'Display name (optional)',
+        initialValue: initialModel?.displayName ?? '',
+    });
+    if (p.isCancel(displayName)) {
+        return null;
+    }
+    let baseURL;
+    if (provider === 'openai-compatible' || provider === 'litellm') {
+        const baseURLInput = await p.text({
+            message: 'Base URL',
+            initialValue: initialModel?.baseURL?.trim() ?? '',
+            validate: (value) => {
+                const trimmed = typeof value === 'string' ? value.trim() : '';
+                if (!trimmed)
+                    return 'Base URL is required';
+                try {
+                    new URL(trimmed);
+                    return undefined;
+                }
+                catch {
+                    return 'Base URL must be a valid URL';
+                }
+            },
+        });
+        if (p.isCancel(baseURLInput)) {
+            return null;
+        }
+        const baseURLValue = typeof baseURLInput === 'string' ? baseURLInput.trim() : '';
+        baseURL = baseURLValue || undefined;
+    }
+    const maxInputTokensInput = await p.text({
+        message: 'Max input tokens (optional)',
+        initialValue: initialModel?.maxInputTokens?.toString() ?? '',
+        validate: (value) => {
+            const trimmed = typeof value === 'string' ? value.trim() : '';
+            if (!trimmed)
+                return undefined;
+            const parsed = Number(value);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                return 'Enter a positive integer';
+            }
+            return undefined;
+        },
+    });
+    if (p.isCancel(maxInputTokensInput)) {
+        return null;
+    }
+    let apiKey;
+    if (provider !== 'bedrock' && provider !== 'vertex') {
+        const apiKeyInput = await p.text({
+            message: 'API key (optional)',
+            initialValue: initialModel?.apiKey ?? '',
+        });
+        if (p.isCancel(apiKeyInput)) {
+            return null;
+        }
+        const apiKeyValue = typeof apiKeyInput === 'string' ? apiKeyInput.trim() : '';
+        apiKey = apiKeyValue || undefined;
+    }
+    let filePath;
+    if (provider === 'local') {
+        const filePathInput = await p.text({
+            message: 'GGUF file path',
+            initialValue: initialModel?.filePath ?? '',
+            validate: (value) => {
+                const trimmed = typeof value === 'string' ? value.trim() : '';
+                if (!trimmed)
+                    return 'File path is required';
+                if (!trimmed.toLowerCase().endsWith('.gguf')) {
+                    return 'File path must end with .gguf';
+                }
+                return undefined;
+            },
+        });
+        if (p.isCancel(filePathInput)) {
+            return null;
+        }
+        const filePathValue = typeof filePathInput === 'string' ? filePathInput.trim() : '';
+        filePath = filePathValue || undefined;
+    }
+    const reasoningEffort = await p.text({
+        message: 'Reasoning effort (optional)',
+        initialValue: initialModel?.reasoningEffort?.toLowerCase() ?? '',
+        validate: (value) => {
+            const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+            if (!normalized)
+                return undefined;
+            const validValues = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+            if (!validValues.includes(normalized)) {
+                return `Use: ${validValues.join(', ')}`;
+            }
+            return undefined;
+        },
+    });
+    if (p.isCancel(reasoningEffort)) {
+        return null;
+    }
+    const trimmedDisplayName = typeof displayName === 'string' ? displayName.trim() : '';
+    const trimmedApiKey = typeof apiKey === 'string' ? apiKey.trim() : '';
+    const trimmedReasoningEffort = typeof reasoningEffort === 'string' ? reasoningEffort.trim().toLowerCase() : '';
+    const trimmedMaxInputTokens = typeof maxInputTokensInput === 'string' ? maxInputTokensInput.trim() : '';
+    return {
+        name: trimmedName,
+        provider,
+        ...(baseURL ? { baseURL } : {}),
+        ...(trimmedDisplayName ? { displayName: trimmedDisplayName } : {}),
+        ...(trimmedMaxInputTokens ? { maxInputTokens: Number(trimmedMaxInputTokens) } : {}),
+        ...(trimmedApiKey ? { apiKey: trimmedApiKey } : {}),
+        ...(filePath ? { filePath } : {}),
+        ...(trimmedReasoningEffort
+            ? { reasoningEffort: trimmedReasoningEffort }
+            : {}),
+    };
+}
 async function selectDefaultModeWithBack() {
     const result = await p.select({
         message: 'How do you want to use Dexto by default?',
@@ -863,40 +1331,50 @@ async function showSettingsMenu() {
             ].join('\n');
             p.note(currentConfig, 'Current Configuration');
         }
+        const currentProviderLabel = currentPrefs?.llm.provider ?? 'not set';
+        const currentModelLabel = currentPrefs?.llm.model || 'not set';
+        const options = [
+            {
+                value: 'model',
+                label: 'Change model',
+                hint: `Currently: ${currentProviderLabel} / ${currentModelLabel}`,
+            },
+            {
+                value: 'mode',
+                label: 'Change default mode',
+                hint: `Currently: ${currentPrefs?.defaults.defaultMode || 'web'}`,
+            },
+            {
+                value: 'apikey',
+                label: 'Update API key',
+                hint: 'Re-enter your API key',
+            },
+            {
+                value: 'reset',
+                label: 'Reset to defaults',
+                hint: 'Start fresh with a new configuration',
+            },
+            {
+                value: 'file',
+                label: 'View preferences file',
+                hint: 'See where your settings are stored',
+            },
+            {
+                value: 'exit',
+                label: 'Exit',
+                hint: 'Done making changes',
+            },
+        ];
+        if (isDextoAuthEnabled()) {
+            options.splice(2, 0, {
+                value: 'credits',
+                label: 'Buy Dexto Nova credits',
+                hint: 'Open billing page in your browser',
+            });
+        }
         const action = await p.select({
             message: 'What would you like to do?',
-            options: [
-                {
-                    value: 'model',
-                    label: 'Change model',
-                    hint: `Currently: ${currentPrefs?.llm.provider || 'not set'} / ${currentPrefs?.llm.model || 'not set'}`,
-                },
-                {
-                    value: 'mode',
-                    label: 'Change default mode',
-                    hint: `Currently: ${currentPrefs?.defaults.defaultMode || 'web'}`,
-                },
-                {
-                    value: 'apikey',
-                    label: 'Update API key',
-                    hint: 'Re-enter your API key',
-                },
-                {
-                    value: 'reset',
-                    label: 'Reset to defaults',
-                    hint: 'Start fresh with a new configuration',
-                },
-                {
-                    value: 'file',
-                    label: 'View preferences file',
-                    hint: 'See where your settings are stored',
-                },
-                {
-                    value: 'exit',
-                    label: 'Exit',
-                    hint: 'Done making changes',
-                },
-            ],
+            options,
         });
         // Exit conditions
         if (p.isCancel(action) || action === 'exit') {
@@ -911,6 +1389,9 @@ async function showSettingsMenu() {
             case 'mode':
                 await changeDefaultMode();
                 break;
+            case 'credits':
+                await openCreditsPage();
+                break;
             case 'apikey':
                 await updateApiKey(currentPrefs?.llm.provider);
                 break;
@@ -942,8 +1423,8 @@ async function changeModel(currentProvider) {
             message: 'Choose your model source',
             options: [
                 {
-                    value: 'dexto',
-                    label: `${chalk.magenta('★')} Dexto Credits`,
+                    value: 'dexto-nova',
+                    label: `${chalk.magenta('★')} Dexto Nova`,
                     hint: 'All models, one account',
                 },
                 {
@@ -957,9 +1438,12 @@ async function changeModel(currentProvider) {
             p.log.warn('Model change cancelled');
             return;
         }
-        if (providerChoice === 'dexto') {
+        if (providerChoice === 'dexto-nova') {
             // Use the same Dexto setup flow as first-time setup
-            await handleDextoProviderSetup();
+            const completed = await handleDextoProviderSetup({ exitOnCancel: false });
+            if (!completed) {
+                return;
+            }
             return;
         }
         // 'other' - fall through to normal provider selection
@@ -1241,20 +1725,89 @@ async function selectModel(provider) {
     const providerInfo = LLM_REGISTRY[provider];
     // For providers with a fixed model list
     if (providerInfo?.models && providerInfo.models.length > 0) {
-        const options = providerInfo.models.map((m) => {
-            const option = {
+        const curatedModels = getCuratedModelsForProvider(provider);
+        if (provider === 'openrouter') {
+            const curatedOptions = curatedModels
+                .slice(0, 8)
+                .filter((m) => m.name !== 'openrouter/free')
+                .map((m) => ({
                 value: m.name,
                 label: m.displayName || m.name,
-            };
-            if (m.default) {
-                option.hint = '(default)';
+            }));
+            if (supportsCustomModels(provider)) {
+                p.log.info(chalk.gray('Tip: You can add or edit custom models via /model'));
+                const manageCustomModels = await p.confirm({
+                    message: 'Manage custom models now?',
+                    initialValue: false,
+                });
+                if (p.isCancel(manageCustomModels)) {
+                    return null;
+                }
+                if (manageCustomModels) {
+                    const customModel = await handleCustomModelManagement(provider);
+                    if (customModel) {
+                        return customModel;
+                    }
+                }
             }
-            return option;
-        });
+            const selected = await p.select({
+                message: `Select a model for ${getProviderDisplayName(provider)}`,
+                options: [
+                    {
+                        value: 'openrouter/free',
+                        label: 'OpenRouter Free Models',
+                        hint: '(recommended)',
+                    },
+                    ...curatedOptions,
+                ],
+                initialValue: 'openrouter/free',
+            });
+            if (p.isCancel(selected)) {
+                return null;
+            }
+            return selected;
+        }
+        const defaultModel = curatedModels.find((m) => m.default) ??
+            providerInfo.models.find((m) => m.default) ??
+            curatedModels[0] ??
+            providerInfo.models[0];
+        if (!defaultModel) {
+            return null;
+        }
+        const curatedOptions = curatedModels
+            .slice(0, 8)
+            .filter((m) => m.name !== defaultModel.name)
+            .map((m) => ({
+            value: m.name,
+            label: m.displayName || m.name,
+        }));
+        if (supportsCustomModels(provider)) {
+            p.log.info(chalk.gray('Tip: You can add or edit custom models via /model'));
+            const manageCustomModels = await p.confirm({
+                message: 'Manage custom models now?',
+                initialValue: false,
+            });
+            if (p.isCancel(manageCustomModels)) {
+                return null;
+            }
+            if (manageCustomModels) {
+                const customModel = await handleCustomModelManagement(provider);
+                if (customModel) {
+                    return customModel;
+                }
+            }
+        }
         const selected = await p.select({
             message: `Select a model for ${getProviderDisplayName(provider)}`,
-            options,
-            initialValue: providerInfo.models.find((m) => m.default)?.name,
+            options: [
+                {
+                    value: defaultModel.name,
+                    label: defaultModel.displayName || defaultModel.name,
+                    hint: '(recommended)',
+                },
+                ...curatedOptions,
+            ],
+            initialValue: defaultModel.name,
         });
         if (p.isCancel(selected)) {
             return null;
@@ -1266,7 +1819,8 @@ async function selectModel(provider) {
         message: `Enter model name for ${getProviderDisplayName(provider)}`,
         placeholder: provider === 'openrouter' ? 'e.g., anthropic/claude-3.5-sonnet' : 'e.g., llama-3-70b',
         validate: (value) => {
-            if (!value || value.trim().length === 0) {
+            const trimmed = typeof value === 'string' ? value.trim() : '';
+            if (!trimmed) {
                 return 'Model name is required';
             }
             return undefined;
@@ -1275,6 +1829,9 @@ async function selectModel(provider) {
     if (p.isCancel(modelInput)) {
         return null;
     }
+    if (typeof modelInput !== 'string') {
+        return null;
+    }
     return modelInput.trim();
 }
 /**
@@ -1292,11 +1849,12 @@ async function promptForBaseURL(provider) {
         message: `Enter base URL for ${getProviderDisplayName(provider)}`,
         placeholder,
         validate: (value) => {
-            if (!value || value.trim().length === 0) {
+            const trimmed = typeof value === 'string' ? value.trim() : '';
+            if (!trimmed) {
                 return 'Base URL is required for this provider';
             }
             try {
-                new URL(value.trim());
+                new URL(trimmed);
             }
             catch {
                 return 'Please enter a valid URL';
@@ -1307,7 +1865,7 @@ async function promptForBaseURL(provider) {
     if (p.isCancel(baseURL)) {
         return null;
     }
-    return baseURL.trim();
+    return typeof baseURL === 'string' ? baseURL.trim() : '';
 }
 /**
  * Show setup complete message
@@ -1342,6 +1900,7 @@ async function showSetupComplete(provider, model, defaultMode, apiKeySkipped = f
         ...(isLocalProvider
             ? [`  Run ${chalk.cyan('dexto setup')} again to manage local models`]
             : []),
+        `  In the interactive CLI, run ${chalk.cyan('/model')} to switch models`,
         `  Run ${chalk.cyan('dexto --help')} for more options`,
     ].join('\n');
     console.log(summary);