@aws/ml-container-creator 0.9.1 → 0.10.3

package/src/lib/prompt-runner.js

@@ -29,40 +29,25 @@ import {
     infraBuildPrompts,
     projectPrompts,
     destinationPrompts,
-    baseImageSearchPrompts,
     baseImagePrompts,
-    formatImageChoices,
     filterByCudaGeneration,
     instanceCatalogRaw
-} from './prompts.js';
+} from './prompts/index.js';
 
 import fs from 'fs';
 import path from 'path';
-import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import RegistryLoader from './registry-loader.js';
 import { runPrompts } from '../prompt-adapter.js';
-import { SECRET_CLASSIFICATIONS } from './secret-classification.js';
-import { isSecretsManagerArn } from './arn-detection.js';
-import BootstrapConfig from './bootstrap-config.js';
+import McpQueryRunner from './mcp-query-runner.js';
+import SecretsPromptRunner from './secrets-prompt-runner.js';
+import CudaResolver from './cuda-resolver.js';
+import MarketplaceFlow from './marketplace-flow.js';
 
 const __pr_filename = fileURLToPath(import.meta.url);
 const __pr_dirname = path.dirname(__pr_filename);
 const GENERATOR_ROOT = path.resolve(__pr_dirname, '..', '..');
 
-/**
- * Resolve MCP server args — converts relative paths to absolute using GENERATOR_ROOT.
- * @param {string[]} args - The args array from mcp.json serverConfig
- * @returns {string[]} Args with relative paths resolved
- */
-function resolveMcpArgs(args) {
-    return (args || []).map(arg => {
-        if (arg && !path.isAbsolute(arg) && !arg.startsWith('-')) {
-            return path.resolve(GENERATOR_ROOT, arg);
-        }
-        return arg;
-    });
-}
 
 export default class PromptRunner {
     constructor({ configManager, options, registryConfigManager, baseConfig, promptFn }) {
@@ -71,8 +56,32 @@ export default class PromptRunner {
         this.registryConfigManager = registryConfigManager || null;
         this.baseConfig = baseConfig || {};
         this._runPrompts = promptFn || runPrompts;
+        this.mcpQueryRunner = new McpQueryRunner(this);
+        this.secretsPromptRunner = new SecretsPromptRunner(this);
+        this.cudaResolver = new CudaResolver(this);
+        this.marketplaceFlow = new MarketplaceFlow(this);
     }
 
+    // ── Sub-object delegations (backward compat for tests) ──────────
+
+    _queryMcpForBaseImage(...args) { return this.mcpQueryRunner._queryMcpForBaseImage(...args); }
+    _queryMcpForModels(...args) { return this.mcpQueryRunner._queryMcpForModels(...args); }
+    _queryMcpForRegion(...args) { return this.mcpQueryRunner._queryMcpForRegion(...args); }
+    _queryMcpForInstance(...args) { return this.mcpQueryRunner._queryMcpForInstance(...args); }
+    _queryMcpForInstanceSizing(...args) { return this.mcpQueryRunner._queryMcpForInstanceSizing(...args); }
+    _queryMcpForEndpoints(...args) { return this.mcpQueryRunner._queryMcpForEndpoints(...args); }
+    _queryMcpForHyperPod(...args) { return this.mcpQueryRunner._queryMcpForHyperPod(...args); }
+    _fetchAndDisplayModelInfo(...args) { return this.mcpQueryRunner._fetchAndDisplayModelInfo(...args); }
+    _validateAndDisplayInstanceType(...args) { return this.mcpQueryRunner._validateAndDisplayInstanceType(...args); }
+    _runSecretPrompts(...args) { return this.secretsPromptRunner._runSecretPrompts(...args); }
+    _secretStagesApply(...args) { return this.secretsPromptRunner._secretStagesApply(...args); }
+    _getArnConfigKey(...args) { return this.secretsPromptRunner._getArnConfigKey(...args); }
+    _getPlaintextConfigKey(...args) { return this.secretsPromptRunner._getPlaintextConfigKey(...args); }
+    _promptSecretSelection(...args) { return this.secretsPromptRunner._promptSecretSelection(...args); }
+    _promptPlaintextEntry(...args) { return this.secretsPromptRunner._promptPlaintextEntry(...args); }
+    _promptPlaintextFallback(...args) { return this.secretsPromptRunner._promptPlaintextFallback(...args); }
+    _promptCudaVersion(...args) { return this.cudaResolver._promptCudaVersion(...args); }
+
     /**
      * Runs all prompting phases and returns combined answers
      * 
@@ -131,7 +140,7 @@ export default class PromptRunner {
         // Requirements: 2.3, 2.4, 2.5
         // ──────────────────────────────────────────────────────────────────────
         if (frameworkAnswers.architecture === 'marketplace') {
-            return this._runMarketplaceFlow(frameworkAnswers, explicitConfig, existingConfig, buildTimestamp);
+            return this.marketplaceFlow._runMarketplaceFlow(frameworkAnswers, explicitConfig, existingConfig, buildTimestamp);
         }
         
         // Engine prompt for http architecture
@@ -141,7 +150,7 @@ export default class PromptRunner {
         const tritonAutoFormat = this._getTritonAutoModelFormat(architecture, backend);
         
         // Query model-picker MCP server for model choices
-        this._queryMcpForModels(frameworkAnswers.architecture);
+        this.mcpQueryRunner._queryMcpForModels(frameworkAnswers.architecture);
         if (this._mcpModelChoices) {
             console.log('   🔍 Querying model-picker...');
             console.log(`   ✓ ${this._mcpModelChoices.length} model(s) available from catalog`);
@@ -171,7 +180,7 @@ export default class PromptRunner {
         
         // Fetch model information from HuggingFace and Model Registry
         if (phase1ModelId && phase1ModelId !== 'Custom (enter manually)') {
-            await this._fetchAndDisplayModelInfo(phase1ModelId);
+            await this.mcpQueryRunner._fetchAndDisplayModelInfo(phase1ModelId);
         }
 
         // ══════════════════════════════════════════════════════════════════════
@@ -186,7 +195,7 @@ export default class PromptRunner {
         const regionAndTargetAnswers = await this._runPhase(infraRegionAndTargetPrompts, { ...frameworkAnswers, ...regionPreviousAnswers }, explicitConfig, existingConfig);
 
         // 2b. Query base-image-picker MCP server for base image choices
-        await this._queryMcpForBaseImage(frameworkAnswers, explicitConfig);
+        await this.mcpQueryRunner._queryMcpForBaseImage(frameworkAnswers, explicitConfig);
         const baseImagePreviousAnswers = {
             ...frameworkAnswers,
             ...engineAnswers,
@@ -211,7 +220,7 @@ export default class PromptRunner {
         // ══════════════════════════════════════════════════════════════════════
 
         // 3a. Region query
-        await this._queryMcpForRegion(frameworkAnswers, explicitConfig);
+        await this.mcpQueryRunner._queryMcpForRegion(frameworkAnswers, explicitConfig);
 
         // 3a2. Existing endpoint prompt (only for realtime-inference)
         // Requirements: 3.3, 4.3, 4.4 — endpoint-picker MCP query
@@ -219,7 +228,7 @@ export default class PromptRunner {
         if (regionAndTargetAnswers.deploymentTarget === 'realtime-inference') {
             // Query endpoint-picker MCP server for available endpoints
             const resolvedRegion = regionAndTargetAnswers.customAwsRegion || regionAndTargetAnswers.awsRegion;
-            await this._queryMcpForEndpoints({ ...regionAndTargetAnswers, awsRegion: resolvedRegion }, explicitConfig);
+            await this.mcpQueryRunner._queryMcpForEndpoints({ ...regionAndTargetAnswers, awsRegion: resolvedRegion }, explicitConfig);
 
             const endpointPreviousAnswers = {
                 ...regionAndTargetAnswers,
@@ -261,13 +270,13 @@ export default class PromptRunner {
                     this._architectureHeuristicDefault = 'ml.m5.large';
                 } else if (phase1ModelId && phase1ModelId !== 'Custom (enter manually)') {
                     // Query instance-sizer with full context
-                    await this._queryMcpForInstanceSizing(frameworkAnswers, modelFormatAnswers, explicitConfig, {
+                    await this.mcpQueryRunner._queryMcpForInstanceSizing(frameworkAnswers, modelFormatAnswers, explicitConfig, {
                         cudaVersion: selectedBaseImageCuda,
                         profileEnvVars: this._selectedProfileEnvVars || {}
                     });
                 } else {
                     // No model known — use architecture heuristic
-                    await this._queryMcpForInstance(frameworkAnswers, explicitConfig);
+                    await this.mcpQueryRunner._queryMcpForInstance(frameworkAnswers, explicitConfig);
                 }
             }
 
@@ -419,7 +428,7 @@ export default class PromptRunner {
 
         // 3e. CUDA/AMI auto-resolution
         const instanceType = instanceAnswers.customInstanceType || instanceAnswers.instanceType;
-        const cudaAnswer = await this._promptCudaVersion(
+        const cudaAnswer = await this.cudaResolver._promptCudaVersion(
             instanceType,
             frameworkAnswers.framework,
             null, // frameworkVersion not yet known in Phase 3
@@ -430,7 +439,7 @@ export default class PromptRunner {
         let hyperPodAnswers = {};
         if (regionAndTargetAnswers.deploymentTarget === 'hyperpod-eks') {
             const resolvedRegion = regionAndTargetAnswers.customAwsRegion || regionAndTargetAnswers.awsRegion;
-            await this._queryMcpForHyperPod({ ...regionAndTargetAnswers, awsRegion: resolvedRegion }, explicitConfig);
+            await this.mcpQueryRunner._queryMcpForHyperPod({ ...regionAndTargetAnswers, awsRegion: resolvedRegion }, explicitConfig);
             hyperPodAnswers = await this._runPhase(infraHyperPodPrompts, { ...regionAndTargetAnswers }, explicitConfig, existingConfig);
         }
 
@@ -507,7 +516,7 @@ export default class PromptRunner {
 
         // Secret prompts — registry-driven secret selection (replaces hardcoded hfToken/ngcApiKey prompts)
         const secretPreviousAnswers = { ...frameworkAnswers, ...engineAnswers, ...frameworkVersionAnswers, ...frameworkProfileAnswers, ...modelFormatAnswers, ...modelServerAnswers, ...modelProfileAnswers };
-        const secretAnswers = await this._runSecretPrompts(secretPreviousAnswers, explicitConfig, existingConfig);
+        const secretAnswers = await this.secretsPromptRunner._runSecretPrompts(secretPreviousAnswers, explicitConfig, existingConfig);
         const hfTokenAnswers = { hfToken: secretAnswers.hfToken, hfTokenArn: secretAnswers.hfTokenArn };
         const ngcApiKeyAnswers = { ngcApiKey: secretAnswers.ngcApiKey, ngcTokenArn: secretAnswers.ngcTokenArn };
 
@@ -548,7 +557,7 @@ export default class PromptRunner {
         // Validate instance type against framework requirements (now that framework version is known)
         const finalInstanceType = infraAnswers.customInstanceType || infraAnswers.instanceType;
         if (finalInstanceType && frameworkVersionAnswers.frameworkVersion) {
-            await this._validateAndDisplayInstanceType(
+            await this.mcpQueryRunner._validateAndDisplayInstanceType(
                 finalInstanceType,
                 frameworkAnswers.framework,
                 frameworkVersionAnswers.frameworkVersion
@@ -756,264 +765,6 @@ export default class PromptRunner {
         return combinedAnswers;
     }
 
-    /**
-     * Marketplace-specific prompt flow.
-     * Skips all container-related prompts (framework, model server, base image, CUDA version)
-     * and prompts only for: model package ARN, instance type, deployment target, region.
-     *
-     * Requirements: 2.3, 2.4, 2.5
-     * @private
-     */
-    async _runMarketplaceFlow(frameworkAnswers, explicitConfig, existingConfig, buildTimestamp) {
-        console.log('\n🏪 Marketplace Model Package Configuration');
-
-        // Query marketplace-picker MCP server for subscription discovery
-        // Requirements: 2.4, 6.1, 6.2
-        let mcpSubscriptions = [];
-        const cm = this.configManager;
-        if (cm && cm.getMcpServerNames && cm.getMcpServerNames().includes('marketplace-picker')) {
-            try {
-                console.log('   🔍 Querying marketplace-picker for subscriptions...');
-                const result = await cm.queryMcpServer('marketplace-picker', {
-                    region: explicitConfig.awsRegion || existingConfig.awsRegion || process.env.AWS_REGION || 'us-east-1'
-                });
-                if (result && result.metadata?.subscriptions?.length > 0) {
-                    mcpSubscriptions = result.metadata.subscriptions;
-                    console.log(`   ✅ Found ${mcpSubscriptions.length} Marketplace subscription(s)`);
-                } else {
-                    console.log('   ℹ️  No Marketplace subscriptions found — enter ARN manually');
-                }
-            } catch (err) {
-                console.log(`   ⚠️  marketplace-picker unavailable: ${err.message}`);
-                console.log('   Falling back to manual ARN entry');
-            }
-        }
-
-        // Marketplace-specific prompts: model package ARN
-        const marketplacePrompts = [
-            {
-                type: mcpSubscriptions.length > 0 ? 'list' : 'input',
-                name: 'modelPackageArn',
-                message: mcpSubscriptions.length > 0
-                    ? 'Select a Marketplace model package:'
-                    : 'Model package ARN (arn:aws:sagemaker:<region>:<account>:model-package/<name>/<version>):',
-                ...(mcpSubscriptions.length > 0 ? {
-                    choices: [
-                        ...mcpSubscriptions.map(sub => ({
-                            name: `${sub.modelName} (${sub.vendor}) — ${sub.arn}`,
-                            value: sub.arn,
-                            short: sub.modelName
-                        })),
-                        { type: 'separator', separator: '──────────────' },
-                        { name: 'Enter ARN manually...', value: '__manual__', short: 'manual' }
-                    ]
-                } : {
-                    validate: (input) => {
-                        if (!input || input.trim() === '') {
-                            return 'Model package ARN is required';
-                        }
-                        const arnPattern = /^arn:aws:sagemaker:[a-z0-9-]+:\d{12}:model-package\/[\w-]+\/\d+$/;
-                        if (!arnPattern.test(input.trim())) {
-                            return 'Invalid ARN format. Expected: arn:aws:sagemaker:<region>:<account>:model-package/<name>/<version>';
-                        }
-                        return true;
-                    }
-                })
-            },
-            {
-                type: 'input',
-                name: 'modelPackageArnManual',
-                message: 'Model package ARN (arn:aws:sagemaker:<region>:<account>:model-package/<name>/<version>):',
-                when: (answers) => answers.modelPackageArn === '__manual__',
-                validate: (input) => {
-                    if (!input || input.trim() === '') {
-                        return 'Model package ARN is required';
-                    }
-                    const arnPattern = /^arn:aws:sagemaker:[a-z0-9-]+:\d{12}:model-package\/[\w-]+\/\d+$/;
-                    if (!arnPattern.test(input.trim())) {
-                        return 'Invalid ARN format. Expected: arn:aws:sagemaker:<region>:<account>:model-package/<name>/<version>';
-                    }
-                    return true;
-                }
-            }
-        ];
-        const marketplaceAnswers = await this._runPhase(marketplacePrompts, { ...frameworkAnswers }, explicitConfig, existingConfig);
-
-        // Handle manual ARN entry fallback
-        if (marketplaceAnswers.modelPackageArn === '__manual__' && marketplaceAnswers.modelPackageArnManual) {
-            marketplaceAnswers.modelPackageArn = marketplaceAnswers.modelPackageArnManual;
-            delete marketplaceAnswers.modelPackageArnManual;
-        }
-
-        // Infrastructure prompts: region, deployment target, instance type
-        console.log('\n💪 Infrastructure & Deployment');
-        const bootstrapRegion = existingConfig.awsRegion || explicitConfig.awsRegion;
-        const regionPreviousAnswers = bootstrapRegion ? { _bootstrapRegion: bootstrapRegion } : {};
-
-        // Marketplace deployment targets (no HyperPod — vendor controls the container)
-        const marketplaceInfraPrompts = [
-            {
-                type: 'list',
-                name: 'awsRegion',
-                message: 'Target AWS region?',
-                choices: (answers) => {
-                    const bootstrapReg = answers._bootstrapRegion;
-                    const choices = ['us-east-1'];
-                    if (bootstrapReg && bootstrapReg !== 'us-east-1') {
-                        choices.unshift({ name: `${bootstrapReg} (from bootstrap profile)`, value: bootstrapReg });
-                    }
-                    choices.push({ name: 'Custom...', value: 'custom' });
-                    return choices;
-                },
-                default: (answers) => answers._bootstrapRegion || 'us-east-1'
-            },
-            {
-                type: 'input',
-                name: 'customAwsRegion',
-                message: 'Enter AWS region (e.g., us-west-2, eu-west-1):',
-                when: answers => answers.awsRegion === 'custom'
-            },
-            {
-                type: 'list',
-                name: 'deploymentTarget',
-                message: 'Deployment target?',
-                choices: [
-                    { name: 'SageMaker Real-Time Inference', value: 'realtime-inference' },
-                    { name: 'SageMaker Async Inference', value: 'async-inference' },
-                    { name: 'SageMaker Batch Transform', value: 'batch-transform' }
-                ],
-                default: 'realtime-inference'
-            },
-            {
-                type: 'list',
-                name: 'instanceType',
-                message: 'Instance type for deployment?',
-                choices: [
-                    { name: 'ml.g5.xlarge (1 GPU, 24GB)', value: 'ml.g5.xlarge' },
-                    { name: 'ml.g5.2xlarge (1 GPU, 24GB)', value: 'ml.g5.2xlarge' },
-                    { name: 'ml.g5.4xlarge (1 GPU, 24GB)', value: 'ml.g5.4xlarge' },
-                    { name: 'ml.g5.12xlarge (4 GPUs, 96GB)', value: 'ml.g5.12xlarge' },
-                    { name: 'ml.p3.2xlarge (1 GPU, 16GB V100)', value: 'ml.p3.2xlarge' },
-                    { name: 'ml.m5.xlarge (CPU, 16GB)', value: 'ml.m5.xlarge' },
-                    { name: 'Custom...', value: 'custom' }
-                ],
-                default: 'ml.g5.xlarge'
-            },
-            {
-                type: 'input',
-                name: 'customInstanceType',
-                message: 'Enter instance type (e.g., ml.g5.xlarge):',
-                validate: (input) => {
-                    if (!input || input.trim() === '') {
-                        return 'Instance type is required';
-                    }
-                    if (!input.startsWith('ml.')) {
-                        return 'Instance type must start with "ml." (e.g., ml.g5.xlarge)';
-                    }
-                    return true;
-                },
-                when: answers => answers.instanceType === 'custom'
-            }
-        ];
-        const infraAnswers = await this._runPhase(marketplaceInfraPrompts, { ...frameworkAnswers, ...regionPreviousAnswers }, explicitConfig, existingConfig);
-
-        // Async-specific prompts (only when deploymentTarget === 'async-inference')
-        let asyncAnswers = {};
-        if (infraAnswers.deploymentTarget === 'async-inference') {
-            asyncAnswers = await this._runPhase(infraAsyncPrompts, { ...infraAnswers }, explicitConfig, existingConfig);
-        }
-
-        // Batch transform-specific prompts (only when deploymentTarget === 'batch-transform')
-        let batchTransformAnswers = {};
-        if (infraAnswers.deploymentTarget === 'batch-transform') {
-            batchTransformAnswers = await this._runPhase(
-                infraBatchTransformPrompts,
-                { ...infraAnswers },
-                explicitConfig,
-                existingConfig
-            );
-        }
-
-        // Role ARN prompt (always needed for marketplace deploy)
-        const rolePrompts = [
-            {
-                type: 'input',
-                name: 'awsRoleArn',
-                message: 'AWS IAM Role ARN for SageMaker execution (optional)?',
-                validate: (input) => {
-                    if (!input || input.trim() === '') {
-                        return true;
-                    }
-                    const arnPattern = /^arn:aws:iam::\d{12}:role\/[\w+=,.@-]+$/;
-                    if (!arnPattern.test(input)) {
-                        return 'Invalid ARN format. Expected: arn:aws:iam::123456789012:role/RoleName';
-                    }
-                    return true;
-                }
-            }
-        ];
-        const roleAnswers = await this._runPhase(rolePrompts, { ...infraAnswers }, explicitConfig, existingConfig);
-
-        // Project name + destination
-        console.log('\n📋 Project Configuration');
-        const allTechnicalAnswers = {
-            ...frameworkAnswers,
-            ...marketplaceAnswers,
-            ...infraAnswers,
-            ...asyncAnswers,
-            ...batchTransformAnswers,
-            ...roleAnswers
-        };
-        const projectAnswers = await this._runPhase(projectPrompts, allTechnicalAnswers, explicitConfig, existingConfig);
-        const destinationAnswers = await this._runPhase(destinationPrompts,
-            { ...allTechnicalAnswers, ...projectAnswers }, explicitConfig, existingConfig);
-
-        // Combine all marketplace answers
-        const combinedAnswers = {
-            ...frameworkAnswers,
-            ...marketplaceAnswers,
-            ...infraAnswers,
-            ...asyncAnswers,
-            ...batchTransformAnswers,
-            ...roleAnswers,
-            ...projectAnswers,
-            ...destinationAnswers,
-            buildTimestamp
-        };
-
-        // Handle custom instance type
-        if (combinedAnswers.customInstanceType) {
-            combinedAnswers.instanceType = combinedAnswers.customInstanceType;
-            delete combinedAnswers.customInstanceType;
-        }
-
-        // Handle custom AWS region
-        if (combinedAnswers.customAwsRegion) {
-            combinedAnswers.awsRegion = combinedAnswers.customAwsRegion;
-            delete combinedAnswers.customAwsRegion;
-        }
-
-        // Map awsRoleArn to roleArn for templates
-        if (combinedAnswers.awsRoleArn) {
-            combinedAnswers.roleArn = combinedAnswers.awsRoleArn;
-            delete combinedAnswers.awsRoleArn;
-        }
-
-        // Ensure CLI-provided values are in combinedAnswers
-        if (explicitConfig.modelPackageArn && !combinedAnswers.modelPackageArn) {
-            combinedAnswers.modelPackageArn = explicitConfig.modelPackageArn;
-        }
-
-        // Handle marketplace:// prefix from --model-name CLI option
-        const modelName = explicitConfig.modelName || combinedAnswers.modelName;
-        if (modelName && modelName.startsWith('marketplace://')) {
-            const arn = modelName.replace(/^marketplace:\/\//, '');
-            combinedAnswers.modelPackageArn = arn;
-            delete combinedAnswers.modelName;
-        }
-
-        return combinedAnswers;
-    }
 
     /**
      * Checks if a parameter is promptable according to the parameter matrix
@@ -1267,491 +1018,6 @@ export default class PromptRunner {
         return Object.hasOwn(HEURISTIC_DEFAULTS, architecture) ? HEURISTIC_DEFAULTS[architecture] : 'ml.g5.xlarge';
     }
 
-    /**
-     * Query MCP region-picker server before infrastructure prompts.
-     * Populates configManager.mcpChoices so _runPhase injects them into list prompts.
-     * @private
-     */
-    async _queryMcpForRegion(frameworkAnswers, explicitConfig) {
-        const cm = this.configManager;
-        if (!cm) return;
-
-        const mcpServers = cm.getMcpServerNames();
-        if (mcpServers.length === 0) return;
-
-        const smart = this.options.smart === true;
-
-        // Region: skip MCP query if region was explicitly provided via CLI, config file, or bootstrap profile
-        const cliRegion = this.options.region;
-        const bootstrapRegion = explicitConfig.awsRegion;
-        const skipRegionQuery = (cliRegion !== undefined && cliRegion !== null) ||
-            (bootstrapRegion !== undefined && bootstrapRegion !== null);
-
-        if (!skipRegionQuery && mcpServers.includes('region-picker')) {
-            const { regionSearch } = await this._runPrompts([{
-                type: 'input',
-                name: 'regionSearch',
-                message: '🔌 Search for a region (e.g. "europe", "us west", "tokyo"):',
-                default: ''
-            }]);
-
-            if (regionSearch && regionSearch.trim()) {
-                console.log(`   🔍 Querying region-picker${smart ? ' [smart]' : ''}...`);
-                const result = await cm.queryMcpServer('region-picker', {
-                    ...frameworkAnswers,
-                    regionSearch: regionSearch.trim()
-                });
-                if (result && result.choices?.awsRegion?.length > 0) {
-                    const choices = result.choices.awsRegion;
-                    const preview = choices.length <= 5
-                        ? choices.join(', ')
-                        : `${choices.slice(0, 5).join(', ')  } (+${choices.length - 5} more)`;
-                    console.log(`   ✓ ${choices.length} region(s): [${preview}]`);
-                } else {
-                    console.log('   ↳ No MCP results, using static list');
-                }
-            }
-        }
-    }
-
-    /**
-     * Query MCP instance-sizer server with tag-based search after deployment target is known.
-     * Used when no model name is available for VRAM-based sizing.
-     * Populates configManager.mcpChoices so _runPhase injects them into list prompts.
-     * @private
-     */
-    async _queryMcpForInstance(frameworkAnswers, explicitConfig) {
-        const cm = this.configManager;
-        if (!cm) return;
-
-        const mcpServers = cm.getMcpServerNames();
-        if (mcpServers.length === 0) return;
-
-        const smart = this.options.smart === true;
-
-        // Instance type: query if not already provided via CLI/config
-        if (!explicitConfig.instanceType && mcpServers.includes('instance-sizer')) {
-            const { instanceSearch } = await this._runPrompts([{
-                type: 'input',
-                name: 'instanceSearch',
-                message: '🔌 Describe your instance needs (e.g. "multi-gpu", "cost-effective cpu"):',
-                default: frameworkAnswers.framework || ''
-            }]);
-
-            if (instanceSearch && instanceSearch.trim()) {
-                console.log(`   🔍 Querying instance-sizer [search]${smart ? ' [smart]' : ''}...`);
-                const result = await cm.queryMcpServer('instance-sizer', {
-                    ...frameworkAnswers,
-                    instanceSearch: instanceSearch.trim()
-                });
-                if (result && result.choices?.instanceType?.length > 0) {
-                    const choices = result.choices.instanceType;
-                    const preview = choices.length <= 5
-                        ? choices.join(', ')
-                        : `${choices.slice(0, 5).join(', ')  } (+${choices.length - 5} more)`;
-                    console.log(`   ✓ ${choices.length} instance(s): [${preview}]`);
-                } else {
-                    console.log('   ↳ No MCP results, using static list');
-                }
-            }
-        }
-    }
-
-    /**
-     * Query the instance-sizer MCP server after model is known.
-     * Estimates VRAM requirements and returns filtered, ranked instance recommendations.
-     * Stores results in this._mcpInstanceSizerChoices and this._instanceSizerMetadata.
-     * Requirements: 4.4, 4.5, 4.7, 3.6, 3.7
-     * @param {object} frameworkAnswers - Framework/architecture answers
-     * @param {object} modelFormatAnswers - Model format answers (contains modelName)
-     * @param {object} explicitConfig - Explicit CLI/config values
-     * @param {object} [sizerContext={}] - Additional context for the sizer query
-     * @param {string} [sizerContext.cudaVersion] - CUDA version from base image
-     * @param {object} [sizerContext.profileEnvVars] - Profile ENV overrides
-     * @private
-     */
-    async _queryMcpForInstanceSizing(frameworkAnswers, modelFormatAnswers, explicitConfig, sizerContext = {}) {
-        const cm = this.configManager;
-        if (!cm) return;
-
-        const mcpServers = cm.getMcpServerNames();
-        if (!mcpServers.includes('instance-sizer')) return;
-
-        // Resolve model name from answers or explicit config
-        const modelName = modelFormatAnswers.customModelName || modelFormatAnswers.modelName || explicitConfig.modelName;
-        if (!modelName || modelName === 'Custom (enter manually)') return;
-
-        const smart = this.options.smart === true;
-        const discover = this.options.discover !== false;
-
-        const modeLabel = [smart && '[smart]', !discover && '[no-discover]'].filter(Boolean).join(' ');
-        console.log(`   🔍 Querying instance-sizer${modeLabel ? ` ${modeLabel}` : ''}...`);
-
-        try {
-            const mcpConfigPath = path.join(GENERATOR_ROOT, 'config', 'mcp.json');
-            if (!fs.existsSync(mcpConfigPath)) return;
-
-            const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
-            const serverConfig = mcpConfig.mcpServers?.['instance-sizer'];
-            if (!serverConfig) return;
-
-            const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
-            const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
-
-            const serverArgs = [...resolveMcpArgs(serverConfig.args)];
-            if (!discover && !serverArgs.includes('--no-discover')) {
-                serverArgs.push('--no-discover');
-            }
-
-            const transport = new StdioClientTransport({
-                command: serverConfig.command,
-                args: serverArgs,
-                env: {
-                    ...process.env,
-                    ...(serverConfig.env || {}),
-                    ...(smart ? { BEDROCK_SMART: 'true' } : {})
-                },
-                stderr: 'pipe'
-            });
-
-            const mcpClient = new Client(
-                { name: 'ml-container-creator', version: '1.0.0' },
-                { capabilities: {} }
-            );
-
-            await mcpClient.connect(transport);
-
-            const toolArgs = {
-                modelName,
-                limit: 10,
-                context: {
-                    architecture: frameworkAnswers.architecture || undefined,
-                    backend: frameworkAnswers.backend || undefined,
-                    deploymentTarget: frameworkAnswers.deploymentTarget || undefined,
-                    profileEnvVars: sizerContext.profileEnvVars || undefined
-                }
-            };
-
-            // Add CUDA version from base image for filtering
-            if (sizerContext.cudaVersion) {
-                toolArgs.cudaVersion = sizerContext.cudaVersion;
-            }
-
-            // Add quantization if available from model format answers
-            if (modelFormatAnswers.quantization) {
-                toolArgs.quantization = modelFormatAnswers.quantization;
-            }
-
-            const result = await mcpClient.callTool({
-                name: 'get_instance_recommendation',
-                arguments: toolArgs
-            });
-
-            await mcpClient.close();
-
-            // Parse the response
-            const textBlock = result?.content?.find(b => b.type === 'text');
-            if (textBlock) {
-                const parsed = JSON.parse(textBlock.text);
-
-                if (parsed.choices?.instanceType?.length > 0) {
-                    this._instanceSizerMetadata = parsed.metadata || null;
-
-                    // Build display labels with VRAM estimate and utilization percentage
-                    const recommendations = parsed.metadata?.recommendations || [];
-                    const estimatedVramGb = parsed.metadata?.estimatedVramGb;
-                    
-                    // Store choices with display labels for the instance prompt
-                    this._mcpInstanceSizerChoices = parsed.choices.instanceType;
-                    this._mcpInstanceSizerDisplayChoices = recommendations.map(rec => ({
-                        name: rec.displayLabel || `${rec.instanceType} (${estimatedVramGb ? estimatedVramGb.toFixed(1) : '?'}GB / ${rec.totalVramGb || '?'}GB — ${rec.utilizationPercent || '?'}% utilization)`,
-                        value: rec.instanceType,
-                        short: rec.instanceType
-                    }));
-
-                    const choices = parsed.choices.instanceType;
-                    const topRec = recommendations[0];
-                    const vramInfo = estimatedVramGb
-                        ? ` (model needs ~${estimatedVramGb.toFixed(1)}GB VRAM)`
-                        : '';
-
-                    console.log(`   ✓ ${choices.length} compatible instance(s) found${vramInfo}`);
-
-                    // Warn if all instances had zero quota but were restored for visibility
-                    if (parsed.metadata?.allFilteredByQuota) {
-                        console.log('   ⚠️  All instances have zero quota — request a quota increase for your preferred type');
-                    }
-
-                    // Check if availability data is present (recommendations have capacityType)
-                    const hasAvailabilityData = recommendations.some(r => r.capacityType);
-
-                    if (hasAvailabilityData) {
-                        // Group by capacityType for display
-                        const reserved = recommendations.filter(r => r.capacityType === 'reserved' || r.capacityType === 'ftp');
-                        const onDemand = recommendations.filter(r => r.capacityType === 'on-demand');
-
-                        if (reserved.length > 0) {
-                            console.log('     ── Reserved Capacity ──');
-                            for (const rec of reserved) {
-                                const tp = rec.tensorParallelism > 1 ? ` TP=${rec.tensorParallelism}` : '';
-                                const vram = rec.totalVramGb ? `${rec.totalVramGb}GB` : '?';
-                                const util = rec.utilizationPercent ? `${rec.utilizationPercent}%` : '?';
-                                const tag = rec.capacityType === 'reserved'
-                                    ? ` [CR] ${rec.reservationInfo?.planName || rec.reservationInfo?.reservationId || ''}`
-                                    : ` [FTP] ${rec.ftpInfo?.planName || ''}`;
-                                console.log(`     ${rec === topRec ? '→' : ' '} ${rec.instanceType.padEnd(20)} ${vram.padStart(5)} VRAM  ${util.padStart(4)} util${tp}${tag}`);
-                            }
-                        }
-
-                        if (onDemand.length > 0) {
-                            console.log('     ── On-Demand ──');
-                            for (const rec of onDemand) {
-                                const tp = rec.tensorParallelism > 1 ? ` TP=${rec.tensorParallelism}` : '';
-                                const vram = rec.totalVramGb ? `${rec.totalVramGb}GB` : '?';
-                                const util = rec.utilizationPercent ? `${rec.utilizationPercent}%` : '?';
-                                const deployed = rec.quotaDeployed;
-                                const quota = rec.quotaLimit;
-                                const tag = quota !== null && quota !== undefined ? ` [Q:${deployed ?? 0}/${quota}]` : '';
-                                console.log(`     ${rec === topRec ? '→' : ' '} ${rec.instanceType.padEnd(20)} ${vram.padStart(5)} VRAM  ${util.padStart(4)} util${tp}${tag}`);
-                            }
-                        }
-                    } else {
-                        // Fallback: display compact recommendation table (no availability data)
-                        for (const rec of recommendations) {
-                            const tp = rec.tensorParallelism > 1 ? ` TP=${rec.tensorParallelism}` : '';
-                            const vram = rec.totalVramGb ? `${rec.totalVramGb}GB` : '?';
-                            const util = rec.utilizationPercent ? `${rec.utilizationPercent}%` : '?';
-                            console.log(`     ${rec === topRec ? '→' : ' '} ${rec.instanceType.padEnd(20)} ${vram.padStart(5)} VRAM  ${util.padStart(4)} util${tp}`);
-                        }
-                    }
-                } else if (parsed.metadata?.allFilteredByQuota) {
-                    // All VRAM-compatible instances had zero quota
-                    console.log('   ⚠️ No quota available for compatible instances. Request a quota increase.');
-                    this._instanceSizerMetadata = parsed.metadata || null;
-                } else if (parsed.metadata?.warning) {
-                    console.log(`   ⚠️  ${parsed.metadata.warning}`);
-                } else {
-                    // Apply architecture heuristic fallback when sizer returns empty
-                    const archForHeuristic = frameworkAnswers.architecture || frameworkAnswers.deploymentConfig?.split('-')[0];
-                    this._architectureHeuristicDefault = this._getArchitectureHeuristicDefault(archForHeuristic);
-                    console.log(`   ↳ No instance-sizer results, using heuristic default: ${this._architectureHeuristicDefault}`);
-                }
-            }
-        } catch (err) {
-            // Sizer unavailable — apply architecture heuristic fallback
-            const archForHeuristic = frameworkAnswers.architecture || frameworkAnswers.deploymentConfig?.split('-')[0];
-            this._architectureHeuristicDefault = this._getArchitectureHeuristicDefault(archForHeuristic);
-            console.log(`   ⚠️  instance-sizer: ${err.message}`);
-            console.log(`   ↳ Using heuristic default: ${this._architectureHeuristicDefault}`);
-        }
-    }
-
-    /**
-     * Query the hyperpod-cluster-picker MCP server for available HyperPod EKS clusters.
-     * Populates configManager.mcpChoices.hyperPodCluster so _runPhase injects them into the list prompt.
-     * Falls back to manual entry if the MCP server is not configured or fails.
-     * Requirements: 12.1, 12.2, 12.3
-     * @private
-     */
-    async _queryMcpForHyperPod(infraAnswers, explicitConfig) {
-        const cm = this.configManager;
-        if (!cm) return;
-
-        const mcpServers = cm.getMcpServerNames();
-        if (!mcpServers.includes('hyperpod-cluster-picker')) return;
-
-        // Skip if cluster already provided via CLI/config
-        if (explicitConfig.hyperPodCluster) return;
-
-        const smart = this.options.smart === true;
-        console.log(`   🔍 Querying hyperpod-cluster-picker${smart ? ' [smart]' : ''}...`);
-
-        const result = await cm.queryMcpServer('hyperpod-cluster-picker', {
-            ...infraAnswers
-        });
-
-        if (result && result.choices?.hyperPodCluster?.length > 0) {
-            const choices = result.choices.hyperPodCluster;
-            const preview = choices.length <= 5
-                ? choices.join(', ')
-                : `${choices.slice(0, 5).join(', ')} (+${choices.length - 5} more)`;
-            console.log(`   ✓ ${choices.length} cluster(s): [${preview}]`);
-        } else {
-            // Surface any error message from the MCP server
-            if (result?.message) {
-                console.log(`   ⚠️  ${result.message}`);
-            } else {
-                console.log('   ↳ No HyperPod clusters found via MCP, manual entry available');
-            }
-        }
-    }
-
-    /**
-     * Query the endpoint-picker MCP server for available InService real-time endpoints.
-     * Populates this._mcpEndpointChoices for the existing endpoint selection prompt.
-     * Graceful fallback: if MCP server fails (no credentials, timeout), skip and create new endpoint.
-     * Requirements: 3.3, 4.3, 4.4
-     * @private
-     */
-    async _queryMcpForEndpoints(infraAnswers, explicitConfig) {
-        const cm = this.configManager;
-        if (!cm) return;
-
-        const mcpServers = cm.getMcpServerNames();
-        if (!mcpServers.includes('endpoint-picker')) return;
-
-        // Skip if existing endpoint already provided via CLI/config
-        if (explicitConfig.existingEndpointName) return;
-
-        console.log('   🔍 Querying endpoint-picker...');
-
-        try {
-            const result = await cm.queryMcpServer('endpoint-picker', {
-                awsRegion: infraAnswers.awsRegion,
-                deploymentTarget: 'realtime-inference'
-            });
-
-            if (result && result.choices?.endpointName?.length > 0) {
-                const endpointNames = result.choices.endpointName;
-                const metadata = result.metadata || {};
-
-                // Build choices with metadata annotations
-                this._mcpEndpointChoices = endpointNames.map(name => {
-                    const meta = metadata[name];
-                    if (meta) {
-                        const gpuInfo = meta.availableGpus === '?' ? 'GPUs: ?' : `${meta.availableGpus} GPUs free`;
-                        return {
-                            name: `${name} (${meta.instanceType}, ${gpuInfo}, ${meta.icCount} IC${meta.icCount !== 1 ? 's' : ''})`,
-                            value: name
-                        };
-                    }
-                    return { name, value: name };
-                });
-
-                console.log(`   ✓ ${endpointNames.length} endpoint(s) with available capacity`);
-            } else {
-                if (result?.message) {
-                    console.log(`   ↳ ${result.message}`);
-                } else {
-                    console.log('   ↳ No endpoints with available capacity found');
-                }
-            }
-        } catch (err) {
-            // Graceful fallback: if MCP server fails, skip and create new endpoint
-            console.log(`   ⚠️  endpoint-picker: ${err.message || 'query failed'} — will create new endpoint`);
-        }
-    }
-
-    /**
-     * Query MCP base-image-picker server after deployment config is selected.
-     * Populates _mcpBaseImageChoices for the base image selection prompt.
-     * Requirements: 5.1, 5.2, 5.3, 5.4, 9.1, 9.2, 9.3
-     * @private
-     */
-    async _queryMcpForBaseImage(frameworkAnswers, _explicitConfig) {
-        // Skip if base image provided via CLI --base-image flag
-        if (this.options['base-image']) return;
-
-        const cm = this.configManager;
-        if (!cm) return;
-
-        const mcpServers = cm.getMcpServerNames();
-        if (!mcpServers.includes('base-image-picker')) return;
-
-        const smart = this.options.smart === true;
-        const discover = this.options.discover !== false;
-        const framework = frameworkAnswers.framework;
-        const modelServer = frameworkAnswers.modelServer;
-        const architecture = frameworkAnswers.architecture || frameworkAnswers.deploymentConfig?.split('-')[0];
-        const isTransformer = framework === 'transformers';
-        const isTriton = architecture === 'triton';
-        const isDiffusors = architecture === 'diffusors';
-
-        // For non-transformer, non-triton, non-diffusors frameworks, prompt for optional search criteria
-        let searchCriteria;
-        if (!isTransformer && !isTriton && !isDiffusors) {
-            const searchAnswer = await this._runPrompts(baseImageSearchPrompts.map(p => ({
-                ...p,
-                when: () => true // Always show for non-transformer since we already checked
-            })));
-            searchCriteria = searchAnswer.baseImageSearch;
-        }
-
-        const modeLabel = [smart && '[smart]', discover && '[discover]'].filter(Boolean).join(' ');
-        console.log(`   🔍 Querying base-image-picker${modeLabel ? ` ${modeLabel}` : ''}...`);
-
-        const context = { framework, modelServer, architecture };
-        if (searchCriteria && searchCriteria.trim()) {
-            context.searchCriteria = searchCriteria.trim();
-        }
-
-        const result = await cm.queryMcpServer('base-image-picker', context);
-
-        if (result && result.metadata?.baseImage?.length > 0) {
-            const entries = result.metadata.baseImage;
-            this._mcpBaseImageChoices = formatImageChoices(entries, isTransformer || isTriton || isDiffusors);
-            const count = entries.length;
-            console.log(`   ✓ ${count} base image(s) available`);
-        } else {
-            console.log('   ↳ No MCP results, using default image');
-        }
-    }
-
-    /**
-     * Query model-picker MCP server catalog for model choices.
-     * Reads the architecture-specific catalog (popular-transformers.json or
-     * popular-diffusors.json) to populate the model selection prompt.
-     * @param {string} [architecture] - Current architecture ('transformers', 'diffusors', etc.)
-     * @private
-     */
-    _queryMcpForModels(architecture) {
-        const cm = this.configManager;
-        if (!cm) return;
-
-        const mcpServers = cm.getMcpServerNames();
-        if (!mcpServers.includes('model-picker')) return;
-
-        try {
-            const mcpConfigPath = path.join(GENERATOR_ROOT, 'config', 'mcp.json');
-            if (!fs.existsSync(mcpConfigPath)) return;
-
-            const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
-            const serverConfig = mcpConfig.mcpServers?.['model-picker'];
-            if (!serverConfig?.args?.length) return;
-
-            // Resolve the server entry point directory from the args
-            const serverEntryPoint = serverConfig.args[serverConfig.args.length - 1];
-            const serverDir = path.dirname(serverEntryPoint);
-
-            // Read manifest to find catalog path
-            const manifestPath = path.join(serverDir, 'manifest.json');
-            if (!fs.existsSync(manifestPath)) return;
-
-            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-
-            // Select catalog based on architecture
-            const catalogKey = architecture === 'diffusors'
-                ? 'popular-diffusors'
-                : 'popular-transformers';
-            const catalogRelPath = manifest.catalogs?.[catalogKey];
-            if (!catalogRelPath) return;
-
-            const catalogPath = path.resolve(serverDir, catalogRelPath);
-            if (!fs.existsSync(catalogPath)) return;
-
-            const catalog = JSON.parse(fs.readFileSync(catalogPath, 'utf8'));
-
-            // Extract model IDs, filtering out glob patterns (entries with *)
-            const modelIds = Object.keys(catalog).filter(id => !id.includes('*'));
-
-            if (modelIds.length > 0) {
-                this._mcpModelChoices = modelIds;
-            }
-        } catch {
-            // Silently fall back to hardcoded defaults
-        }
-    }
-
     /**
      * Get framework version choices from registry
      * Requirements: 2.1, 2.6, 8.2, 8.3
@@ -1916,735 +1182,6 @@ export default class PromptRunner {
         return choices;
     }
 
-    /**
-     * Fetch and display model information from HuggingFace API and Model Registry
-     * Requirements: 5.1, 5.2, 5.3, 5.4, 5.5, 5.6, 5.11, 11.1, 11.2, 11.3, 11.5, 11.6, 11.7
-     * @private
-     */
-    async _fetchAndDisplayModelInfo(modelId) {
-        console.log('\n   🔍 Querying model-picker [discover]...');
-
-        const sources = [];
-        let chatTemplate = null;
-        let modelFamily = null;
-        let mcpUsed = false;
-
-        // Try model-picker MCP server in discover mode (queries HuggingFace + merges with catalog)
-        const cm = this.configManager;
-        if (cm) {
-            const mcpServers = cm.getMcpServerNames();
-            if (mcpServers.includes('model-picker')) {
-                try {
-                    const mcpConfigPath = path.join(GENERATOR_ROOT, 'config', 'mcp.json');
-                    if (fs.existsSync(mcpConfigPath)) {
-                        const mcpConfig = JSON.parse(fs.readFileSync(mcpConfigPath, 'utf8'));
-                        const serverConfig = mcpConfig.mcpServers?.['model-picker'];
-                        if (serverConfig) {
-                            const { McpClient } = await import('./mcp-client.js');
-                            const client = new McpClient(serverConfig, { timeout: 15000 });
-
-                            // Override _buildContext to pass model_id and mode directly
-                            client._getUnboundedParameterNames = () => [];
-                            client._buildContext = () => ({});
-
-                            // Connect and call get_models directly
-                            const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
-                            const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
-
-                            const transport = new StdioClientTransport({
-                                command: serverConfig.command,
-                                args: resolveMcpArgs(serverConfig.args),
-                                env: { ...process.env, ...(serverConfig.env || {}) },
-                                stderr: 'pipe'
-                            });
-
-                            const mcpClient = new Client(
-                                { name: 'ml-container-creator', version: '1.0.0' },
-                                { capabilities: {} }
-                            );
-
-                            await mcpClient.connect(transport);
-
-                            const result = await mcpClient.callTool({
-                                name: 'get_models',
-                                arguments: { model_id: modelId, mode: 'discover' }
-                            });
-
-                            await mcpClient.close();
-
-                            // Parse the response
-                            const textBlock = result?.content?.find(b => b.type === 'text');
-                            if (textBlock) {
-                                const parsed = JSON.parse(textBlock.text);
-                                if (parsed.values && Object.keys(parsed.values).length > 0) {
-                                    mcpUsed = true;
-                                    const vals = parsed.values;
-
-                                    if (vals.chat_template) {
-                                        chatTemplate = vals.chat_template;
-                                    }
-                                    if (vals.family) {
-                                        modelFamily = vals.family;
-                                    }
-
-                                    // Extract model_type for architecture validation
-                                    // Requirements: 4.1
-                                    if (vals.model_type) {
-                                        this._modelType = vals.model_type;
-                                    }
-
-                                    // Extract model source metadata for loading adapter
-                                    // Requirements: 2.1, 2.2, 2.3, 2.4
-                                    if (vals.provider) {
-                                        this._mcpModelSource = vals.provider;
-                                    }
-                                    if (vals.artifactUri) {
-                                        this._mcpArtifactUri = vals.artifactUri;
-                                    }
-
-                                    // Determine sources based on what was returned
-                                    if (vals.tags || vals.pipeline_tag) {
-                                        sources.push('HuggingFace_Hub_API');
-                                    }
-                                    if (vals.validation_level || vals.framework_compatibility) {
-                                        sources.push('Model_Picker_Catalog');
-                                    }
-                                    if (sources.length === 0) {
-                                        sources.push('model-picker');
-                                    }
-                                    console.log(`   ✓ Resolved: ${modelId}`);
-                                } else if (parsed.message) {
-                                    console.log(`   ↳ ${parsed.message}`);
-                                }
-                            }
-                        }
-                    }
-                } catch (err) {
-                    console.log('   ↳ model-picker unavailable, using fallback');
-                }
-            }
-        }
-
-        // Fallback to legacy path if MCP didn't resolve
-        if (!mcpUsed) {
-            const registryConfigManager = this.registryConfigManager;
-            if (registryConfigManager) {
-                // Only try HuggingFace API for bare model IDs (not prefixed URIs)
-                const isNonHfUri = modelId.startsWith('s3://') ||
-                        modelId.startsWith('registry://');
-
-                if (!isNonHfUri) {
-                    // Try HuggingFace API directly
-                    try {
-                        const hfData = await registryConfigManager._fetchHuggingFaceData(modelId);
-                        if (hfData) {
-                            sources.push('HuggingFace_Hub_API');
-                            if (hfData.chatTemplate) {
-                                chatTemplate = hfData.chatTemplate;
-                            }
-                            // Extract model_type for architecture validation
-                            // Requirements: 4.1
-                            if (hfData.modelConfig?.model_type) {
-                                this._modelType = hfData.modelConfig.model_type;
-                            }
-                            console.log('   ✅ Found on HuggingFace Hub');
-                        } else {
-                            console.log('   ℹ️  Not found on HuggingFace Hub (may be private or offline)');
-                        }
-                    } catch (error) {
-                        console.log('   ⚠️  HuggingFace API unavailable');
-                    }
-                } else {
-                    // Non-HF URI (s3://, registry://, etc.) — skip HF lookup silently
-                    // The summary at the end of this function will report "No additional model information"
-                }
-
-                // Check Model Registry for overrides
-                if (registryConfigManager.modelRegistry) {
-                    let modelConfig = registryConfigManager.modelRegistry[modelId];
-
-                    if (!modelConfig) {
-                        for (const [pattern, config] of Object.entries(registryConfigManager.modelRegistry)) {
-                            if (pattern.includes('*')) {
-                                const regex = new RegExp(`^${  pattern.replace(/\*/g, '.*')  }$`);
-                                if (regex.test(modelId)) {
-                                    modelConfig = config;
-                                    console.log(`   ✅ Matched pattern in Model_Registry: ${pattern}`);
-                                    break;
-                                }
-                            }
-                        }
-                    } else {
-                        console.log('   ✅ Found in Model_Registry');
-                    }
-
-                    if (modelConfig) {
-                        sources.push('Model_Registry');
-                        if (modelConfig.chatTemplate) {
-                            chatTemplate = modelConfig.chatTemplate;
-                        }
-                        if (modelConfig.family) {
-                            modelFamily = modelConfig.family;
-                        }
-                    }
-                }
-            }
-        }
-
-        // Display information
-        if (sources.length > 0) {
-            console.log('\n📋 Model Information:');
-            console.log(`   • Model ID: ${modelId}`);
-            if (modelFamily) {
-                console.log(`   • Family: ${modelFamily}`);
-            }
-            if (chatTemplate) {
-                console.log('   • Chat Template: ✅ Available');
-                console.log('     (Will be injected into generated files)');
-            } else {
-                console.log('   • Chat Template: ❌ Not available');
-                console.log('     (Chat endpoints may require manual configuration)');
-            }
-            console.log(`   • Sources: ${sources.join(', ')}`);
-        } else {
-            console.log('   ℹ️  No additional model information available');
-            console.log('   Proceeding with default configuration');
-        }
-    }
-
-
-
-    /**
-     * Validate and display instance type compatibility
-     * Requirements: 4.1, 4.2, 4.3, 4.4, 4.5, 4.6
-     * @private
-     */
-    async _validateAndDisplayInstanceType(instanceType, framework, version) {
-        const registryConfigManager = this.registryConfigManager;
-        
-        if (!registryConfigManager) {
-            return;
-        }
-        
-        // Get framework configuration
-        const frameworkConfig = registryConfigManager.frameworkRegistry?.[framework]?.[version];
-        if (!frameworkConfig) {
-            return; // No framework config, skip validation
-        }
-        
-        console.log(`\n🔍 Validating instance type: ${instanceType}`);
-        
-        // Validate instance type
-        const validationResult = registryConfigManager.validateInstanceType(instanceType, frameworkConfig);
-        
-        if (validationResult.compatible) {
-            console.log('   ✅ Instance type is compatible');
-            if (validationResult.info) {
-                console.log(`   ℹ️  ${validationResult.info}`);
-            }
-        } else {
-            console.log('   ❌ Instance type compatibility issue detected');
-            if (validationResult.error) {
-                console.log(`   Error: ${validationResult.error}`);
-            }
-            if (validationResult.recommendations && validationResult.recommendations.length > 0) {
-                console.log(`   💡 Recommended instances: ${validationResult.recommendations.join(', ')}`);
-            }
-            
-            // In test mode or non-interactive mode, throw error instead of prompting
-            if (this.options.skipPrompts || process.env.NODE_ENV === 'test') {
-                throw new Error('Instance type validation failed. Please select a compatible instance type.');
-            }
-            
-            // Ask user if they want to proceed
-            const proceed = await this._runPrompts([{
-                type: 'confirm',
-                name: 'proceedWithIncompatible',
-                message: 'Instance type may not be compatible. Proceed anyway?',
-                default: false
-            }]);
-            
-            if (!proceed.proceedWithIncompatible) {
-                throw new Error('Instance type validation failed. Please select a compatible instance type.');
-            }
-        }
-        
-        if (validationResult.warning) {
-            console.log(`   ⚠️  Warning: ${validationResult.warning}`);
-        }
-    }
-
-    /**
-     * Run secret prompts using the Secret_Classification registry.
-     * For each secret type whose stages apply to the current context:
-     * - Query for managed secrets of that type
-     * - If managed secrets exist: show selection list (secrets + "Enter plaintext token" + "Skip")
-     * - If no managed secrets exist: fall back to existing plaintext prompt
-     * 
-     * Requirements: 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9
-     * @param {object} previousAnswers - Answers from previous prompt phases
-     * @param {object} explicitConfig - Explicit CLI/config values
-     * @param {object} existingConfig - Existing project configuration
-     * @returns {Promise<object>} Object with token/ARN values keyed by config field names
-     * @private
-     */
-    async _runSecretPrompts(previousAnswers, explicitConfig, existingConfig) {
-        const results = {};
-
-        for (const classification of SECRET_CLASSIFICATIONS) {
-            // Check if this secret type's stages apply to the current context
-            if (!this._secretStagesApply(classification, previousAnswers)) continue;
-
-            // Determine the config keys for this classification
-            const arnConfigKey = this._getArnConfigKey(classification);
-            const plaintextConfigKey = this._getPlaintextConfigKey(classification);
-
-            // Skip if ARN already provided via CLI flag
-            if (explicitConfig[arnConfigKey]) {
-                results[arnConfigKey] = explicitConfig[arnConfigKey];
-                continue;
-            }
-
-            // Skip if plaintext already provided via CLI flag
-            if (explicitConfig[plaintextConfigKey]) {
-                results[plaintextConfigKey] = explicitConfig[plaintextConfigKey];
-                continue;
-            }
-
-            // Query for existing managed secrets of this type
-            const managedSecrets = await this._listManagedSecrets(classification.identifier);
-
-            if (managedSecrets.length > 0) {
-                // Show selection list: managed secrets + plaintext entry + skip
-                const answer = await this._promptSecretSelection(classification, managedSecrets, previousAnswers);
-                Object.assign(results, answer);
-            } else {
-                // Fall back to existing plaintext prompt
-                const answer = await this._promptPlaintextFallback(classification, previousAnswers, explicitConfig, existingConfig);
-                Object.assign(results, answer);
-            }
-        }
-
-        return results;
-    }
-
-    /**
-     * Determine if a secret classification's stages apply to the current generation context.
-     * Build-time secrets apply when the project involves a Docker build step.
-     * Runtime secrets apply when the architecture uses HuggingFace Hub models.
-     * Requirements: 8.9
-     * @param {object} classification - Secret classification entry
-     * @param {object} answers - Current answers from previous phases
-     * @returns {boolean} True if the secret type is applicable
-     * @private
-     */
-    _secretStagesApply(classification, answers) {
-        const architecture = answers.architecture || answers.deploymentConfig?.split('-')[0];
-        const backend = answers.backend || answers.deploymentConfig?.split('-').slice(1).join('-');
-
-        if (classification.identifier === 'hf-token') {
-            // HF token applies to transformers, diffusors, and Triton LLM backends
-            const isTransformers = architecture === 'transformers';
-            const isDiffusors = architecture === 'diffusors';
-            const isTritonLlm = architecture === 'triton' && (backend === 'vllm' || backend === 'tensorrtllm');
-
-            if (!isTransformers && !isDiffusors && !isTritonLlm) return false;
-
-            // Skip for non-HuggingFace model sources
-            const modelSource = answers.modelSource;
-            if (modelSource && modelSource !== 'huggingface') return false;
-
-            return true;
-        }
-
-        if (classification.identifier === 'ngc-token') {
-            // NGC token only applies to transformers-tensorrt-llm (build-time only)
-            if (architecture === 'triton') return false;
-            if (architecture === 'diffusors') return false;
-            return architecture === 'transformers' && backend === 'tensorrt-llm';
-        }
-
-        // For future secret types, check if any stage applies
-        // Build-time applies to all Docker-based deployments
-        // Runtime applies to architectures that download at startup
-        return classification.stages.length > 0;
-    }
-
-    /**
-     * Get the ARN config key for a classification.
-     * Maps classification identifiers to config field names.
-     * @param {object} classification - Secret classification entry
-     * @returns {string} Config key for the ARN value
-     * @private
-     */
-    _getArnConfigKey(classification) {
-        const keyMap = {
-            'hf-token': 'hfTokenArn',
-            'ngc-token': 'ngcTokenArn'
-        };
-        return keyMap[classification.identifier] || `${classification.identifier.replace(/-([a-z])/g, (_, c) => c.toUpperCase())}Arn`;
-    }
-
-    /**
-     * Get the plaintext config key for a classification.
-     * Maps classification identifiers to config field names.
-     * @param {object} classification - Secret classification entry
-     * @returns {string} Config key for the plaintext value
-     * @private
-     */
-    _getPlaintextConfigKey(classification) {
-        const keyMap = {
-            'hf-token': 'hfToken',
-            'ngc-token': 'ngcApiKey'
-        };
-        return keyMap[classification.identifier] || classification.identifier.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-    }
-
-    /**
-     * List managed secrets of a given type from AWS Secrets Manager.
-     * Uses the active bootstrap profile to query for secrets tagged with
-     * the mlcc:secret-type matching the given identifier.
-     * @param {string} secretType - The secret type identifier (e.g., 'hf-token')
-     * @returns {Promise<Array<{name: string, arn: string}>>} Array of managed secrets
-     * @private
-     */
-    async _listManagedSecrets(secretType) {
-        try {
-            const bootstrapConfig = new BootstrapConfig();
-            const activeProfile = bootstrapConfig.getActiveProfile();
-            if (!activeProfile) return [];
-
-            const profile = activeProfile.config.awsProfile;
-            const region = activeProfile.config.awsRegion;
-            if (!profile || !region) return [];
-
-            const command = `aws secretsmanager list-secrets --filters Key=tag-key,Values=mlcc:managed-by Key=tag-value,Values=ml-container-creator --region ${region} --profile ${profile} --output json`;
-            const output = execSync(command, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 });
-            const trimmed = output.trim();
-            if (!trimmed) return [];
-
-            const result = JSON.parse(trimmed);
-            const secrets = result.SecretList || [];
-
-            // Filter by secret type tag
-            return secrets
-                .filter(secret => {
-                    const typeTag = (secret.Tags || []).find(t => t.Key === 'mlcc:secret-type');
-                    return typeTag && typeTag.Value === secretType;
-                })
-                .map(secret => ({
-                    name: secret.Name,
-                    arn: secret.ARN
-                }));
-        } catch {
-            // If AWS CLI fails (not configured, no credentials, etc.), return empty
-            return [];
-        }
-    }
-
-    /**
-     * Display a selection list for managed secrets of a given type.
-     * Shows available secrets plus options for plaintext entry and skip.
-     * Requirements: 8.1, 8.2, 8.3, 8.4, 8.5, 8.6
-     * @param {object} classification - Secret classification entry
-     * @param {Array<{name: string, arn: string}>} managedSecrets - Available managed secrets
-     * @param {object} previousAnswers - Answers from previous phases
-     * @returns {Promise<object>} Object with the selected value keyed by config field name
-     * @private
-     */
-    async _promptSecretSelection(classification, managedSecrets, previousAnswers) {
-        const arnConfigKey = this._getArnConfigKey(classification);
-
-        console.log(`\n🔐 ${classification.displayName}`);
-        console.log(`   ${classification.purpose}`);
-
-        // Build choices: managed secrets + enter plaintext + skip
-        const choices = [
-            ...managedSecrets.map(secret => ({
-                name: `🔒 ${secret.name} (${secret.arn})`,
-                value: secret.arn,
-                short: secret.name
-            })),
-            { name: '✏️  Enter plaintext token', value: '__plaintext__', short: 'Plaintext' },
-            { name: '⏭️  Skip (use environment variable)', value: '__skip__', short: 'Skip' }
-        ];
-
-        const { secretSelection } = await this._runPrompts([{
-            type: 'list',
-            name: 'secretSelection',
-            message: `Select ${classification.promptLabel}:`,
-            choices
-        }]);
-
-        if (secretSelection === '__skip__') {
-            return {};
-        }
-
-        if (secretSelection === '__plaintext__') {
-            // Use existing plaintext flow
-            return this._promptPlaintextEntry(classification, previousAnswers);
-        }
 
-        // User selected a managed secret ARN
-        return { [arnConfigKey]: secretSelection };
-    }
-
-    /**
-     * Prompt for plaintext token entry with ARN detection.
-     * If the user enters an ARN, store it as an ARN reference.
-     * Requirements: 8.4, 8.5, 8.6
-     * @param {object} classification - Secret classification entry
-     * @param {object} previousAnswers - Answers from previous phases
-     * @returns {Promise<object>} Object with the value keyed by config field name
-     * @private
-     */
-    async _promptPlaintextEntry(classification, _previousAnswers) {
-        const arnConfigKey = this._getArnConfigKey(classification);
-        const plaintextConfigKey = this._getPlaintextConfigKey(classification);
-
-        const { tokenValue } = await this._runPrompts([{
-            type: 'input',
-            name: 'tokenValue',
-            message: `${classification.promptLabel} (enter token, ARN, or leave empty):`,
-            validate: (input) => {
-                // Empty is valid
-                if (!input || input.trim() === '') return true;
-                // Environment variable reference is valid
-                if (input.trim().startsWith('$')) return true;
-                return true;
-            }
-        }]);
-
-        if (!tokenValue || tokenValue.trim() === '') {
-            return {};
-        }
-
-        const value = tokenValue.trim();
-
-        // ARN detection: if the value is a Secrets Manager ARN, store as ARN
-        if (isSecretsManagerArn(value)) {
-            return { [arnConfigKey]: value };
-        }
-
-        // Otherwise store as plaintext
-        return { [plaintextConfigKey]: value };
-    }
-
-    /**
-     * Fall back to existing plaintext prompt when no managed secrets exist.
-     * Uses the same prompts as the original hfTokenPrompts/ngcApiKeyPrompts
-     * but with ARN detection on the input.
-     * Requirements: 8.7
-     * @param {object} classification - Secret classification entry
-     * @param {object} previousAnswers - Answers from previous phases
-     * @param {object} explicitConfig - Explicit CLI/config values
-     * @param {object} existingConfig - Existing project configuration
-     * @returns {Promise<object>} Object with the value keyed by config field name
-     * @private
-     */
-    async _promptPlaintextFallback(classification, _previousAnswers, _explicitConfig, _existingConfig) {
-        const arnConfigKey = this._getArnConfigKey(classification);
-        const plaintextConfigKey = this._getPlaintextConfigKey(classification);
-
-        // If in auto-prompt mode, skip
-        if (this.configManager?.isAutoPrompt()) {
-            return {};
-        }
-
-        // Display context-appropriate security message
-        if (classification.identifier === 'hf-token') {
-            console.log('\n🔐 HuggingFace Authentication');
-            console.log('   Many models (e.g. Llama, Mistral) are gated and require a token.');
-            console.log('   💡 Tip: Use `ml-container-creator secrets create --type hf-token` to store');
-            console.log('   your token in AWS Secrets Manager for zero-knowledge operation.');
-            console.log('   For CI/CD pipelines, use "$HF_TOKEN" to reference an environment variable.\n');
-        } else if (classification.identifier === 'ngc-token') {
-            console.log('\n🔐 NVIDIA NGC Authentication');
-            console.log('   TensorRT-LLM base images are hosted on NVIDIA NGC and require an API key.');
-            console.log('   💡 Tip: Use `ml-container-creator secrets create --type ngc-token` to store');
-            console.log('   your key in AWS Secrets Manager for zero-knowledge operation.');
-            console.log('   For CI/CD pipelines, use "$NGC_API_KEY" to reference an environment variable.\n');
-        } else {
-            console.log(`\n🔐 ${classification.displayName}`);
-            console.log(`   ${classification.purpose}\n`);
-        }
-
-        const { tokenValue } = await this._runPrompts([{
-            type: 'input',
-            name: 'tokenValue',
-            message: `${classification.promptLabel} (enter token, ARN, "$${classification.envVar}" for env var, or leave empty):`,
-            validate: (input) => {
-                if (!input || input.trim() === '') return true;
-                if (input.trim().startsWith('$')) return true;
-                // Warn about HF token format
-                if (classification.identifier === 'hf-token' && !input.startsWith('hf_') && !isSecretsManagerArn(input)) {
-                    console.warn('\n⚠️  Warning: HuggingFace tokens typically start with "hf_"');
-                    console.warn('   If this is intentional, you can ignore this warning.');
-                }
-                return true;
-            }
-        }]);
-
-        if (!tokenValue || tokenValue.trim() === '') {
-            return {};
-        }
-
-        const value = tokenValue.trim();
-
-        // ARN detection: if the value is a Secrets Manager ARN, store as ARN
-        if (isSecretsManagerArn(value)) {
-            return { [arnConfigKey]: value };
-        }
-
-        // Otherwise store as plaintext
-        return { [plaintextConfigKey]: value };
-    }
-
-    /**
-     * CUDA-to-AMI mapping.
-     * Maps CUDA major.minor versions to the SageMaker inference AMI that provides
-     * the matching CUDA driver. Derived from the framework registry patterns.
-     * @private
-     */
-    static CUDA_AMI_MAP = {
-        '11.0': 'al2-ami-sagemaker-inference-gpu-2',
-        '11.4': 'al2-ami-sagemaker-inference-gpu-2-1',
-        '11.8': 'al2-ami-sagemaker-inference-gpu-2-1',
-        '12.1': 'al2-ami-sagemaker-inference-gpu-3-1',
-        '12.2': 'al2-ami-sagemaker-inference-gpu-3-1',
-        '12.4': 'al2-ami-sagemaker-inference-gpu-3-1',
-        '12.6': 'al2-ami-sagemaker-inference-gpu-3-1',
-        '13.0': 'al2023-ami-sagemaker-inference-gpu-4-1'
-    };
-
-    /**
-     * Prompt the user to select a CUDA version when the selected GPU instance
-     * supports multiple versions. The choice transparently resolves to the
-     * correct SageMaker inference AMI.
-     *
-     * When a base image CUDA version is provided, auto-resolves by intersecting
-     * with the instance's supported versions. Removes the CUDA prompt from the
-     * interactive flow when auto-resolution succeeds.
-     *
-     * Skipped for CPU instances, non-CUDA accelerators, or when only one
-     * compatible CUDA version exists.
-     *
-     * @param {string} instanceType - Selected instance type (e.g. "ml.g5.2xlarge")
-     * @param {string} framework - Selected framework name
-     * @param {string} frameworkVersion - Selected framework version
-     * @param {string} [baseImageCuda] - CUDA version from selected base image (for auto-resolution)
-     * @returns {Promise<{cudaVersion: string, inferenceAmiVersion: string}|null>}
-     * @private
-     */
-    async _promptCudaVersion(instanceType, framework, frameworkVersion, baseImageCuda) {
-        if (!instanceType) return null;
-
-        // Look up instance in accelerator mapping
-        const instanceInfo = this._instanceAcceleratorMapping[instanceType];
-        if (!instanceInfo || instanceInfo.accelerator.type !== 'cuda') return null;
-
-        const instanceCudaVersions = instanceInfo.accelerator.versions;
-        if (!instanceCudaVersions || instanceCudaVersions.length === 0) return null;
-
-        // Auto-resolution: when base image specifies a CUDA version, intersect with instance support
-        // Requirements: 3.11, 4.9, 4.10, 4.11
-        if (baseImageCuda) {
-            const majorRequired = baseImageCuda.split('.')[0];
-            const intersection = instanceCudaVersions.filter(v => {
-                if (v === baseImageCuda) return true;
-                if (v.startsWith(`${majorRequired  }.`)) return true;
-                return false;
-            });
-
-            if (intersection.length > 0) {
-                // Auto-select: pick exact match or highest compatible
-                const exactMatch = intersection.find(v => v === baseImageCuda);
-                const selectedVersion = exactMatch || intersection.sort().pop();
-                const inferenceAmiVersion = PromptRunner.CUDA_AMI_MAP[selectedVersion];
-                if (inferenceAmiVersion) {
-                    console.log(`\n🔧 CUDA ${selectedVersion} auto-resolved from base image (requires ${baseImageCuda})`);
-                    console.log(`   AMI: ${inferenceAmiVersion}`);
-                    return { cudaVersion: selectedVersion, inferenceAmiVersion };
-                }
-            } else {
-                // No intersection — warn and fall through to manual prompt
-                console.log(`\n   ⚠️  Base image requires CUDA ${baseImageCuda} but instance ${instanceType} supports: ${instanceCudaVersions.join(', ')}`);
-                console.log('   No compatible CUDA version found. Falling back to manual selection.');
-            }
-        }
-
-        // Get framework CUDA requirements (if available)
-        const registryConfigManager = this.registryConfigManager;
-        const frameworkConfig = registryConfigManager?.frameworkRegistry?.[framework]?.[frameworkVersion];
-        const frameworkAccel = frameworkConfig?.accelerator;
-
-        // Compute compatible CUDA versions: intersection of instance support and framework range
-        let compatibleVersions;
-        if (frameworkAccel?.versionRange) {
-            const { min, max } = frameworkAccel.versionRange;
-            compatibleVersions = instanceCudaVersions.filter(v => {
-                return v >= min && v <= max;
-            });
-        } else {
-            compatibleVersions = [...instanceCudaVersions];
-        }
-
-        if (compatibleVersions.length === 0) {
-            // No overlap — fall back to all instance versions (validation already warned)
-            compatibleVersions = [...instanceCudaVersions];
-        }
-
-        // If only one option, auto-select it silently
-        if (compatibleVersions.length === 1) {
-            const cudaVersion = compatibleVersions[0];
-            const inferenceAmiVersion = PromptRunner.CUDA_AMI_MAP[cudaVersion];
-            if (inferenceAmiVersion) {
-                console.log(`\n🔧 CUDA ${cudaVersion} auto-selected (only compatible version for ${instanceType})`);
-                console.log(`   AMI: ${inferenceAmiVersion}`);
-            }
-            return inferenceAmiVersion ? { cudaVersion, inferenceAmiVersion } : null;
-        }
-
-        // Multiple options — let the user choose (or auto-select in auto-prompt mode)
-        const defaultVersion = frameworkAccel?.version
-            && compatibleVersions.includes(frameworkAccel.version)
-            ? frameworkAccel.version
-            : instanceInfo.accelerator.default || compatibleVersions[compatibleVersions.length - 1];
-
-        // In auto-prompt mode, auto-select the default without prompting
-        if (this.configManager?.isAutoPrompt()) {
-            const inferenceAmiVersion = PromptRunner.CUDA_AMI_MAP[defaultVersion];
-            if (inferenceAmiVersion) {
-                console.log(`\n🔧 CUDA ${defaultVersion} auto-selected (auto-prompt mode)`);
-                console.log(`   AMI: ${inferenceAmiVersion}`);
-            }
-            return inferenceAmiVersion ? { cudaVersion: defaultVersion, inferenceAmiVersion } : null;
-        }
-
-        const choices = compatibleVersions.map(v => {
-            const ami = PromptRunner.CUDA_AMI_MAP[v] || 'unknown';
-            const isDefault = v === defaultVersion ? ' (recommended)' : '';
-            return {
-                name: `CUDA ${v}${isDefault}  →  AMI: ${ami}`,
-                value: v,
-                short: `CUDA ${v}`
-            };
-        });
-
-        const { cudaVersion } = await this._runPrompts([{
-            type: 'list',
-            name: 'cudaVersion',
-            message: `Select CUDA version for ${instanceType} (${instanceInfo.accelerator.hardware}):`,
-            choices,
-            default: defaultVersion
-        }]);
-
-        const inferenceAmiVersion = PromptRunner.CUDA_AMI_MAP[cudaVersion];
-        if (inferenceAmiVersion) {
-            console.log(`   ✅ CUDA ${cudaVersion} → AMI: ${inferenceAmiVersion}`);
-        }
-
-        return inferenceAmiVersion ? { cudaVersion, inferenceAmiVersion } : null;
-    }
 }