@aws/ml-container-creator 1.0.4 → 1.1.0

package/src/lib/tune-config-state.js

@@ -2,65 +2,91 @@
 // SPDX-License-Identifier: Apache-2.0
 
 /**
- * Tune Config State Manager
+ * Tune Config State
  *
- * JavaScript module that mimics the bash _update_config_var() behavior
- * from do/tune for testing purposes. Manages config variables written
- * after job submission.
+ * Manages bash-style config files (do/config) that contain lines like:
+ *   export VAR_NAME="value"
+ *
+ * Provides read/write access for tuning job state variables.
  */
 
 import { readFileSync, writeFileSync } from 'node:fs';
 
 /**
- * Update or add a config variable in a do/config-style file.
- * Mimics the bash _update_config_var() function:
- * - If the variable exists (line starts with `export VAR_NAME=`), replace it
- * - Otherwise, append a new line
+ * Read a variable value from a bash config file.
+ * Looks for lines matching: export VAR_NAME="value", export VAR_NAME='value', or export VAR_NAME=value
  *
  * @param {string} configPath - Path to the config file
- * @param {string} varName - Variable name (e.g., TUNE_JOB_NAME_SFT)
- * @param {string} varValue - Variable value
+ * @param {string} varName - Variable name to read
+ * @returns {string|null} The unquoted value, or null if not found
  */
-export function updateConfigVar(configPath, varName, varValue) {
-    let content = readFileSync(configPath, 'utf8');
-    const pattern = new RegExp(`^export ${varName}=.*$`, 'm');
+export function readConfigVar(configPath, varName) {
+    const content = readFileSync(configPath, 'utf8');
+    const lines = content.split('\n');
 
-    if (pattern.test(content)) {
-        content = content.replace(pattern, `export ${varName}="${varValue}"`);
-    } else {
-        if (content.length > 0 && !content.endsWith('\n')) {
-            content += '\n';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const prefix = `export ${varName}=`;
+        if (trimmed.startsWith(prefix)) {
+            let value = trimmed.slice(prefix.length);
+            // Strip surrounding quotes (double or single)
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith('\'') && value.endsWith('\''))) {
+                value = value.slice(1, -1);
+            }
+            return value;
         }
-        content += `export ${varName}="${varValue}"\n`;
     }
 
-    writeFileSync(configPath, content, 'utf8');
+    return null;
 }
 
 /**
- * Read a config variable from a do/config-style file.
+ * Write or update a variable in a bash config file.
+ * If the variable already exists, replaces that line.
+ * If not, appends the new export line.
  *
  * @param {string} configPath - Path to the config file
- * @param {string} varName - Variable name to read
- * @returns {string|null} The variable value, or null if not found
+ * @param {string} varName - Variable name to set
+ * @param {string} value - Value to assign
  */
-export function readConfigVar(configPath, varName) {
+export function updateConfigVar(configPath, varName, value) {
     const content = readFileSync(configPath, 'utf8');
-    const pattern = new RegExp(`^export ${varName}="([^"]*)"`, 'm');
-    const match = content.match(pattern);
-    return match ? match[1] : null;
+    const lines = content.split('\n');
+    const prefix = `export ${varName}=`;
+    const newLine = `export ${varName}="${value}"`;
+
+    let found = false;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim().startsWith(prefix)) {
+            lines[i] = newLine;
+            found = true;
+            break;
+        }
+    }
+
+    if (found) {
+        writeFileSync(configPath, lines.join('\n'), 'utf8');
+    } else {
+        // Append to end of file
+        let appendContent = content;
+        if (appendContent.length > 0 && !appendContent.endsWith('\n')) {
+            appendContent += '\n';
+        }
+        appendContent += `${newLine  }\n`;
+        writeFileSync(configPath, appendContent, 'utf8');
+    }
 }
 
 /**
- * Simulate the config writes that happen after a successful job submission.
- * This mirrors the behavior in do/tune's _submit_job() function.
+ * Write tuning job submission state to config.
  *
  * @param {string} configPath - Path to the config file
- * @param {object} params - Submission parameters
- * @param {string} params.technique - Technique (sft, dpo, rlaif, rlvr)
- * @param {string} params.trainingType - Training type (lora, full-rank)
- * @param {string} params.datasetPath - Dataset path (s3://... or hf://...)
- * @param {string} params.jobName - Generated job name
+ * @param {object} state - Submission state
+ * @param {string} state.technique - Tuning technique (e.g., 'sft', 'dpo')
+ * @param {string} state.trainingType - Training type (e.g., 'lora', 'full-rank')
+ * @param {string} state.datasetPath - Dataset path (S3 or HF URI)
+ * @param {string} state.jobName - Generated job name
  */
 export function persistSubmissionState(configPath, { technique, trainingType, datasetPath, jobName }) {
     const techniqueUpper = technique.toUpperCase();
@@ -71,59 +97,54 @@ export function persistSubmissionState(configPath, { technique, trainingType, da
 }
 
 /**
- * Simulate the config writes that happen after a job completes successfully.
- * This mirrors the behavior in do/tune's _handle_completion() function.
- *
- * Writes three levels of tracking (AC-4.1, AC-4.2):
- * - Level 1: TUNE_OUTPUT_PATH_LATEST (always the last run, any technique)
- * - Level 2: TUNE_ADAPTER_PATH_<TECHNIQUE> (last run per technique)
- * - Level 3: TUNE_ADAPTER_PATH_<TECHNIQUE>_<SLUG> (per technique + dataset slug)
+ * Write tuning job completion state to config.
  *
  * @param {string} configPath - Path to the config file
- * @param {object} params - Completion parameters
- * @param {string} params.technique - Technique (sft, dpo, rlaif, rlvr)
- * @param {string} params.trainingType - Training type (lora, full-rank)
- * @param {string} params.artifactPath - S3 path to the output artifact
- * @param {string} params.outputType - Output type (adapter, full-model)
- * @param {string} [params.datasetSlug] - Optional dataset slug for per-technique-per-dataset tracking
+ * @param {object} state - Completion state
+ * @param {string} state.technique - Tuning technique
+ * @param {string} state.trainingType - Training type
+ * @param {string} state.artifactPath - Output artifact path (S3 URI)
+ * @param {string} state.outputType - Output type ('adapter' or 'model')
+ * @param {string} [state.datasetSlug] - Dataset slug for named paths
  */
-export function persistCompletionState(configPath, { technique, trainingType, artifactPath, outputType, datasetSlug }) {
+export function persistCompletionState(configPath, { technique, trainingType: _trainingType, artifactPath, outputType, datasetSlug }) {
     const techniqueUpper = technique.toUpperCase();
 
-    if (trainingType === 'lora') {
-        // Level 2: per-technique
+    updateConfigVar(configPath, 'TUNE_OUTPUT_PATH_LATEST', artifactPath);
+    updateConfigVar(configPath, 'TUNE_OUTPUT_TYPE_LATEST', outputType);
+
+    if (outputType === 'adapter') {
         updateConfigVar(configPath, `TUNE_ADAPTER_PATH_${techniqueUpper}`, artifactPath);
-        // Level 3: per-technique + per-dataset (if slug available)
         if (datasetSlug) {
             const slugUpper = datasetSlug.toUpperCase().replace(/-/g, '_');
             updateConfigVar(configPath, `TUNE_ADAPTER_PATH_${techniqueUpper}_${slugUpper}`, artifactPath);
         }
-    } else if (trainingType === 'full-rank') {
+    } else {
         updateConfigVar(configPath, `TUNE_MODEL_PATH_${techniqueUpper}`, artifactPath);
     }
-
-    // Level 1: latest
-    updateConfigVar(configPath, 'TUNE_OUTPUT_PATH_LATEST', artifactPath);
-    updateConfigVar(configPath, 'TUNE_OUTPUT_TYPE_LATEST', outputType);
 }
 
 /**
- * Generate a job name following the pattern used by do/tune.
- * Pattern: ${projectName}-tune-${technique}-YYYYMMDD-HHMMSS
+ * Generate a job name matching pattern: ${projectName}-tune-${technique}-YYYYMMDD-HHMMSS
+ * Uses local time for the timestamp.
  *
  * @param {string} projectName - Project name
- * @param {string} technique - Technique (sft, dpo, rlaif, rlvr)
- * @param {Date} [timestamp] - Optional timestamp (defaults to now)
- * @returns {string} Generated job name
+ * @param {string} technique - Tuning technique
+ * @param {Date} [timestamp] - Optional timestamp (defaults to new Date())
+ * @returns {string} Formatted job name
  */
-export function generateJobName(projectName, technique, timestamp = new Date()) {
-    const year = timestamp.getFullYear().toString();
-    const month = (timestamp.getMonth() + 1).toString().padStart(2, '0');
-    const day = timestamp.getDate().toString().padStart(2, '0');
-    const hours = timestamp.getHours().toString().padStart(2, '0');
-    const minutes = timestamp.getMinutes().toString().padStart(2, '0');
-    const seconds = timestamp.getSeconds().toString().padStart(2, '0');
+export function generateJobName(projectName, technique, timestamp) {
+    const ts = timestamp || new Date();
+
+    const year = ts.getFullYear().toString();
+    const month = (ts.getMonth() + 1).toString().padStart(2, '0');
+    const day = ts.getDate().toString().padStart(2, '0');
+    const hours = ts.getHours().toString().padStart(2, '0');
+    const minutes = ts.getMinutes().toString().padStart(2, '0');
+    const seconds = ts.getSeconds().toString().padStart(2, '0');
+
     const dateStr = `${year}${month}${day}`;
     const timeStr = `${hours}${minutes}${seconds}`;
+
     return `${projectName}-tune-${technique}-${dateStr}-${timeStr}`;
 }

package/templates/do/config

@@ -220,6 +220,9 @@ export <%= key %>=${<%= key %>:-<%= value %>}
 <% Object.entries(icEnvVars).forEach(([key, value]) => { %>
 export IC_ENV_<%= key %>=${IC_ENV_<%= key %>:-<%= value %>}
 <% }); %>
+<% if ((modelServer === 'vllm' || modelServer === 'sglang') && !icEnvVars['VLLM_MAX_MODEL_LEN'] && !icEnvVars['SGLANG_MAX_MODEL_LEN']) { %>
+export IC_ENV_VLLM_MAX_MODEL_LEN=${IC_ENV_VLLM_MAX_MODEL_LEN:-4096}
+<% } %>
 <% } else if (deploymentTarget === 'realtime-inference') { %>
 # ─── Deploy-time IC environment variables (uncomment to configure) ─────────────
 # These are passed as the Environment field in InferenceComponent.create() at deploy time.
@@ -227,7 +230,9 @@ export IC_ENV_<%= key %>=${IC_ENV_<%= key %>:-<%= value %>}
 # Max 16 vars, max 1024 chars per key/value.
 # WARNING: Do not store raw secrets here. Use Secrets Manager ARN pattern instead:
 #   export IC_ENV_HF_TOKEN_ARN=arn:aws:secretsmanager:REGION:ACCOUNT:secret:NAME
-# export IC_ENV_VLLM_MAX_MODEL_LEN=8192
+<% if (modelServer === 'vllm' || modelServer === 'sglang') { %>
+export IC_ENV_VLLM_MAX_MODEL_LEN=${IC_ENV_VLLM_MAX_MODEL_LEN:-4096}
+<% } %>
 # export IC_ENV_VLLM_GPU_MEMORY_UTILIZATION=0.85
 <% } %>
 

package/src/lib/auto-prompt-builder.js

@@ -1,172 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * Auto-Prompt Builder — generates targeted prompts for missing required parameters.
- * 
- * Used by --auto-prompt mode to ask only for values that cannot be inferred
- * or defaulted from the provided CLI flags.
- */
-
-/**
- * Builds a minimal set of prompts for the given missing parameters.
- * Each prompt is self-contained and doesn't depend on multi-phase wizard state.
- *
- * @param {string[]} missingParams - Parameter names that need values
- * @param {object} currentConfig - Current configuration (with defaults filled)
- * @returns {Array} Array of prompt objects compatible with runPrompts()
- */
-export function buildAutoPrompts(missingParams, currentConfig) {
-    const prompts = [];
-
-    for (const param of missingParams) {
-        const builder = PROMPT_BUILDERS[param];
-        if (builder) {
-            const prompt = builder(currentConfig);
-            if (prompt) {
-                prompts.push(prompt);
-            }
-        } else {
-            // Fallback: generic text input for unknown parameters
-            prompts.push({
-                type: 'input',
-                name: param,
-                message: `Enter value for ${param}:`
-            });
-        }
-    }
-
-    return prompts;
-}
-
-/**
- * Map of parameter names to prompt builder functions.
- * Each builder receives the current config and returns a prompt object.
- */
-const PROMPT_BUILDERS = {
-    deploymentConfig: (_config) => ({
-        type: 'list',
-        name: 'deploymentConfig',
-        message: 'Select deployment configuration:',
-        choices: [
-            { type: 'separator', separator: '── Large Language Models ──' },
-            { name: 'Transformers with vLLM', value: 'transformers-vllm' },
-            { name: 'Transformers with SGLang', value: 'transformers-sglang' },
-            { name: 'Transformers with TensorRT-LLM', value: 'transformers-tensorrt-llm' },
-            { name: 'Transformers with LMI', value: 'transformers-lmi' },
-            { name: 'Transformers with DJL', value: 'transformers-djl' },
-            { type: 'separator', separator: '── HTTP Serving ──' },
-            { name: 'HTTP with Flask', value: 'http-flask' },
-            { name: 'HTTP with FastAPI', value: 'http-fastapi' },
-            { type: 'separator', separator: '── NVIDIA Triton ──' },
-            { name: 'Triton FIL (XGBoost, LightGBM)', value: 'triton-fil' },
-            { name: 'Triton ONNX Runtime', value: 'triton-onnxruntime' },
-            { name: 'Triton TensorFlow', value: 'triton-tensorflow' },
-            { name: 'Triton PyTorch', value: 'triton-pytorch' },
-            { name: 'Triton vLLM', value: 'triton-vllm' },
-            { name: 'Triton TensorRT-LLM', value: 'triton-tensorrtllm' },
-            { name: 'Triton Python Backend', value: 'triton-python' },
-            { type: 'separator', separator: '── Diffusion Models ──' },
-            { name: 'Diffusors with vLLM Omni', value: 'diffusors-vllm-omni' }
-        ]
-    }),
-
-    instanceType: (config) => {
-        const architecture = config.architecture || 'http';
-        const isGpu = architecture === 'transformers' || architecture === 'triton' || architecture === 'diffusors';
-
-        const gpuChoices = [
-            { name: 'ml.g5.xlarge  (1× A10G 24GB — small LLMs)', value: 'ml.g5.xlarge' },
-            { name: 'ml.g5.2xlarge (1× A10G 24GB — medium LLMs)', value: 'ml.g5.2xlarge' },
-            { name: 'ml.g5.4xlarge (1× A10G 24GB — larger models)', value: 'ml.g5.4xlarge' },
-            { name: 'ml.g5.12xlarge (4× A10G 96GB — large LLMs)', value: 'ml.g5.12xlarge' },
-            { name: 'ml.g5.48xlarge (8× A10G 192GB — very large)', value: 'ml.g5.48xlarge' },
-            { name: 'ml.g6.xlarge  (1× L4 24GB)', value: 'ml.g6.xlarge' },
-            { name: 'ml.g6.2xlarge (1× L4 24GB)', value: 'ml.g6.2xlarge' },
-            { name: 'ml.p4d.24xlarge (8× A100 320GB)', value: 'ml.p4d.24xlarge' },
-            { name: 'ml.p5.48xlarge (8× H100 640GB)', value: 'ml.p5.48xlarge' },
-            { name: 'Custom (enter manually)', value: '_custom' }
-        ];
-
-        const cpuChoices = [
-            { name: 'ml.m5.large   (2 vCPU, 8GB — lightweight)', value: 'ml.m5.large' },
-            { name: 'ml.m5.xlarge  (4 vCPU, 16GB — small models)', value: 'ml.m5.xlarge' },
-            { name: 'ml.m5.2xlarge (8 vCPU, 32GB — medium models)', value: 'ml.m5.2xlarge' },
-            { name: 'ml.m5.4xlarge (16 vCPU, 64GB — large models)', value: 'ml.m5.4xlarge' },
-            { name: 'ml.c5.xlarge  (4 vCPU, 8GB — compute-heavy)', value: 'ml.c5.xlarge' },
-            { name: 'ml.c5.2xlarge (8 vCPU, 16GB — compute-heavy)', value: 'ml.c5.2xlarge' },
-            { name: 'Custom (enter manually)', value: '_custom' }
-        ];
-
-        return {
-            type: 'list',
-            name: 'instanceType',
-            message: `Select instance type${isGpu ? ' (GPU recommended for this architecture)' : ''}:`,
-            choices: isGpu ? gpuChoices : cpuChoices
-        };
-    },
-
-    deploymentTarget: (_config) => ({
-        type: 'list',
-        name: 'deploymentTarget',
-        message: 'Select deployment target:',
-        choices: [
-            { name: 'Real-Time Inference', value: 'realtime-inference' },
-            { name: 'Async Inference', value: 'async-inference' },
-            { name: 'Batch Transform', value: 'batch-transform' },
-            { name: 'HyperPod EKS', value: 'hyperpod-eks' }
-        ]
-    }),
-
-    modelFormat: (config) => {
-        const engine = config.engine || 'sklearn';
-        const formatMap = {
-            sklearn: [
-                { name: 'pkl (pickle)', value: 'pkl' },
-                { name: 'joblib', value: 'joblib' }
-            ],
-            xgboost: [
-                { name: 'json', value: 'json' },
-                { name: 'model (binary)', value: 'model' },
-                { name: 'ubj (universal binary JSON)', value: 'ubj' }
-            ],
-            tensorflow: [
-                { name: 'keras', value: 'keras' },
-                { name: 'h5', value: 'h5' },
-                { name: 'SavedModel', value: 'SavedModel' }
-            ]
-        };
-
-        const choices = formatMap[engine] || formatMap.sklearn;
-
-        return {
-            type: 'list',
-            name: 'modelFormat',
-            message: `Select model format for ${engine}:`,
-            choices
-        };
-    },
-
-    awsRegion: (_config) => ({
-        type: 'list',
-        name: 'awsRegion',
-        message: 'Select AWS region:',
-        choices: [
-            { name: 'us-east-1 (N. Virginia)', value: 'us-east-1' },
-            { name: 'us-west-2 (Oregon)', value: 'us-west-2' },
-            { name: 'eu-west-1 (Ireland)', value: 'eu-west-1' },
-            { name: 'ap-northeast-1 (Tokyo)', value: 'ap-northeast-1' },
-            { name: 'ap-southeast-1 (Singapore)', value: 'ap-southeast-1' },
-            { name: 'Custom (enter manually)', value: '_custom' }
-        ]
-    }),
-
-    buildTarget: (_config) => ({
-        type: 'list',
-        name: 'buildTarget',
-        message: 'Select build target:',
-        choices: [
-            { name: 'CodeBuild (recommended)', value: 'codebuild' }
-        ]
-    })
-};