@aws/ml-container-creator 0.7.1 → 0.8.0

package/src/lib/prompt-runner.js

@@ -111,6 +111,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 +604,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 +635,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 +660,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 +742,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
@@ -1746,9 +2016,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 +2041,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') {

package/src/lib/tune-catalog-validator.js

@@ -13,7 +13,7 @@
 
 /**
  * Look up a model entry in the catalog by model ID.
- * @param {string} modelId - The JumpStart model ID to look up
+ * @param {string} modelId - The model ID to look up
  * @param {Object} catalog - The tune catalog object with a `models` map
  * @returns {Object|null} The catalog entry for the model, or null if not found
  */
@@ -29,7 +29,7 @@ export function lookupModel(modelId, catalog) {
 
 /**
  * Check whether a model ID is present in the Supported Model Catalog.
- * @param {string} modelId - The JumpStart model ID to check
+ * @param {string} modelId - The model ID to check
  * @param {Object} catalog - The tune catalog object with a `models` map
  * @returns {boolean} True if the model is in the catalog
  */
@@ -41,7 +41,7 @@ export function isTuneSupported(modelId, catalog) {
  * Validate that a model ID exists in the catalog.
  * Returns a descriptive error when the model is not supported, including
  * the model name, supported families, and a reference to `do/train`.
- * @param {string} modelId - The JumpStart model ID to validate
+ * @param {string} modelId - The model ID to validate
  * @param {Object} catalog - The tune catalog object with a `models` map
  * @returns {{ valid: boolean, error?: string }}
  */
@@ -65,7 +65,7 @@ export function validateModel(modelId, catalog) {
  * Validate that a technique is supported for the given model.
  * Returns a descriptive error listing the supported techniques when
  * the requested technique is not available.
- * @param {string} modelId - The JumpStart model ID
+ * @param {string} modelId - The model ID
  * @param {string} technique - The technique to validate (e.g., 'sft', 'dpo')
  * @param {Object} catalog - The tune catalog object with a `models` map
  * @returns {{ valid: boolean, error?: string }}
@@ -92,7 +92,7 @@ export function validateTechnique(modelId, technique, catalog) {
  * Validate that a training type is supported for the given model and technique.
  * Returns a descriptive error listing the supported training types when
  * the requested type is not available.
- * @param {string} modelId - The JumpStart model ID
+ * @param {string} modelId - The model ID
  * @param {string} technique - The technique (e.g., 'sft', 'dpo')
  * @param {string} trainingType - The training type to validate (e.g., 'lora', 'full-rank')
  * @param {Object} catalog - The tune catalog object with a `models` map

package/templates/code/serve

@@ -113,7 +113,7 @@ resolve_model() {
             echo "${!_MODEL_VAR}"
             return
             ;;
-        s3|jumpstart|jumpstart-hub|registry)
+        s3|registry)
             # Check for pre-mounted artifacts first
             if [ -d "$LOCAL_MODEL_PATH" ] && [ "$(ls -A $LOCAL_MODEL_PATH 2>/dev/null)" ]; then
                 echo "Using pre-mounted model artifacts at $LOCAL_MODEL_PATH" >&2
@@ -245,7 +245,7 @@ ARG_PREFIX="--"
 
 # Define environment variables to exclude (internal variables set by base images)
 <% if (modelServer === 'vllm') { %>
-EXCLUDE_VARS=("VLLM_USAGE_SOURCE")
+EXCLUDE_VARS=("VLLM_USAGE_SOURCE" "VLLM_ENABLE_CUDA_COMPATIBILITY")
 <% } else if (modelServer === 'sglang') { %>
 EXCLUDE_VARS=()
 <% } else if (modelServer === 'tensorrt-llm') { %>

package/templates/code/serving.properties

@@ -15,7 +15,7 @@ option.model_id=<%= modelName %>
 option.model_id=<%= artifactUri %>
 <% } else { %>
 # Model will be loaded from /opt/ml/model at runtime
-# (JumpStart model without artifact URI — requires SageMaker ModelDataUrl)
+# (requires SageMaker ModelDataUrl or MODEL_ARTIFACT_URI)
 # option.model_id=/opt/ml/model
 <% } %>
 
@@ -71,7 +71,7 @@ option.model_id=<%= modelName %>
 option.model_id=<%= artifactUri %>
 <% } else { %>
 # Model will be loaded from /opt/ml/model at runtime
-# (JumpStart model without artifact URI — requires SageMaker ModelDataUrl)
+# (requires SageMaker ModelDataUrl or MODEL_ARTIFACT_URI)
 # option.model_id=/opt/ml/model
 <% } %>
 

package/templates/diffusors/serve

@@ -9,10 +9,10 @@ echo "Starting vLLM-Omni server (diffusion model serving)"
 
 # Resolve model URI prefixes that engines cannot handle natively.
 # The generator's model-picker may store provider-specific URIs
-# (e.g. jumpstart://model-txt2img-stabilityai-stable-diffusion-v2-1-base)
-# as the model identifier. vLLM expects a HuggingFace repo ID or local path.
+# (e.g. registry://my-model-group/1) as the model identifier.
+# vLLM expects a HuggingFace repo ID or local path.
 _RAW_MODEL="${VLLM_MODEL:-}"
-if [[ "$_RAW_MODEL" == jumpstart://* ]] || [[ "$_RAW_MODEL" == jumpstart-hub://* ]] || [[ "$_RAW_MODEL" == registry://* ]]; then
+if [[ "$_RAW_MODEL" == registry://* ]]; then
     if [ -d /opt/ml/model ] && [ "$(ls -A /opt/ml/model 2>/dev/null)" ]; then
         echo "Resolved VLLM_MODEL='${_RAW_MODEL}' → /opt/ml/model (local artifacts found)"
         export VLLM_MODEL="/opt/ml/model"

package/templates/do/.tune_helper.py

@@ -176,7 +176,7 @@ def cmd_submit(args):
             )
         elif "ValidationException" in error_msg and "license" in error_msg.lower():
             _error_exit(
-                f"Model license not accepted. Accept the license in JumpStart before "
+                f"Model license not accepted. Accept the model license before "
                 f"using this model for customization. Details: {error_msg}"
             )
         else:
@@ -660,7 +660,7 @@ def main():
 
     # ── submit ────────────────────────────────────────────────────────────────
     submit_parser = subparsers.add_parser("submit", help="Submit a customization job")
-    submit_parser.add_argument("--model-id", required=True, help="JumpStart model ID")
+    submit_parser.add_argument("--model-id", required=True, help="Model ID")
     submit_parser.add_argument("--technique", required=True,
                                choices=["sft", "dpo", "rlaif", "rlvr"],
                                help="Customization technique")

package/templates/do/register

@@ -191,8 +191,14 @@ fi
 # ============================================================
 
 # DEPLOYMENT_CONFIG format: <architecture>-<backend> (e.g., transformers-vllm, http-flask, triton-fil)
-ARCHITECTURE="${DEPLOYMENT_CONFIG%%-*}"
-BACKEND="${DEPLOYMENT_CONFIG#*-}"
+# Special case: marketplace has no backend
+if [ "${DEPLOYMENT_CONFIG}" = "marketplace" ]; then
+    ARCHITECTURE="marketplace"
+    BACKEND=""
+else
+    ARCHITECTURE="${DEPLOYMENT_CONFIG%%-*}"
+    BACKEND="${DEPLOYMENT_CONFIG#*-}"
+fi
 
 echo "📋 Registering deployment to registry"
 echo "   Project: ${PROJECT_NAME}"

package/templates/do/test

@@ -103,9 +103,9 @@ case "${FRAMEWORK}" in
         case "${MODEL_SERVER}" in
             vllm|sglang)
                 # OpenAI-compatible chat completions format
-                # For S3/JumpStart models, vLLM registers the model under the local path
+                # For S3/registry models, vLLM registers the model under the local path
                 VLLM_MODEL_NAME="${MODEL_NAME}"
-                if [[ "${MODEL_NAME}" == jumpstart://* ]] || [[ "${MODEL_NAME}" == jumpstart-hub://* ]] || [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
+                if [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
                     VLLM_MODEL_NAME="/opt/ml/model"
                 fi
                 TEST_PAYLOAD='{"model": "'"${VLLM_MODEL_NAME}"'", "messages": [{"role": "user", "content": "What is machine learning?"}], "max_tokens": 50, "temperature": 0.7}'
@@ -431,7 +431,7 @@ case "${FRAMEWORK}" in
         case "${MODEL_SERVER}" in
             vllm|sglang)
                 VLLM_MODEL_NAME="${MODEL_NAME}"
-                if [[ "${MODEL_NAME}" == jumpstart://* ]] || [[ "${MODEL_NAME}" == jumpstart-hub://* ]] || [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
+                if [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
                     VLLM_MODEL_NAME="/opt/ml/model"
                 fi
                 TEST_PAYLOAD='{"model": "'"${VLLM_MODEL_NAME}"'", "messages": [{"role": "user", "content": "What is machine learning?"}], "max_tokens": 50, "temperature": 0.7}'
@@ -808,7 +808,7 @@ case "${FRAMEWORK}" in
             vllm|sglang)
                 # OpenAI-compatible chat completions format
                 VLLM_MODEL_NAME="${MODEL_NAME}"
-                if [[ "${MODEL_NAME}" == jumpstart://* ]] || [[ "${MODEL_NAME}" == jumpstart-hub://* ]] || [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
+                if [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
                     VLLM_MODEL_NAME="/opt/ml/model"
                 fi
                 TEST_PAYLOAD='{"model": "'"${VLLM_MODEL_NAME}"'", "messages": [{"role": "user", "content": "What is machine learning?"}], "max_tokens": 50, "temperature": 0.7}'
@@ -1095,7 +1095,7 @@ case "${FRAMEWORK}" in
         case "${MODEL_SERVER}" in
             vllm|sglang)
                 VLLM_MODEL_NAME="${MODEL_NAME}"
-                if [[ "${MODEL_NAME}" == jumpstart://* ]] || [[ "${MODEL_NAME}" == jumpstart-hub://* ]] || [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
+                if [[ "${MODEL_NAME}" == s3://* ]] || [[ "${MODEL_NAME}" == /opt/ml/* ]]; then
                     VLLM_MODEL_NAME="/opt/ml/model"
                 fi
                 TEST_PAYLOAD='{"model": "'"${VLLM_MODEL_NAME}"'", "messages": [{"role": "user", "content": "What is machine learning?"}], "max_tokens": 50, "temperature": 0.7}'

package/templates/do/tune

@@ -67,7 +67,7 @@ _parse_args() {
                 ARG_TRAINING_TYPE="$2"; shift 2 ;;
             --model)
                 if [ -z "${2:-}" ]; then
-                    echo "❌ --model requires a JumpStart model ID"
+                    echo "❌ --model requires a model ID"
                     exit 1
                 fi
                 ARG_MODEL="$2"; shift 2 ;;
@@ -287,7 +287,7 @@ for family in sorted(families.keys()):
     for entry in entries:
         techniques = list(entry.get('techniques', {}).keys())
         print(f'    • {entry[\"displayName\"]}')
-        print(f'      ID: {entry[\"jumpStartModelId\"]}')
+        print(f'      ID: {entry[\"modelId\"]}')
         for t in techniques:
             tc = entry['techniques'][t]
             types = ', '.join(tc.get('trainingTypes', []))