@aws/ml-container-creator 0.7.1 → 0.9.0

package/src/lib/e2e-quota-validator.js

@@ -0,0 +1,135 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * E2E Quota Validator
+ *
+ * Validates that the AWS account has sufficient service quotas for the
+ * instance types required by a given tier in the e2e catalog.
+ *
+ * Requirements: 3.3, 3.4
+ */
+
+import { ServiceQuotasClient, GetServiceQuotaCommand } from '@aws-sdk/client-service-quotas';
+import { filterByTier } from './e2e-catalog-validator.js';
+
+/**
+ * Instance type to Service Quotas quota code mapping.
+ * SageMaker real-time endpoint instance quotas follow a naming pattern.
+ * This map covers the instance types used in the e2e catalog.
+ */
+const INSTANCE_QUOTA_CODES = {
+    'ml.g6e.xlarge': 'L-2D6591FA',
+    'ml.g6e.2xlarge': 'L-2D6591FA',
+    'ml.g6e.4xlarge': 'L-2D6591FA',
+    'ml.g6e.12xlarge': 'L-2D6591FA',
+    'ml.g5.xlarge': 'L-0100B498',
+    'ml.g5.2xlarge': 'L-0100B498',
+    'ml.m5.xlarge': 'L-ABB2FAC3',
+    'ml.p5.48xlarge': 'L-E89A212B'
+};
+
+const SAGEMAKER_SERVICE_CODE = 'sagemaker';
+
+/**
+ * Parse the instance type from a CLI args string.
+ *
+ * Looks for `--instance-type=<value>` or `--instance-type <value>` patterns.
+ *
+ * @param {string} args - The CLI args string
+ * @returns {string|null} The instance type value, or null if not found
+ */
+export function parseInstanceType(args) {
+    if (!args || typeof args !== 'string') {
+        return null;
+    }
+
+    // Match --instance-type=value or --instance-type value
+    const equalMatch = args.match(/--instance-type=(\S+)/);
+    if (equalMatch) {
+        return equalMatch[1];
+    }
+
+    const spaceMatch = args.match(/--instance-type\s+(\S+)/);
+    if (spaceMatch) {
+        return spaceMatch[1];
+    }
+
+    return null;
+}
+
+/**
+ * Sum instance counts per type for a given tier in the catalog.
+ *
+ * @param {string} tier - The tier to filter by
+ * @param {Object} catalog - The catalog object
+ * @returns {Map<string, number>} Map of instance type to required count
+ */
+export function sumInstanceRequirements(tier, catalog) {
+    const configs = filterByTier(catalog, tier);
+    const counts = new Map();
+
+    for (const config of configs) {
+        const instanceType = parseInstanceType(config.args);
+        if (instanceType) {
+            counts.set(instanceType, (counts.get(instanceType) || 0) + 1);
+        }
+    }
+
+    return counts;
+}
+
+/**
+ * Validate that the AWS account has sufficient quotas for the instance types
+ * required by a given tier.
+ *
+ * @param {string} tier - The tier to validate quotas for
+ * @param {Object} catalog - The catalog object
+ * @param {string} region - The AWS region to check quotas in
+ * @param {Object} [options] - Optional configuration
+ * @param {Object} [options.client] - Pre-configured ServiceQuotasClient (for testing)
+ * @returns {Promise<Array<{instanceType: string, required: number, available: number, sufficient: boolean}>>}
+ */
+export async function validateQuotas(tier, catalog, region, options = {}) {
+    const instanceRequirements = sumInstanceRequirements(tier, catalog);
+    const results = [];
+
+    if (instanceRequirements.size === 0) {
+        return results;
+    }
+
+    const client = options.client || new ServiceQuotasClient({ region });
+
+    for (const [instanceType, required] of instanceRequirements) {
+        const quotaCode = INSTANCE_QUOTA_CODES[instanceType];
+        let available = 0;
+
+        if (quotaCode) {
+            try {
+                const command = new GetServiceQuotaCommand({
+                    ServiceCode: SAGEMAKER_SERVICE_CODE,
+                    QuotaCode: quotaCode
+                });
+                const response = await client.send(command);
+                available = response.Quota?.Value ?? 0;
+            } catch (err) {
+                // If we can't fetch the quota, assume 0 and warn
+                console.warn(`⚠️  Could not fetch quota for ${instanceType}: ${err.message}`);
+                available = 0;
+            }
+        } else {
+            console.warn(`⚠️  No quota code mapping for ${instanceType}, skipping quota check`);
+            available = 0;
+        }
+
+        const sufficient = available >= required;
+
+        if (!sufficient) {
+            console.warn(`⚠️  ${instanceType} quota is ${available}, need ${required} for ${tier} tier`);
+        }
+
+        results.push({ instanceType, required, available, sufficient });
+    }
+
+    return results;
+}

package/src/lib/mcp-client.js

@@ -14,6 +14,12 @@
 
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __mcp_filename = fileURLToPath(import.meta.url);
+const __mcp_dirname = path.dirname(__mcp_filename);
+const PACKAGE_ROOT = path.resolve(__mcp_dirname, '../..');
 
 const DEFAULT_TOOL_NAME = 'get_ml_config';
 const DEFAULT_LIMIT = 10;
@@ -96,6 +102,15 @@ class McpClient {
     async _executeQuery() {
         const { command, args = [], env } = this.serverConfig;
 
+        // Resolve relative paths in args against the package root
+        const resolvedArgs = args.map(arg => {
+            if (arg && !path.isAbsolute(arg) && !arg.startsWith('-')) {
+                const resolved = path.resolve(PACKAGE_ROOT, arg);
+                return resolved;
+            }
+            return arg;
+        });
+
         // Build environment: merge process.env with server-specific env
         // When --smart flag is active, inject BEDROCK_SMART=true for this run
         // Discover mode is now default; inject DISCOVER_MODE=false only when explicitly disabled
@@ -108,7 +123,7 @@ class McpClient {
         // Create stdio transport — spawns the server process
         this._transport = new StdioClientTransport({
             command,
-            args,
+            args: resolvedArgs,
             env: spawnEnv,
             stderr: 'pipe'
         });

package/src/lib/mcp-command-handler.js

@@ -91,8 +91,12 @@ export default class McpCommandHandler {
             const installed = await this._installBundledDependencies(resolved.serverDir, name);
             if (!installed) return;
 
+            // Store path relative to package root for portability
+            const packageRoot = path.resolve(__dirname, '../..');
+            const relativePath = path.relative(packageRoot, resolved.entryPoint);
+
             command = 'node';
-            commandArgs = [resolved.entryPoint];
+            commandArgs = [relativePath];
         } else {
             // Find the '--' separator to split name from command
             const separatorIndex = positionalArgs.indexOf('--');
@@ -195,9 +199,13 @@ export default class McpCommandHandler {
             const installed = await this._installBundledDependencies(resolved.serverDir, server.name);
             if (!installed) continue;
 
+            // Store path relative to package root for portability across machines
+            const packageRoot = path.resolve(__dirname, '../..');
+            const relativePath = path.relative(packageRoot, resolved.entryPoint);
+
             config.mcpServers[server.name] = {
                 command: 'node',
-                args: [resolved.entryPoint]
+                args: [relativePath]
             };
             added++;
         }

package/src/lib/prompt-runner.js

@@ -50,6 +50,20 @@ 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 }) {
         this.configManager = configManager;
@@ -111,6 +125,14 @@ export default class PromptRunner {
             framework: framework || deploymentConfigAnswers.framework,
             modelServer: modelServer || deploymentConfigAnswers.modelServer
         };
+
+        // ──────────────────────────────────────────────────────────────────────
+        // Marketplace fast-path: skip all container-related prompts
+        // Requirements: 2.3, 2.4, 2.5
+        // ──────────────────────────────────────────────────────────────────────
+        if (frameworkAnswers.architecture === 'marketplace') {
+            return this._runMarketplaceFlow(frameworkAnswers, explicitConfig, existingConfig, buildTimestamp);
+        }
         
         // Engine prompt for http architecture
         const engineAnswers = await this._runPhase(enginePrompts, { ...frameworkAnswers }, explicitConfig, existingConfig);
@@ -596,13 +618,27 @@ export default class PromptRunner {
         // Infer modelSource from model name prefix if not set by MCP
         const modelName = combinedAnswers.customModelName || combinedAnswers.modelName;
         if (!combinedAnswers.modelSource && modelName) {
-            if (modelName.startsWith('s3://')) {
+            // Reject deprecated JumpStart prefixes with migration message
+            if (modelName.startsWith('jumpstart://') || modelName.startsWith('jumpstart-hub://')) {
+                const bareId = modelName.replace(/^jumpstart(-hub)?:\/\//, '');
+                console.error(`\n   ⚠️  JumpStart is no longer supported. Use the HuggingFace model ID directly: ${bareId}`);
+                console.error('   JumpStart model sources have been removed. Use one of:');
+                console.error('     • HuggingFace model ID (e.g., meta-llama/Llama-2-7b-hf)');
+                console.error('     • s3://bucket/path/model.tar.gz');
+                console.error('     • registry://model-package-name');
+                console.error('     • marketplace://arn:aws:sagemaker:...\n');
+                process.exit(1);
+            }
+            if (modelName.startsWith('marketplace://')) {
+                // marketplace://arn:aws:sagemaker:... → set architecture to marketplace and store ARN
+                const arn = modelName.replace(/^marketplace:\/\//, '');
+                combinedAnswers.modelPackageArn = arn;
+                combinedAnswers.architecture = 'marketplace';
+                combinedAnswers.deploymentConfig = 'marketplace';
+                combinedAnswers.modelSource = undefined;
+            } else if (modelName.startsWith('s3://')) {
                 combinedAnswers.modelSource = 's3';
                 combinedAnswers.artifactUri = modelName;
-            } else if (modelName.startsWith('jumpstart://')) {
-                combinedAnswers.modelSource = 'jumpstart';
-            } else if (modelName.startsWith('jumpstart-hub://')) {
-                combinedAnswers.modelSource = 'jumpstart-hub';
             } else if (modelName.startsWith('registry://')) {
                 combinedAnswers.modelSource = 'registry';
             }
@@ -613,7 +649,7 @@ export default class PromptRunner {
                 combinedAnswers.artifactUri = modelName;
             }
         }
-        const downloadSources = ['jumpstart', 's3'];
+        const downloadSources = ['s3'];
         if (downloadSources.includes(combinedAnswers.modelSource) && !combinedAnswers.artifactUri) {
             console.log(`\n   ⚠️  Model source is '${combinedAnswers.modelSource}' but no artifact URI was resolved.`);
             console.log('   The model-picker could not determine the download location.');
@@ -638,18 +674,7 @@ export default class PromptRunner {
             }
         }
 
-        // Warn about jumpstart-hub:// models — private hub deployment requires
-        // HubAccessConfig on CreateModel, which is not yet supported by the generator.
-        if (combinedAnswers.modelSource === 'jumpstart-hub') {
-            console.log('\n   ⚠️  JumpStart Private Hub models are not yet fully supported.');
-            console.log('   Private hub artifacts live in AWS-managed S3 buckets that require');
-            console.log('   SageMaker\'s HubAccessConfig mechanism for access.');
-            console.log('   The generated project will not be able to download model artifacts at runtime.');
-            console.log('   This feature is tracked for a future release.\n');
-            console.log('   Falling back to HuggingFace source.\n');
-            combinedAnswers.modelSource = 'huggingface';
-            delete combinedAnswers.artifactUri;
-        }
+
 
         // Apply auto-set model format for Triton backends with single format
         // Requirements: 3.3, 3.4, 3.5
@@ -731,6 +756,265 @@ 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
      * @param {string} parameterName - Name of the parameter
@@ -1114,7 +1398,7 @@ export default class PromptRunner {
             const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
             const { StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js');
 
-            const serverArgs = [...(serverConfig.args || [])];
+            const serverArgs = [...resolveMcpArgs(serverConfig.args)];
             if (!discover && !serverArgs.includes('--no-discover')) {
                 serverArgs.push('--no-discover');
             }
@@ -1669,7 +1953,7 @@ export default class PromptRunner {
 
                             const transport = new StdioClientTransport({
                                 command: serverConfig.command,
-                                args: serverConfig.args || [],
+                                args: resolveMcpArgs(serverConfig.args),
                                 env: { ...process.env, ...(serverConfig.env || {}) },
                                 stderr: 'pipe'
                             });
@@ -1746,9 +2030,7 @@ export default class PromptRunner {
             const registryConfigManager = this.registryConfigManager;
             if (registryConfigManager) {
                 // Only try HuggingFace API for bare model IDs (not prefixed URIs)
-                const isNonHfUri = modelId.startsWith('jumpstart://') ||
-                        modelId.startsWith('jumpstart-hub://') ||
-                        modelId.startsWith('s3://') ||
+                const isNonHfUri = modelId.startsWith('s3://') ||
                         modelId.startsWith('registry://');
 
                 if (!isNonHfUri) {
@@ -1773,7 +2055,7 @@ export default class PromptRunner {
                         console.log('   ⚠️  HuggingFace API unavailable');
                     }
                 } else {
-                    // Non-HF URI (jumpstart://, s3://, etc.) — skip HF lookup silently
+                    // Non-HF URI (s3://, registry://, etc.) — skip HF lookup silently
                     // The summary at the end of this function will report "No additional model information"
                 }
 

package/src/lib/prompts.js

@@ -232,6 +232,12 @@ const deploymentConfigPrompts = [
                 name: 'Diffusors with vLLM Omni',
                 value: 'diffusors-vllm-omni',
                 short: 'diffusors-vllm-omni'
+            },
+            { type: 'separator', separator: '── AWS Marketplace ──' },
+            {
+                name: 'Marketplace Model Package',
+                value: 'marketplace',
+                short: 'marketplace'
             }
         ]
     }
@@ -469,9 +475,9 @@ const modelFormatPrompts = [
             if (!input || input.trim() === '') {
                 return 'Model name is required';
             }
-            // Basic validation - must contain a slash (org/model, hub/model, s3://path, etc.)
+            // Basic validation - must contain a slash (org/model, s3://path, etc.)
             if (!input.includes('/')) {
-                return 'Please use the full model path (e.g., microsoft/DialoGPT-medium, jumpstart-hub://my-hub/my-model)';
+                return 'Please use the full model path (e.g., microsoft/DialoGPT-medium, s3://bucket/model, registry://my-package)';
             }
             return true;
         },
@@ -583,7 +589,7 @@ const hfTokenPrompts = [
             }
             
             // Skip HF token prompt for non-HuggingFace model sources
-            // (S3, JumpStart, Private Hub, Registry models don't need HF auth)
+            // (S3, Registry models don't need HF auth)
             const modelSource = answers.modelSource;
             if (modelSource && modelSource !== 'huggingface') {
                 return false;

package/src/lib/template-manager.js

@@ -50,7 +50,7 @@ export default class TemplateManager {
      */
     validate() {
         const supportedOptions = {
-            // 15 canonical deployment-config values (2 http, 5 transformers, 7 triton, 1 diffusors)
+            // 16 canonical deployment-config values (2 http, 5 transformers, 7 triton, 1 diffusors, 1 marketplace)
             deploymentConfigs: [
                 // HTTP architecture (2)
                 'http-flask', 'http-fastapi',
@@ -61,7 +61,9 @@ export default class TemplateManager {
                 'triton-fil', 'triton-onnxruntime', 'triton-tensorflow',
                 'triton-pytorch', 'triton-vllm', 'triton-tensorrtllm', 'triton-python',
                 // Diffusors architecture (1)
-                'diffusors-vllm-omni'
+                'diffusors-vllm-omni',
+                // Marketplace architecture (1)
+                'marketplace'
             ],
             buildTargets: ['codebuild'],
             deploymentTargets: ['realtime-inference', 'async-inference', 'batch-transform', 'hyperpod-eks'],
@@ -82,7 +84,7 @@ export default class TemplateManager {
             this._validateGpuRequirement();
         } else {
             // Fallback: validate architecture and backend separately (new canonical format)
-            const architectures = ['http', 'transformers', 'triton', 'diffusors'];
+            const architectures = ['http', 'transformers', 'triton', 'diffusors', 'marketplace'];
             const backends = [
                 // http backends
                 'flask', 'fastapi',
@@ -95,7 +97,11 @@ export default class TemplateManager {
             ];
             
             this._validateChoice('architecture', architectures);
-            this._validateChoice('backend', backends);
+            
+            // Marketplace has no backend — skip backend validation
+            if (this.answers.architecture !== 'marketplace') {
+                this._validateChoice('backend', backends);
+            }
             
             // Validate tensorrt-llm is only used with transformers architecture
             if (this.answers.backend === 'tensorrt-llm' && this.answers.architecture !== 'transformers') {