dexto 1.4.0 → 1.5.0

package/dist/cli/utils/api-key-setup.js

@@ -1,155 +1,481 @@
 // packages/cli/src/cli/utils/api-key-setup.ts
 import * as p from '@clack/prompts';
 import chalk from 'chalk';
-import { logger, getPrimaryApiKeyEnvVar, getExecutionContext } from '@dexto/core';
+import { logger, getExecutionContext } from '@dexto/core';
 import { saveProviderApiKey } from '@dexto/agent-management';
 import { applyLayeredEnvironmentLoading } from '../../utils/env.js';
-import { getProviderDisplayName, isValidApiKeyFormat, getProviderInstructions, } from './provider-setup.js';
+import { getProviderDisplayName, validateApiKeyFormat, getProviderInstructions, openApiKeyUrl, getProviderInfo, getProviderEnvVar, PROVIDER_REGISTRY, } from './provider-setup.js';
+import { verifyApiKey } from './api-key-verification.js';
 /**
  * Interactively prompts the user to set up an API key for a specific provider.
- * Used when config validation detects a missing API key for a configured provider.
- * Only handles environment variable setup - does not modify config files.
- * Exits the process if user cancels or setup fails.
+ * Includes browser auto-open, format validation with hints, and API key verification.
+ *
  * @param provider - The specific provider that needs API key setup
+ * @param options - Configuration options
+ * @returns Result indicating success, cancellation, or error
  */
-export async function interactiveApiKeySetup(provider) {
+export async function interactiveApiKeySetup(provider, options = {}) {
+    const { exitOnCancel = true, skipVerification = false, model } = options;
     try {
-        // Welcome message
-        p.intro(chalk.cyan('🔑 API Key Setup '));
-        // Show targeted message for the required provider
+        p.intro(chalk.cyan('🔑 API Key Setup'));
         const instructions = getProviderInstructions(provider);
-        p.note(`Your configuration requires a ${getProviderDisplayName(provider)} API key.\n\n` +
-            (instructions ? instructions.content : 'Please get an API key for this provider.'), chalk.bold(`${getProviderDisplayName(provider)} API Key Required`));
-        // First, ask what they want to do
+        const providerInfo = getProviderInfo(provider);
+        // Show targeted message for the required provider
+        if (instructions) {
+            p.note(`Your configuration requires a ${getProviderDisplayName(provider)} API key.\n\n` +
+                instructions.content, chalk.bold(instructions.title));
+        }
+        // Ask what they want to do - with "Open in browser" option
+        const hasApiKeyUrl = Boolean(providerInfo?.apiKeyUrl);
+        const actionOptions = [
+            ...(hasApiKeyUrl
+                ? [
+                    {
+                        value: 'open-browser',
+                        label: 'Open browser & set up now',
+                        hint: 'Opens the API key page in your browser (recommended)',
+                    },
+                ]
+                : []),
+            {
+                value: 'setup',
+                label: hasApiKeyUrl ? 'I already have a key' : 'Enter API key now',
+                hint: 'Paste an existing API key',
+            },
+            {
+                value: 'skip',
+                label: 'Skip for now',
+                hint: 'Continue without API key - configure later in settings',
+            },
+            {
+                value: 'manual',
+                label: 'View manual instructions',
+                hint: 'See how to set up manually',
+            },
+        ];
         const action = await p.select({
             message: 'What would you like to do?',
-            options: [
-                {
-                    value: 'setup',
-                    label: 'Set up an API key now',
-                    hint: 'Interactive setup (recommended)',
-                },
-                {
-                    value: 'manual',
-                    label: 'Set up manually later',
-                    hint: 'Get instructions for manual setup',
-                },
-                {
-                    value: 'exit',
-                    label: 'Exit',
-                    hint: 'Quit Dexto for now',
-                },
-            ],
+            options: actionOptions,
         });
-        if (action === 'exit') {
-            p.cancel('Setup cancelled. Run dexto again when you have an API key!');
-            process.exit(0);
+        if (p.isCancel(action)) {
+            p.cancel('Setup cancelled');
+            if (exitOnCancel)
+                process.exit(0);
+            return { success: false, cancelled: true };
+        }
+        if (action === 'skip') {
+            p.log.warn('Skipping API key setup. You can configure it later with: dexto setup');
+            return { success: true, skipped: true };
         }
         if (action === 'manual') {
             showManualSetupInstructions(provider);
-            console.log(chalk.dim('\n👋 Run dexto again once you have set up your API key!'));
-            process.exit(0);
+            // Don't exit - let them continue
+            p.log.info('You can configure your API key later with: dexto setup');
+            return { success: true, skipped: true };
         }
-        if (p.isCancel(action)) {
-            p.cancel('Setup cancelled');
-            process.exit(1);
+        // Open browser if requested
+        if (action === 'open-browser') {
+            const spinner = p.spinner();
+            spinner.start('Opening browser...');
+            const opened = await openApiKeyUrl(provider);
+            if (opened) {
+                spinner.stop('Browser opened! Get your API key and paste it below.');
+            }
+            else {
+                spinner.stop(`Could not open browser. Visit: ${providerInfo?.apiKeyUrl}`);
+            }
         }
-        const apiKey = await p.password({
-            message: `Enter your ${getProviderDisplayName(provider)} API key`,
-            mask: '*',
-            validate: (value) => {
-                if (!value || value.trim().length === 0) {
-                    return 'API key is required';
+        // Prompt for API key with improved validation
+        const apiKey = await promptForApiKey(provider);
+        if (!apiKey) {
+            if (exitOnCancel)
+                process.exit(0);
+            return { success: false, cancelled: true };
+        }
+        // Verify API key works (unless skipped)
+        if (!skipVerification) {
+            const verificationResult = await verifyApiKeyWithSpinner(provider, apiKey, model);
+            if (!verificationResult.success) {
+                p.log.error(verificationResult.error || 'API key verification failed');
+                const retryAction = await p.select({
+                    message: 'What would you like to do?',
+                    options: [
+                        {
+                            value: 'retry',
+                            label: 'Try a different API key',
+                            hint: 'Enter a new API key',
+                        },
+                        {
+                            value: 'save-anyway',
+                            label: 'Save anyway',
+                            hint: 'Key might still work - save and continue',
+                        },
+                        {
+                            value: 'skip',
+                            label: 'Skip for now',
+                            hint: 'Continue without saving - configure later',
+                        },
+                    ],
+                });
+                if (p.isCancel(retryAction)) {
+                    if (exitOnCancel)
+                        process.exit(1);
+                    const result = { success: false, cancelled: true };
+                    return result;
                 }
-                if (!isValidApiKeyFormat(value.trim(), provider)) {
-                    return `Invalid ${getProviderDisplayName(provider)} API key format`;
+                if (retryAction === 'retry') {
+                    // Recursive retry
+                    return interactiveApiKeySetup(provider, options);
                 }
-                return undefined;
-            },
-        });
-        if (p.isCancel(apiKey)) {
-            p.cancel('Setup cancelled');
-            process.exit(0);
-        }
-        // Update .env file
-        const spinner = p.spinner();
-        spinner.start('Saving API key...');
-        try {
-            // Update .env file with the API key using smart path detection
-            const meta = await saveProviderApiKey(provider, apiKey.trim(), process.cwd());
-            spinner.stop(`✨ API key saved successfully for ${getProviderDisplayName(provider)} in ${meta.targetEnvPath}!`);
-            p.outro(chalk.green(`✨ API key setup complete!`));
-            // Reload environment variables so the newly saved API key is available
-            await applyLayeredEnvironmentLoading();
-        }
-        catch (error) {
-            spinner.stop('Failed to save API key');
-            logger.error(`Failed to update .env file: ${error}`);
-            // Provide context-aware manual setup instructions
-            let instructions;
-            if (getExecutionContext() === 'global-cli') {
-                instructions =
-                    `1. Create ~/.dexto/.env file\n` +
-                        `2. Add this line: ${getPrimaryApiKeyEnvVar(provider)}=your_api_key_here\n` +
-                        `3. Run dexto again\n\n` +
-                        `Alternatively:\n` +
-                        `• Set environment variable: export ${getPrimaryApiKeyEnvVar(provider)}=your_api_key_here\n` +
-                        `• Or run: dexto setup`;
-            }
-            else {
-                instructions =
-                    `1. Create a .env file in your project root\n` +
-                        `2. Add this line: ${getPrimaryApiKeyEnvVar(provider)}=your_api_key_here\n` +
-                        `3. Run dexto again`;
+                if (retryAction === 'skip') {
+                    p.log.warn('Skipping API key setup. You can configure it later with: dexto setup');
+                    return { success: true, skipped: true };
+                }
+                // retryAction === 'save-anyway' - fall through to save
+                p.log.info('Saving API key despite verification failure...');
             }
-            p.note(`Manual setup required:\n\n${instructions}`, chalk.yellow('Save this API key manually'));
-            console.error(chalk.red('\n❌ API key setup required to continue.'));
-            process.exit(1);
         }
+        // Save API key
+        const saveResult = await saveApiKeyWithSpinner(provider, apiKey);
+        if (!saveResult.success) {
+            showManualSaveInstructions(provider, apiKey);
+            p.log.warn('You can configure API key later with: dexto setup');
+            // Don't fail - return success with the API key for in-memory use
+            return { success: true, apiKey, skipped: true };
+        }
+        p.outro(chalk.green('✨ API key setup complete!'));
+        return { success: true, apiKey };
     }
     catch (error) {
         if (p.isCancel(error)) {
             p.cancel('Setup cancelled');
-            process.exit(0);
+            if (exitOnCancel)
+                process.exit(0);
+            return { success: false, cancelled: true };
         }
-        console.error(chalk.red('\n❌ API key setup required to continue.'));
-        process.exit(1);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error(`API key setup failed: ${errorMessage}`);
+        if (exitOnCancel) {
+            console.error(chalk.red('\n❌ API key setup required to continue.'));
+            process.exit(1);
+        }
+        return { success: false, error: errorMessage };
     }
 }
+/**
+ * Prompt for API key with format validation and hints
+ */
+async function promptForApiKey(provider) {
+    const providerInfo = getProviderInfo(provider);
+    const formatHint = providerInfo?.apiKeyPrefix
+        ? chalk.gray(` (starts with ${providerInfo.apiKeyPrefix})`)
+        : '';
+    const apiKey = await p.password({
+        message: `Enter your ${getProviderDisplayName(provider)} API key${formatHint}`,
+        mask: '*',
+        validate: (value) => {
+            const result = validateApiKeyFormat(value, provider);
+            if (!result.valid) {
+                return result.error;
+            }
+            return undefined;
+        },
+    });
+    if (p.isCancel(apiKey)) {
+        p.cancel('Setup cancelled');
+        return null;
+    }
+    return apiKey.trim();
+}
+/**
+ * Verify API key with a spinner
+ */
+async function verifyApiKeyWithSpinner(provider, apiKey, model) {
+    const spinner = p.spinner();
+    spinner.start('Verifying API key...');
+    try {
+        const result = await verifyApiKey(provider, apiKey, model);
+        if (result.success) {
+            spinner.stop(chalk.green('✓ API key verified successfully!'));
+            return { success: true };
+        }
+        else {
+            spinner.stop(chalk.red('✗ API key verification failed'));
+            const response = { success: false };
+            if (result.error)
+                response.error = result.error;
+            return response;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        spinner.stop(chalk.red('✗ Verification failed'));
+        return { success: false, error: errorMessage };
+    }
+}
+/**
+ * Save API key with a spinner
+ */
+async function saveApiKeyWithSpinner(provider, apiKey) {
+    const spinner = p.spinner();
+    spinner.start('Saving API key...');
+    try {
+        const meta = await saveProviderApiKey(provider, apiKey, process.cwd());
+        spinner.stop(chalk.green(`✓ API key saved to ${meta.targetEnvPath}`));
+        // Reload environment variables
+        await applyLayeredEnvironmentLoading();
+        return { success: true, path: meta.targetEnvPath };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        spinner.stop(chalk.red('✗ Failed to save API key'));
+        logger.error(`Failed to save API key: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
+}
+/**
+ * Show manual setup instructions when automatic save fails
+ */
+function showManualSaveInstructions(provider, apiKey) {
+    const envVar = getProviderEnvVar(provider);
+    const maskedKey = apiKey.slice(0, 8) + '...' + apiKey.slice(-4);
+    const instructions = getExecutionContext() === 'global-cli'
+        ? [
+            `1. Create or edit: ${chalk.cyan('~/.dexto/.env')}`,
+            `2. Add this line: ${chalk.rgb(255, 165, 0)(`${envVar}=${maskedKey}`)}`,
+            `3. Run ${chalk.cyan('dexto')} again`,
+        ]
+        : [
+            `1. Create or edit: ${chalk.cyan('.env')} in your project`,
+            `2. Add this line: ${chalk.rgb(255, 165, 0)(`${envVar}=your_api_key`)}`,
+            `3. Run ${chalk.cyan('dexto')} again`,
+        ];
+    p.note(instructions.join('\n'), chalk.rgb(255, 165, 0)('Manual Setup Required'));
+}
 /**
  * Shows manual setup instructions to the user
  */
 function showManualSetupInstructions(provider) {
-    const envVar = getPrimaryApiKeyEnvVar(provider);
+    const envVar = getProviderEnvVar(provider);
+    const providerInfo = getProviderInfo(provider);
     const envInstructions = getExecutionContext() === 'global-cli'
         ? [
-            `${chalk.bold('2. Recommended: Use dexto setup (easiest):')}`,
-            `   dexto setup`,
-            ``,
-            `${chalk.bold('Or manually create ~/.dexto/.env:')}`,
-            `   mkdir -p ~/.dexto && echo "${envVar}=your_api_key_here" > ~/.dexto/.env`,
+            `${chalk.bold('2. Save your API key:')}`,
+            `   ${chalk.gray('Option A:')} Run ${chalk.cyan('dexto setup')} (interactive)`,
+            `   ${chalk.gray('Option B:')} Create ${chalk.cyan('~/.dexto/.env')} with:`,
+            `            ${chalk.rgb(255, 165, 0)(`${envVar}=your_api_key_here`)}`,
         ]
         : [
-            `${chalk.bold('2. Create a .env file in your project:')}`,
-            `   echo "${envVar}=your_api_key_here" > .env`,
+            `${chalk.bold('2. Save your API key:')}`,
+            `   Create ${chalk.cyan('.env')} in your project with:`,
+            `   ${chalk.rgb(255, 165, 0)(`${envVar}=your_api_key_here`)}`,
         ];
+    // Build provider URLs list dynamically from registry
+    const providerUrls = [];
+    // Add current provider first if it has an API key URL
+    if (providerInfo?.apiKeyUrl) {
+        providerUrls.push(`   ${chalk.cyan('→')} ${chalk.cyan(getProviderDisplayName(provider))}: ${providerInfo.apiKeyUrl}`);
+        providerUrls.push(''); // Add spacing
+    }
+    // Add recommended/popular providers with API keys
+    const popularProviders = [
+        { provider: 'google', color: chalk.green }, // Free
+        { provider: 'groq', color: chalk.green }, // Free
+        { provider: 'openai', color: chalk.blue },
+        { provider: 'anthropic', color: chalk.blue },
+        { provider: 'xai', color: chalk.blue },
+        { provider: 'cohere', color: chalk.blue },
+    ];
+    for (const { provider: p, color } of popularProviders) {
+        const info = PROVIDER_REGISTRY[p];
+        if (info?.apiKeyUrl && p !== provider) {
+            // Don't duplicate current provider
+            const freeTag = info.free ? ' (Free)' : '';
+            providerUrls.push(`   ${color('●')} ${color(info.label + freeTag)}: ${info.apiKeyUrl}`);
+        }
+    }
+    // Add gateway providers
+    const gatewayProviders = ['openrouter', 'glama'];
+    for (const p of gatewayProviders) {
+        const info = PROVIDER_REGISTRY[p];
+        if (info?.apiKeyUrl && p !== provider) {
+            providerUrls.push(`   ${chalk.rgb(255, 165, 0)('●')} ${chalk.rgb(255, 165, 0)(info.label)} (Gateway): ${info.apiKeyUrl}`);
+        }
+    }
+    // Add enterprise providers
+    const enterpriseProviders = ['vertex', 'bedrock'];
+    for (const p of enterpriseProviders) {
+        const info = PROVIDER_REGISTRY[p];
+        if (info?.apiKeyUrl && p !== provider) {
+            providerUrls.push(`   ${chalk.cyan('●')} ${chalk.cyan(info.label)} (Enterprise): ${info.apiKeyUrl}`);
+        }
+    }
     const instructions = [
-        `${chalk.bold('1. Get an API key:')}`,
-        `   • ${chalk.green('Google Gemini (Free)')}:  https://aistudio.google.com/apikey`,
-        `   • ${chalk.blue('OpenAI')}:           https://platform.openai.com/api-keys`,
-        `   • ${chalk.magenta('Anthropic')}:        https://console.anthropic.com/settings/keys`,
-        `   • ${chalk.yellow('Groq (Free)')}:      https://console.groq.com/keys`,
+        `${chalk.bold('1. Get an API key from your provider:')}`,
+        ...providerUrls,
         ``,
         ...envInstructions,
-        `   # OR for other providers:`,
-        `   # OPENAI_API_KEY=your_key_here`,
-        `   # ANTHROPIC_API_KEY=your_key_here`,
-        `   # GROQ_API_KEY=your_key_here`,
         ``,
         `${chalk.bold('3. Run dexto again:')}`,
-        `   dexto | npx dexto`,
+        `   ${chalk.cyan('dexto')} or ${chalk.cyan('npx dexto')}`,
         ``,
-        `${chalk.dim('💡 Tip: Start with Google Gemini for a free experience!')}`,
+        `${chalk.gray('💡 Tip: Start with Google Gemini or Groq for a free experience!')}`,
     ].join('\n');
     p.note(instructions, chalk.bold('Manual Setup Instructions'));
 }
+/**
+ * Quick check if an API key is already configured for a provider
+ */
+export function hasApiKeyConfigured(provider) {
+    const envVar = getProviderEnvVar(provider);
+    return Boolean(process.env[envVar]);
+}
+/**
+ * Prompts user about pending API key setup from a previous incomplete setup.
+ * This is shown when user previously skipped API key setup and is now trying to run dexto.
+ *
+ * @param provider - The provider that needs API key setup
+ * @param model - The model configured for the provider
+ * @returns Result indicating which action the user chose
+ */
+export async function promptForPendingApiKey(provider, model) {
+    const providerName = getProviderDisplayName(provider);
+    p.intro(chalk.cyan('🔧 Complete Your Setup'));
+    p.note(`You previously set up Dexto with ${chalk.bold(providerName)} but skipped API key configuration.\n\n` +
+        `To use ${providerName}/${model}, you'll need to add your API key.`, 'Setup Incomplete');
+    const action = await p.select({
+        message: 'What would you like to do?',
+        options: [
+            {
+                value: 'setup',
+                label: `Set up ${providerName} API key now`,
+                hint: 'Recommended - complete your setup',
+            },
+            {
+                value: 'skip',
+                label: 'Skip for now',
+                hint: 'Continue without API key - will show error when trying to use LLM',
+            },
+            {
+                value: 'cancel',
+                label: 'Exit',
+                hint: 'Exit and set up later with: dexto setup',
+            },
+        ],
+    });
+    if (p.isCancel(action)) {
+        p.cancel('Cancelled');
+        return { action: 'cancel' };
+    }
+    if (action === 'cancel') {
+        return { action: 'cancel' };
+    }
+    if (action === 'skip') {
+        p.log.warn('Continuing without API key. You may see errors when the LLM is invoked.');
+        return { action: 'skip' };
+    }
+    // action === 'setup' - use the existing API key setup flow
+    const setupResult = await interactiveApiKeySetup(provider, {
+        exitOnCancel: false,
+        model,
+    });
+    if (setupResult.cancelled) {
+        return { action: 'cancel' };
+    }
+    if (setupResult.skipped) {
+        p.log.warn('API key setup skipped. You can configure it later with: dexto setup');
+        return { action: 'skip' };
+    }
+    if (setupResult.success && setupResult.apiKey) {
+        return { action: 'setup', apiKey: setupResult.apiKey };
+    }
+    return { action: 'skip' };
+}
+/**
+ * Prompts user when loading a specific agent that requires an API key they don't have.
+ * Offers options to add the API key, continue with their default LLM, or cancel.
+ *
+ * @param agentProvider - The provider the agent requires
+ * @param agentModel - The model the agent uses
+ * @param userProvider - The user's default provider (from preferences)
+ * @param userModel - The user's default model (from preferences)
+ * @returns Result indicating which action the user chose
+ */
+export async function promptForMissingAgentApiKey(agentProvider, agentModel, userProvider, userModel) {
+    const agentProviderName = getProviderDisplayName(agentProvider);
+    const userProviderName = getProviderDisplayName(userProvider);
+    const userDefault = `${userProviderName}/${userModel}`;
+    p.intro(chalk.cyan('🔧 Agent Configuration'));
+    p.note(`This agent is configured for ${chalk.bold(`${agentProviderName}/${agentModel}`)}\n` +
+        `but you don't have an API key set up for ${agentProviderName}.\n\n` +
+        `Your default LLM is ${chalk.green(userDefault)}.`, 'Missing API Key');
+    const action = await p.select({
+        message: 'What would you like to do?',
+        options: [
+            {
+                value: 'use-default',
+                label: `Continue with ${userDefault}`,
+                hint: 'Agent will use your default LLM instead (behavior may differ)',
+            },
+            {
+                value: 'add-key',
+                label: `Set up ${agentProviderName} API key`,
+                hint: `Configure ${agentProviderName} to run agent as intended`,
+            },
+            {
+                value: 'cancel',
+                label: 'Cancel',
+                hint: 'Exit without running the agent',
+            },
+        ],
+    });
+    if (p.isCancel(action)) {
+        p.cancel('Cancelled');
+        return { action: 'cancel' };
+    }
+    if (action === 'cancel') {
+        return { action: 'cancel' };
+    }
+    if (action === 'use-default') {
+        p.log.warn(`Using ${userDefault} instead of ${agentProviderName}/${agentModel}. ` +
+            `Agent behavior may differ from intended.`);
+        return { action: 'use-default' };
+    }
+    // action === 'add-key' - use the existing API key setup flow
+    const setupResult = await interactiveApiKeySetup(agentProvider, {
+        exitOnCancel: false,
+        model: agentModel,
+    });
+    if (setupResult.cancelled) {
+        return { action: 'cancel' };
+    }
+    if (setupResult.skipped) {
+        // User skipped in the API key setup - ask again what they want to do
+        const skipAction = await p.select({
+            message: 'API key setup was skipped. What would you like to do?',
+            options: [
+                {
+                    value: 'use-default',
+                    label: `Continue with ${userDefault}`,
+                    hint: 'Agent will use your default LLM instead',
+                },
+                {
+                    value: 'cancel',
+                    label: 'Cancel',
+                    hint: 'Exit without running the agent',
+                },
+            ],
+        });
+        if (p.isCancel(skipAction) || skipAction === 'cancel') {
+            return { action: 'cancel' };
+        }
+        p.log.warn(`Using ${userDefault} instead of ${agentProviderName}/${agentModel}. ` +
+            `Agent behavior may differ from intended.`);
+        return { action: 'use-default' };
+    }
+    if (setupResult.success && setupResult.apiKey) {
+        return { action: 'add-key', apiKey: setupResult.apiKey };
+    }
+    // Shouldn't reach here, but default to cancel
+    return { action: 'cancel' };
+}

package/dist/cli/utils/api-key-verification.d.ts

@@ -0,0 +1,17 @@
+import type { LLMProvider } from '@dexto/core';
+export interface VerificationResult {
+    success: boolean;
+    error?: string;
+    modelUsed?: string;
+}
+/**
+ * Verify an API key by making a minimal test request to the provider.
+ * Uses provider-specific endpoints for efficient validation.
+ *
+ * @param provider - The LLM provider
+ * @param apiKey - The API key to verify
+ * @param model - Optional specific model to test with
+ * @returns Verification result
+ */
+export declare function verifyApiKey(provider: LLMProvider, apiKey: string, _model?: string): Promise<VerificationResult>;
+//# sourceMappingURL=api-key-verification.d.ts.map

package/dist/cli/utils/api-key-verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-key-verification.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/api-key-verification.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAC9B,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,kBAAkB,CAAC,CAsC7B"}