dexto 1.8.1 → 1.8.2

package/dist/cli/commands/setup.js

@@ -1,16 +1,12 @@
 // packages/cli/src/cli/commands/setup.ts
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
 import chalk from 'chalk';
 import { z } from 'zod';
-import open from 'open';
 import { acceptsAnyModel, getDefaultModelForProvider, getReasoningProfile, getSupportedModels, isValidProviderModel, LLM_PROVIDERS, LLM_REGISTRY, requiresApiKey, supportsCustomModels, } from '@dexto/llm';
-import { CodexAppServerClient, createCodexBaseURL, getCodexAuthModeLabel, getCodexProviderDisplayName, getCuratedModelsForProvider, isCodexBaseURL, logger, parseCodexBaseURL, resolveApiKeyForProvider, } from '@dexto/core';
-import { createInitialPreferences, saveGlobalPreferences, loadGlobalPreferences, getGlobalPreferencesPath, updateGlobalPreferences, setActiveModel, isDextoAuthEnabled, loadCustomModels, saveCustomModel, deleteCustomModel, globalPreferencesExist, getDextoGlobalPath, } from '@dexto/agent-management';
+import { getCuratedModelsForProvider, logger, resolveApiKeyForProvider } from '@dexto/core';
+import { createInitialPreferences, saveGlobalPreferences, loadGlobalPreferences, getGlobalPreferencesPath, updateGlobalPreferences, setActiveModel, isDextoAuthEnabled, loadCustomModels, saveCustomModel, deleteCustomModel, globalPreferencesExist, getDefaultModelAuthProfile, loadModelAuthProfilesSync, } 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 { executeCommand } from '../utils/self-management.js';
 import { requiresSetup } from '../utils/setup-utils.js';
 import { canUseDextoProvider } from '../utils/dexto-setup.js';
 import { handleAutoLogin } from './auth/login.js';
@@ -77,13 +73,6 @@ const REASONING_VARIANT_HINTS = {
     max: 'Maximum reasoning within provider limits',
     xhigh: 'Extra high reasoning',
 };
-const OPENAI_CODEX_PACKAGE = '@openai/codex';
-const DEXTO_DEPS_PACKAGE_JSON = {
-    name: 'dexto-deps',
-    version: '1.0.0',
-    private: true,
-    description: 'Managed dependencies for Dexto',
-};
 function toReasoningVariantLabel(variant, defaultVariant) {
     const normalized = variant.toLowerCase();
     const withKnownCasing = normalized === 'xhigh'
@@ -104,6 +93,16 @@ function getReasoningVariantSelectOptions(variants, defaultVariant) {
         hint: REASONING_VARIANT_HINTS[variant] ?? 'Model/provider-native reasoning variant',
     }));
 }
+function hasUsableModelAuthProfile(provider) {
+    const profile = getDefaultModelAuthProfile(loadModelAuthProfilesSync(), provider);
+    if (!profile) {
+        return false;
+    }
+    if (profile.credential.type === 'api_key_env') {
+        return Boolean(process.env[profile.credential.envVar]?.trim());
+    }
+    return true;
+}
 /**
  * Get the steps to display for the current provider and model.
  * - Local/Ollama providers skip the API Key step.
@@ -358,7 +357,7 @@ async function handleQuickStart(options = { onCancel: 'exit' }) {
         const apiKeyVar = getProviderEnvVar(provider);
         let apiKeySkipped = false;
         // Check if API key exists
-        const hasKey = hasApiKeyConfigured(provider);
+        const hasKey = hasApiKeyConfigured(provider) || hasUsableModelAuthProfile(provider);
         if (!hasKey) {
             const providerName = getProviderDisplayName(provider);
             p.note(`${providerName} is ${chalk.green('free')} to use!\n\n` +
@@ -411,7 +410,7 @@ async function handleQuickStart(options = { onCancel: 'exit' }) {
             apiKeyPending: apiKeySkipped,
         };
         // Only include apiKeyVar if not skipped
-        if (!apiKeySkipped) {
+        if (!apiKeySkipped && hasApiKeyConfigured(provider)) {
             preferencesOptions.apiKeyVar = apiKeyVar;
         }
         const preferences = createInitialPreferences(preferencesOptions);
@@ -428,316 +427,6 @@ async function handleQuickStart(options = { onCancel: 'exit' }) {
         return 'completed';
     }
 }
-function getConfiguredProviderDisplayName(provider, baseURL) {
-    if (provider === 'openai-compatible') {
-        const codex = parseCodexBaseURL(baseURL);
-        if (codex) {
-            return getCodexProviderDisplayName(codex.authMode);
-        }
-    }
-    return getProviderDisplayName(provider);
-}
-function isCodexConfigured(provider, baseURL) {
-    return provider === 'openai-compatible' && isCodexBaseURL(baseURL);
-}
-async function ensureDextoDepsPackageJson() {
-    const depsDir = getDextoGlobalPath('deps');
-    await fs.mkdir(depsDir, { recursive: true });
-    const packageJsonPath = path.join(depsDir, 'package.json');
-    try {
-        await fs.access(packageJsonPath);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT') {
-            throw error;
-        }
-        await fs.writeFile(packageJsonPath, JSON.stringify(DEXTO_DEPS_PACKAGE_JSON, null, 2), 'utf-8');
-    }
-    return depsDir;
-}
-function isMissingCodexCliError(error) {
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    const code = error.code;
-    return (error.message.includes('Codex CLI not found on PATH') ||
-        error.message.includes('spawn codex ENOENT') ||
-        (code === 'ENOENT' && error.message.includes('spawn')));
-}
-function getCodexSetupErrorMessage(error) {
-    if (isMissingCodexCliError(error)) {
-        return 'Codex CLI not found on PATH. Install Codex to use ChatGPT Login in Dexto.';
-    }
-    return error instanceof Error ? error.message : String(error);
-}
-async function resolveCodexInstaller() {
-    const candidates = [
-        {
-            command: 'npm',
-            args: ['install', OPENAI_CODEX_PACKAGE, '--no-audit', '--no-fund'],
-            label: 'npm',
-        },
-        {
-            command: 'pnpm',
-            args: ['add', OPENAI_CODEX_PACKAGE],
-            label: 'pnpm',
-        },
-        {
-            command: 'bun',
-            args: ['add', OPENAI_CODEX_PACKAGE],
-            label: 'bun',
-        },
-    ];
-    for (const candidate of candidates) {
-        const probe = await executeCommand(candidate.command, ['--version']);
-        if (probe.code === 0) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function getCodexInstallerFailureMessage(installer, result) {
-    const details = `${result.stderr}\n${result.stdout}`
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-    const lastLine = details.at(-1);
-    return lastLine
-        ? `Failed to install the OpenAI Codex CLI via ${installer.label}: ${lastLine}`
-        : `Failed to install the OpenAI Codex CLI via ${installer.label}.`;
-}
-async function installManagedCodexCli() {
-    const depsDir = await ensureDextoDepsPackageJson();
-    const installer = await resolveCodexInstaller();
-    if (!installer) {
-        throw new Error('Could not find npm, pnpm, or bun to install the OpenAI Codex CLI automatically.');
-    }
-    const result = await executeCommand(installer.command, installer.args, { cwd: depsDir });
-    if (result.code !== 0) {
-        throw new Error(getCodexInstallerFailureMessage(installer, result));
-    }
-}
-async function createCodexClientForSetup() {
-    try {
-        return await CodexAppServerClient.create();
-    }
-    catch (error) {
-        if (!isMissingCodexCliError(error)) {
-            throw error;
-        }
-        const spinner = p.spinner();
-        spinner.start('Installing OpenAI Codex CLI...');
-        try {
-            await installManagedCodexCli();
-            spinner.stop('OpenAI Codex CLI installed');
-        }
-        catch (installError) {
-            spinner.stop('OpenAI Codex CLI installation failed');
-            throw installError;
-        }
-        return await CodexAppServerClient.create();
-    }
-}
-async function ensureCodexChatGPTLogin(client) {
-    const spinner = p.spinner();
-    spinner.start('Starting ChatGPT login with Codex...');
-    const login = await client.startLogin({ type: 'chatgpt' });
-    if (login.type !== 'chatgpt') {
-        spinner.stop('ChatGPT login failed');
-        throw new Error('Codex did not return a ChatGPT login URL');
-    }
-    spinner.stop('ChatGPT login ready');
-    try {
-        await open(login.authUrl);
-        p.log.success('Opened your browser for ChatGPT login');
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        p.log.warn(`Could not open browser automatically: ${errorMessage}`);
-    }
-    p.note(`Finish the ChatGPT login in your browser.\n\n${chalk.dim(login.authUrl)}`, 'ChatGPT Login');
-    const waitSpinner = p.spinner();
-    waitSpinner.start('Waiting for ChatGPT login to complete...');
-    const completed = await client.waitForLoginCompleted(login.loginId, {
-        timeoutMs: 5 * 60 * 1000,
-    });
-    if (!completed.success) {
-        waitSpinner.stop('ChatGPT login failed');
-        throw new Error(completed.error ?? 'Codex ChatGPT login failed');
-    }
-    waitSpinner.stop('ChatGPT login complete');
-    return await client.readAccount(true);
-}
-async function ensureCodexChatGPTSession(client) {
-    const current = await client.readAccount(false);
-    if (current.account?.type === 'chatgpt') {
-        return current;
-    }
-    if (current.account) {
-        const currentLabel = 'OpenAI API key';
-        const shouldSwitch = await p.confirm({
-            message: `Codex is currently using ${currentLabel}. Switch to ChatGPT login?`,
-            initialValue: true,
-        });
-        if (p.isCancel(shouldSwitch) || !shouldSwitch) {
-            return null;
-        }
-        await client.logout();
-    }
-    return await ensureCodexChatGPTLogin(client);
-}
-function getCodexModelOptions(models) {
-    const visibleModels = models.filter((model) => !model.hidden);
-    const defaultModel = visibleModels.find((model) => model.isDefault) ?? visibleModels[0] ?? null;
-    if (!defaultModel) {
-        return [];
-    }
-    const secondaryModels = visibleModels
-        .filter((model) => model.model !== defaultModel.model)
-        .slice(0, 9);
-    return [
-        {
-            value: defaultModel.model,
-            label: defaultModel.displayName,
-            hint: `${defaultModel.description || 'Recommended'} (recommended)`,
-        },
-        ...secondaryModels.map((model) => ({
-            value: model.model,
-            label: model.displayName,
-            hint: model.description || model.model,
-        })),
-    ];
-}
-/**
- * ChatGPT Login setup flow - authenticate with ChatGPT through Codex, choose a model, save preferences
- *
- * Config storage:
- * - provider: 'openai-compatible'
- * - baseURL: special 'codex://chatgpt' URI resolved at runtime to Codex app-server
- * - model: model ID returned by Codex model/list
- */
-async function handleCodexProviderSetup(options = {}) {
-    const exitOnCancel = options.exitOnCancel ?? true;
-    const abort = (message, exitCode = 0) => {
-        p.cancel(message);
-        if (exitOnCancel) {
-            process.exit(exitCode);
-        }
-        return false;
-    };
-    console.log(chalk.cyan('\nChatGPT Login Setup\n'));
-    let client = null;
-    try {
-        client = await createCodexClientForSetup();
-        const account = await ensureCodexChatGPTSession(client);
-        if (!account || account.account?.type !== 'chatgpt') {
-            return abort('Setup cancelled');
-        }
-        p.log.success(`Codex authenticated with ChatGPT as ${account.account.email} (${account.account.planType})`);
-        const models = await client.listModels();
-        const modelOptions = getCodexModelOptions(models);
-        if (modelOptions.length === 0) {
-            p.log.error('Codex did not return any available models.');
-            return abort('Setup cancelled', 1);
-        }
-        const model = await p.select({
-            message: 'Select a model to start with',
-            options: modelOptions,
-        });
-        if (p.isCancel(model)) {
-            return abort('Setup cancelled');
-        }
-        const selectedModel = model;
-        const provider = 'openai-compatible';
-        const baseURL = createCodexBaseURL('chatgpt');
-        const codexReasoningProfile = getReasoningProfile(provider, selectedModel);
-        let reasoningPreset;
-        if (codexReasoningProfile.capable) {
-            const selectedReasoning = await p.select({
-                message: 'Select reasoning variant',
-                options: getReasoningVariantSelectOptions(codexReasoningProfile.supportedVariants, codexReasoningProfile.defaultVariant),
-                ...(codexReasoningProfile.defaultVariant
-                    ? { initialValue: codexReasoningProfile.defaultVariant }
-                    : {}),
-            });
-            if (p.isCancel(selectedReasoning)) {
-                return abort('Setup cancelled');
-            }
-            if (selectedReasoning !== codexReasoningProfile.defaultVariant) {
-                reasoningPreset = selectedReasoning;
-            }
-        }
-        const defaultMode = await selectDefaultMode();
-        if (defaultMode === null) {
-            return abort('Setup cancelled');
-        }
-        const preferences = createInitialPreferences({
-            provider,
-            model: selectedModel,
-            baseURL,
-            defaultMode,
-            setupCompleted: true,
-            apiKeyPending: false,
-            ...(reasoningPreset ? { reasoning: { variant: reasoningPreset } } : {}),
-        });
-        await saveGlobalPreferences(preferences);
-        capture('dexto_setup', {
-            provider,
-            model: selectedModel,
-            setupMode: 'interactive',
-            setupVariant: 'codex-chatgpt',
-            defaultMode,
-            hasBaseURL: true,
-        });
-        await showSetupComplete(provider, selectedModel, defaultMode, false, {
-            providerLabel: getCodexProviderDisplayName('chatgpt'),
-            authLabel: getCodexAuthModeLabel('chatgpt'),
-            baseURL,
-        });
-        return true;
-    }
-    catch (error) {
-        const errorMessage = getCodexSetupErrorMessage(error);
-        p.log.error(`ChatGPT Login setup failed: ${errorMessage}`);
-        return abort('Setup cancelled', 1);
-    }
-    finally {
-        if (client) {
-            await client.close().catch(() => undefined);
-        }
-    }
-}
-async function handleCodexChatGPTLoginRefresh(options = {}) {
-    const exitOnCancel = options.exitOnCancel ?? true;
-    const abort = (message, exitCode = 0) => {
-        p.cancel(message);
-        if (exitOnCancel) {
-            process.exit(exitCode);
-        }
-        return false;
-    };
-    console.log(chalk.cyan('\nChatGPT Login\n'));
-    let client = null;
-    try {
-        client = await createCodexClientForSetup();
-        const account = await ensureCodexChatGPTSession(client);
-        if (!account || account.account?.type !== 'chatgpt') {
-            return abort('ChatGPT login cancelled');
-        }
-        p.log.success(`Codex authenticated with ChatGPT as ${account.account.email} (${account.account.planType})`);
-        return true;
-    }
-    catch (error) {
-        const errorMessage = getCodexSetupErrorMessage(error);
-        p.log.error(`ChatGPT Login failed: ${errorMessage}`);
-        return abort('ChatGPT login cancelled', 1);
-    }
-    finally {
-        if (client) {
-            await client.close().catch(() => undefined);
-        }
-    }
-}
 /**
  * Dexto setup flow - login if needed, select model, save preferences
  *
@@ -990,10 +679,6 @@ async function wizardStepSetupType(state) {
         });
     }
     options.push({
-        value: 'openai-codex',
-        label: `${chalk.green('●')} ChatGPT Login`,
-        hint: 'Use your ChatGPT account through Codex',
-    }, {
         value: 'quick',
         label: `${chalk.blue('●')} Quick Start`,
         hint: 'Google Gemini (free) - no account needed',
@@ -1015,13 +700,6 @@ async function wizardStepSetupType(state) {
         await handleDextoProviderSetup();
         return { ...state, step: 'complete', quickStartHandled: true };
     }
-    if (setupType === 'openai-codex') {
-        const completed = await handleCodexProviderSetup({ exitOnCancel: false });
-        if (!completed) {
-            return { ...state, step: 'setupType' };
-        }
-        return { ...state, step: 'complete', quickStartHandled: true };
-    }
     if (setupType === 'quick') {
         // Quick start bypasses the wizard - handle it directly
         const result = await handleQuickStart({
@@ -1140,7 +818,7 @@ async function wizardStepApiKey(state) {
     const provider = state.provider;
     const model = state.model;
     showStepProgress('apiKey', provider, model);
-    const hasKey = hasApiKeyConfigured(provider);
+    const hasKey = hasApiKeyConfigured(provider) || hasUsableModelAuthProfile(provider);
     const needsApiKey = requiresApiKey(provider);
     if (needsApiKey && !hasKey) {
         const result = await interactiveApiKeySetup(provider, {
@@ -1184,7 +862,9 @@ async function wizardStepMode(state) {
                 defaultMode: undefined,
             };
         }
-        const canShowApiKeyStep = requiresApiKey(provider) && !hasApiKeyConfigured(provider);
+        const canShowApiKeyStep = requiresApiKey(provider) &&
+            !hasApiKeyConfigured(provider) &&
+            !hasUsableModelAuthProfile(provider);
         let prevStep = 'model';
         if (canShowApiKeyStep) {
             prevStep = 'apiKey';
@@ -1611,7 +1291,7 @@ async function saveWizardPreferences(state) {
         setupCompleted: true,
         apiKeyPending: apiKeySkipped,
     };
-    if (needsApiKey && !apiKeySkipped) {
+    if (needsApiKey && !apiKeySkipped && hasApiKeyConfigured(provider)) {
         preferencesOptions.apiKeyVar = apiKeyVar;
     }
     if (state.baseURL) {
@@ -1632,17 +1312,7 @@ async function saveWizardPreferences(state) {
         hasBaseURL: Boolean(state.baseURL),
         apiKeySkipped,
     });
-    const codex = parseCodexBaseURL(state.baseURL);
-    const codexSetupOptions = codex && typeof state.baseURL === 'string'
-        ? {
-            providerLabel: getCodexProviderDisplayName(codex.authMode),
-            authLabel: getCodexAuthModeLabel(codex.authMode),
-            baseURL: state.baseURL,
-        }
-        : {};
-    await showSetupComplete(provider, model, defaultMode, apiKeySkipped, {
-        ...codexSetupOptions,
-    });
+    await showSetupComplete(provider, model, defaultMode, apiKeySkipped);
 }
 /**
  * Non-interactive setup with CLI options
@@ -1709,14 +1379,10 @@ async function showSettingsMenu() {
         }
         // Show current configuration
         if (currentPrefs) {
-            const codex = parseCodexBaseURL(currentPrefs.llm.baseURL);
             const currentConfig = [
-                `Provider: ${chalk.cyan(getConfiguredProviderDisplayName(currentPrefs.llm.provider, currentPrefs.llm.baseURL))}`,
+                `Provider: ${chalk.cyan(getProviderDisplayName(currentPrefs.llm.provider))}`,
                 `Model: ${chalk.cyan(currentPrefs.llm.model)}`,
                 `Default Mode: ${chalk.cyan(currentPrefs.defaults.defaultMode)}`,
-                ...(codex
-                    ? [`Authentication: ${chalk.cyan(getCodexAuthModeLabel(codex.authMode))}`]
-                    : []),
                 ...(currentPrefs.llm.baseURL
                     ? [`Base URL: ${chalk.cyan(currentPrefs.llm.baseURL)}`]
                     : []),
@@ -1732,14 +1398,9 @@ async function showSettingsMenu() {
             p.note(currentConfig, 'Current Configuration');
         }
         const currentProviderLabel = currentPrefs
-            ? getConfiguredProviderDisplayName(currentPrefs.llm.provider, currentPrefs.llm.baseURL)
+            ? getProviderDisplayName(currentPrefs.llm.provider)
             : 'not set';
         const currentModelLabel = currentPrefs?.llm.model || 'not set';
-        const currentCodex = currentPrefs ? parseCodexBaseURL(currentPrefs.llm.baseURL) : null;
-        const authActionLabel = currentCodex ? 'Manage ChatGPT login' : 'Update API key';
-        const authActionHint = currentCodex
-            ? 'Verify or reconnect your ChatGPT login for Codex'
-            : 'Re-enter your API key';
         const options = [
             {
                 value: 'model',
@@ -1753,8 +1414,8 @@ async function showSettingsMenu() {
             },
             {
                 value: 'auth',
-                label: authActionLabel,
-                hint: authActionHint,
+                label: 'Update API key',
+                hint: 'Re-enter your API key',
             },
             {
                 value: 'reset',
@@ -1800,7 +1461,7 @@ async function showSettingsMenu() {
                 await openCreditsPage();
                 break;
             case 'auth':
-                await updateApiKey(currentPrefs?.llm.provider, currentPrefs?.llm.baseURL);
+                await updateApiKey(currentPrefs?.llm.provider);
                 break;
             case 'reset': {
                 // Reset exits the menu after completion, but returns to menu if cancelled
@@ -1821,15 +1482,8 @@ async function showSettingsMenu() {
 /**
  * Change model setting (includes provider selection)
  */
-async function changeModel(currentProvider, currentBaseURL) {
+async function changeModel(currentProvider) {
     let provider = currentProvider ?? null;
-    if (isCodexConfigured(provider ?? undefined, currentBaseURL)) {
-        const completed = await handleCodexProviderSetup({ exitOnCancel: false });
-        if (!completed) {
-            p.log.warn('Model change cancelled');
-        }
-        return;
-    }
     // If no provider specified, show selection
     if (!provider) {
         const sourceOptions = [];
@@ -1841,10 +1495,6 @@ async function changeModel(currentProvider, currentBaseURL) {
             });
         }
         sourceOptions.push({
-            value: 'openai-codex',
-            label: `${chalk.green('●')} ChatGPT Login`,
-            hint: 'Use your ChatGPT account through Codex',
-        }, {
             value: 'other',
             label: `${chalk.blue('●')} Other providers`,
             hint: 'OpenAI, Anthropic, Gemini, Ollama, etc.',
@@ -1865,13 +1515,6 @@ async function changeModel(currentProvider, currentBaseURL) {
             }
             return;
         }
-        if (providerChoice === 'openai-codex') {
-            const completed = await handleCodexProviderSetup({ exitOnCancel: false });
-            if (!completed) {
-                return;
-            }
-            return;
-        }
         // 'other' - fall through to normal provider selection
     }
     // Get provider if not already set
@@ -1950,7 +1593,7 @@ async function changeModel(currentProvider, currentBaseURL) {
     }
     const apiKeyVar = getProviderEnvVar(provider);
     const needsApiKey = requiresApiKey(provider);
-    const hasKey = hasApiKeyConfigured(provider);
+    const hasKey = hasApiKeyConfigured(provider) || hasUsableModelAuthProfile(provider);
     // Check if API key is needed and missing - prompt for it
     if (needsApiKey && !hasKey) {
         const result = await interactiveApiKeySetup(provider, {
@@ -1971,7 +1614,7 @@ async function changeModel(currentProvider, currentBaseURL) {
         model,
     };
     // Only include apiKey for providers that need it
-    if (needsApiKey) {
+    if (needsApiKey && hasApiKeyConfigured(provider)) {
         llmUpdate.apiKey = `$${apiKeyVar}`;
     }
     // Ask for reasoning variant if applicable
@@ -2007,20 +1650,13 @@ async function changeDefaultMode() {
 /**
  * Update authentication for current provider
  */
-async function updateApiKey(currentProvider, currentBaseURL) {
+async function updateApiKey(currentProvider) {
     const provider = currentProvider || (await selectProvider());
     // Handle cancellation or back from selectProvider
     if (provider === null || provider === '_back') {
         p.log.warn('API key update cancelled');
         return;
     }
-    if (isCodexConfigured(provider, currentBaseURL)) {
-        const completed = await handleCodexChatGPTLoginRefresh({ exitOnCancel: false });
-        if (!completed) {
-            p.log.warn('ChatGPT login update cancelled');
-        }
-        return;
-    }
     // Handle providers that use non-API-key authentication
     if (provider === 'vertex') {
         p.note(`Google Vertex AI uses Application Default Credentials (ADC).\n\n` +
@@ -2305,7 +1941,7 @@ async function promptForBaseURL(provider) {
 async function showSetupComplete(provider, model, defaultMode, apiKeySkipped = false, options = {}) {
     const modeCommand = defaultMode === 'web' ? 'dexto' : `dexto --mode ${defaultMode}`;
     const isLocalProvider = provider === 'local' || provider === 'ollama';
-    const providerLabel = options.providerLabel ?? getConfiguredProviderDisplayName(provider, options.baseURL);
+    const providerLabel = options.providerLabel ?? getProviderDisplayName(provider);
     if (apiKeySkipped) {
         console.log(chalk.rgb(255, 165, 0)('\n⚠️  Setup complete (API key pending)\n'));
     }

package/dist/index-main.js

@@ -46,7 +46,7 @@ process.env.DEXTO_CLI_VERSION = cliVersion;
 import { logger, startLlmRegistryAutoUpdate, DextoAgent, isPath } from '@dexto/core';
 import { getAllSupportedModels, getProviderFromModel } from '@dexto/llm';
 import { applyImageDefaults, cleanNullValues, AgentConfigSchema, loadImage, resolveServicesFromConfig, toDextoAgentOptions, } from '@dexto/agent-config';
-import { getDextoPackageRoot, resolveAgentPath, loadAgentConfig, findDextoProjectRoot, globalPreferencesExist, loadGlobalPreferences, resolveBundledScript, enrichAgentConfig, isDextoAuthEnabled, resolveApiKeyForProvider, getPrimaryApiKeyEnvVar, } from '@dexto/agent-management';
+import { getDextoPackageRoot, resolveAgentPath, loadAgentConfig, findDextoProjectRoot, globalPreferencesExist, loadGlobalPreferences, resolveBundledScript, enrichAgentConfig, isDextoAuthEnabled, createModelAuthResolver, resolveApiKeyForProvider, getPrimaryApiKeyEnvVar, } from '@dexto/agent-management';
 import { validateCliOptions, handleCliOptionsError } from './cli/utils/options.js';
 import { validateAgentConfig } from './cli/utils/config-validation.js';
 import { applyCLIOverrides, applyStartupLLMFallback, applyUserPreferences, } from './config/cli-overrides.js';
@@ -208,6 +208,26 @@ program
         safeExit('setup', 1, 'error');
     }
 }));
+program
+    .command('connect')
+    .description('Connect a model provider auth method')
+    .option('--provider <provider>', 'Model provider id')
+    .option('--method <method>', 'Auth method id')
+    .option('--action <action>', 'Existing profile action: use, replace, or delete')
+    .option('--no-interactive', 'Require provider and method flags')
+    .action(withAnalytics('connect', async (options) => {
+    try {
+        const { handleConnectCommand } = await import('./cli/commands/connect.js');
+        await handleConnectCommand(options);
+        safeExit('connect', 0);
+    }
+    catch (err) {
+        if (err instanceof ExitSignal)
+            throw err;
+        console.error(`❌ dexto connect command failed: ${err}`);
+        safeExit('connect', 1, 'error');
+    }
+}));
 registerAgentsCommand({ program });
 // 7) `upgrade` SUB-COMMAND
 program
@@ -357,6 +377,9 @@ async function bootstrapAgentFromGlobalOpts(options) {
         services,
         image,
         hostContext: { workspaceRoot },
+        overrides: {
+            authResolver: createModelAuthResolver(),
+        },
     }));
     await agent.start();
     await (await import('./utils/workspace.js')).applyWorkspaceToAgent(agent, workspaceRoot);
@@ -842,6 +865,7 @@ program
             overrides: {
                 sessionLoggerFactory,
                 mcpAuthProviderFactory,
+                authResolver: createModelAuthResolver(),
             },
         }));
         // Start the agent (initialize async services)