@aws/ml-container-creator 0.3.0 → 0.5.0

package/src/lib/prompts.js

@@ -47,6 +47,69 @@ function loadInstanceTypeRegistry() {
 
 const instanceTypeRegistry = loadInstanceTypeRegistry();
 
+/**
+ * Load the raw instance catalog for GPU/CUDA generation lookups.
+ * Returns the full catalog entries keyed by instance type.
+ */
+function loadInstanceCatalogRaw() {
+    try {
+        const raw = readFileSync(instancesCatalogPath, 'utf8');
+        const catalog = JSON.parse(raw);
+        return catalog?.catalog || {};
+    } catch (error) {
+        return {};
+    }
+}
+
+const instanceCatalogRaw = loadInstanceCatalogRaw();
+
+/**
+ * Get the CUDA generation key for an instance type.
+ * Uses gpuArchitecture as the generation grouping (e.g., "Turing", "Ampere", "Hopper").
+ * Instances in the same generation share AMI compatibility.
+ * @param {string} instanceType - e.g., "ml.g5.xlarge"
+ * @returns {string|null} Generation key or null if not found/not GPU
+ */
+function getInstanceCudaGeneration(instanceType) {
+    const entry = instanceCatalogRaw[instanceType];
+    if (!entry) return null;
+    if (entry.acceleratorType !== 'cuda') return null;
+    return entry.gpuArchitecture || null;
+}
+
+/**
+ * Filter instance choices to only include instances from the same CUDA generation
+ * as the first (highest-priority) instance in the list.
+ * @param {string[]} instanceTypes - Array of instance type strings
+ * @returns {{ filtered: string[], generation: string|null, removed: string[] }}
+ */
+function filterByCudaGeneration(instanceTypes) {
+    if (!instanceTypes || instanceTypes.length === 0) {
+        return { filtered: [], generation: null, removed: [] };
+    }
+
+    // Find the generation of the first instance
+    const firstGen = getInstanceCudaGeneration(instanceTypes[0]);
+    if (!firstGen) {
+        // First instance not in catalog or not CUDA — return all (can't filter)
+        return { filtered: instanceTypes, generation: null, removed: [] };
+    }
+
+    const filtered = [];
+    const removed = [];
+    for (const it of instanceTypes) {
+        const gen = getInstanceCudaGeneration(it);
+        // Keep if same generation, or if not in catalog (don't block unknown types)
+        if (gen === firstGen || gen === null) {
+            filtered.push(it);
+        } else {
+            removed.push(it);
+        }
+    }
+
+    return { filtered, generation: firstGen, removed };
+}
+
 /**
  * Generate pseudo-randomized project name based on framework
  * @param {string} framework - The ML framework
@@ -583,7 +646,7 @@ const modulePrompts = [
         type: 'confirm',
         name: 'includeSampleModel',
         message: 'Include sample Abalone classifier?',
-        default: false,
+        default: true,
         when: (answers) => {
             const architecture = answers.architecture || answers.deploymentConfig?.split('-')[0];
             const backend = answers.backend || answers.deploymentConfig?.split('-').slice(1).join('-');
@@ -622,7 +685,10 @@ const modulePrompts = [
             
             // Transformers and Triton LLM backends only support hosted endpoint tests
             if (architecture === 'transformers') {
-                return ['hosted-model-endpoint'];
+                return ['hosted-model-endpoint', 'sagemaker-ai-automated-benchmarking'];
+            }
+            if (architecture === 'diffusors') {
+                return ['hosted-model-endpoint', 'sagemaker-ai-automated-benchmarking'];
             }
             if (architecture === 'triton' && (backend === 'vllm' || backend === 'tensorrtllm')) {
                 return ['hosted-model-endpoint'];
@@ -635,7 +701,10 @@ const modulePrompts = [
             const backend = answers.backend || answers.deploymentConfig?.split('-').slice(1).join('-');
             
             if (architecture === 'transformers') {
-                return ['hosted-model-endpoint'];
+                return ['hosted-model-endpoint', 'sagemaker-ai-automated-benchmarking'];
+            }
+            if (architecture === 'diffusors') {
+                return ['hosted-model-endpoint', 'sagemaker-ai-automated-benchmarking'];
             }
             if (architecture === 'triton' && (backend === 'vllm' || backend === 'tensorrtllm')) {
                 return ['hosted-model-endpoint'];
@@ -692,15 +761,137 @@ const infraRegionAndTargetPrompts = [
     }
 ];
 
+// Sub-phase A2: Existing endpoint prompt (only when deploymentTarget === 'realtime-inference')
+const infraExistingEndpointPrompts = [
+    {
+        type: 'list',
+        name: 'useExistingEndpoint',
+        message: 'Deploy to an existing endpoint? (attach IC to running endpoint)',
+        choices: [
+            { name: 'No — create a new endpoint', value: 'no' },
+            { name: 'Yes — attach to an existing endpoint', value: 'yes' }
+        ],
+        default: 'no',
+        when: answers => answers.deploymentTarget === 'realtime-inference'
+    },
+    {
+        type: 'list',
+        name: 'existingEndpointName',
+        message: 'Select endpoint:',
+        choices: (answers) => {
+            const mcpChoices = answers._mcpEndpointChoices || [];
+            if (mcpChoices.length > 0) {
+                return [...mcpChoices, { name: 'Custom (enter manually)', value: 'custom' }];
+            }
+            return [{ name: 'Enter endpoint name manually', value: 'custom' }];
+        },
+        when: answers => answers.useExistingEndpoint === 'yes'
+    },
+    {
+        type: 'input',
+        name: 'customExistingEndpointName',
+        message: 'Enter existing endpoint name:',
+        validate: (input) => {
+            if (!input || input.trim() === '') {
+                return 'Endpoint name is required';
+            }
+            return true;
+        },
+        when: answers => answers.useExistingEndpoint === 'yes' && answers.existingEndpointName === 'custom'
+    }
+];
+
 // Sub-phase B: Instance type (only when deploymentTarget === 'realtime-inference')
 const infraInstancePrompts = [
+    // Multi-select prompt: shown when MCP sizer has choices AND deployment target is realtime-inference
+    // User can select 1-5 instances; selection count determines single-type vs instance-pools behavior
+    // Requirements: 6.4
+    {
+        type: 'checkbox',
+        name: 'instanceTypeSelections',
+        when: answers => answers.deploymentTarget === 'realtime-inference' &&
+            answers._mcpInstanceChoices && answers._mcpInstanceChoices.length > 1,
+        message: 'Select instance type(s) — select multiple for instance pools (priority = selection order, max 5):',
+        choices: (answers) => {
+            const mcpChoices = answers._mcpInstanceChoices || [];
+            // Show all compatible instances — CUDA generation filtering happens
+            // after selection to allow users to see all options and make informed choices.
+            // If they select instances from different generations, the post-selection
+            // filter (filterByCudaGeneration in prompt-runner.js) will warn and remove incompatible ones.
+            const choices = mcpChoices.map(instanceType => {
+                const entry = instanceCatalogRaw[instanceType];
+                const gpuInfo = entry ? `${entry.gpus} GPU${entry.gpus > 1 ? 's' : ''}, ${entry.gpuMemoryGb || '?'}GB` : '';
+                return {
+                    name: gpuInfo ? `${instanceType} (${gpuInfo})` : instanceType,
+                    value: instanceType,
+                    short: instanceType
+                };
+            });
+            // Always include a "Custom Input" option at the end
+            choices.push({
+                name: 'Custom Input (enter one or comma-separated list)',
+                value: '__custom_input__',
+                short: 'Custom'
+            });
+            return choices;
+        },
+        validate: (input) => {
+            if (!input || input.length === 0) {
+                return 'Select at least one instance type';
+            }
+            if (input.length > 5) {
+                return 'Maximum 5 instance types allowed (API limit). Please deselect some.';
+            }
+            return true;
+        }
+    },
+    // Custom input prompt for multi-select: shown when user selects "Custom Input" in instanceTypeSelections
+    {
+        type: 'input',
+        name: 'customInstanceTypeSelections',
+        message: 'Enter instance type(s) — single for homogeneous, comma-separated for heterogeneous (e.g., ml.g5.xlarge or ml.g5.xlarge,ml.g5.2xlarge):',
+        when: answers => Array.isArray(answers.instanceTypeSelections) &&
+            answers.instanceTypeSelections.includes('__custom_input__'),
+        validate: (input) => {
+            if (!input || input.trim() === '') {
+                return 'At least one instance type is required';
+            }
+            const instancePattern = /^ml\.[a-z0-9]+\.(nano|micro|small|medium|large|xlarge|[0-9]+xlarge)$/;
+            const instances = input.split(',').map(s => s.trim()).filter(s => s.length > 0);
+            if (instances.length === 0) {
+                return 'At least one instance type is required';
+            }
+            if (instances.length > 5) {
+                return 'Maximum 5 instance types allowed (API limit).';
+            }
+            for (const inst of instances) {
+                if (!instancePattern.test(inst)) {
+                    return `Invalid instance type format: "${inst}". Expected format: ml.{family}.{size} (e.g., ml.g5.xlarge)`;
+                }
+            }
+            return true;
+        }
+    },
+    // Single-select prompt: shown when no MCP choices, or for non-realtime targets, or only 1 MCP choice
     {
         type: 'list',
         name: 'instanceType',
-        when: answers => answers.deploymentTarget === 'realtime-inference' || answers.deploymentTarget === 'async-inference' || answers.deploymentTarget === 'batch-transform' || answers.deploymentTarget === 'hyperpod-eks',
+        when: answers => {
+            // Skip if multi-select was shown (realtime with multiple MCP choices)
+            if (answers.deploymentTarget === 'realtime-inference' &&
+                answers._mcpInstanceChoices && answers._mcpInstanceChoices.length > 1) {
+                return false;
+            }
+            return answers.deploymentTarget === 'realtime-inference' || answers.deploymentTarget === 'async-inference' || answers.deploymentTarget === 'batch-transform' || answers.deploymentTarget === 'hyperpod-eks';
+        },
         message: (answers) => {
             const framework = answers.framework || answers.deploymentConfig?.split('-')[0];
-            
+
+            // Skip table when MCP sizer already displayed annotated results
+            if (answers._mcpInstanceChoices && answers._mcpInstanceChoices.length > 0) {
+                return 'Select instance type:';
+            }
+
             const table = new Table({
                 head: [
                     chalk.cyan('Instance Type'),
@@ -1110,6 +1301,91 @@ const baseImagePrompts = [
     }
 ];
 
+/**
+ * LoRA adapter prompts for multi-adapter serving configuration.
+ * Only shown when architecture is transformers AND model server is vllm, sglang, or djl-lmi.
+ * Requirements: 1.1, 1.2, 1.4
+ */
+const loraPrompts = [
+    {
+        type: 'confirm',
+        name: 'enableLora',
+        message: 'Enable LoRA adapter serving?',
+        default: false,
+        when: (answers) => {
+            const architecture = answers.architecture || answers.deploymentConfig?.split('-')[0];
+            const backend = answers.backend || answers.deploymentConfig?.split('-').slice(1).join('-');
+            if (architecture !== 'transformers') return false;
+            const loraCapableServers = ['vllm', 'sglang', 'djl-lmi', 'lmi', 'djl'];
+            return loraCapableServers.includes(backend);
+        }
+    },
+    {
+        type: 'number',
+        name: 'maxLoras',
+        message: 'Maximum concurrent LoRA adapters in GPU memory:',
+        default: 30,
+        when: (answers) => answers.enableLora === true
+    },
+    {
+        type: 'number',
+        name: 'maxLoraRank',
+        message: 'Maximum LoRA rank:',
+        default: 64,
+        when: (answers) => answers.enableLora === true
+    }
+];
+
+/**
+ * Benchmark prompts for SageMaker AI Benchmarking (NVIDIA AIPerf)
+ * Sub-prompts shown when 'sagemaker-ai-automated-benchmarking' is selected in testTypes.
+ * Requirements: 2.1, 2.2, 2.3, 2.4, 2.5
+ */
+const benchmarkPrompts = [
+    {
+        type: 'number',
+        name: 'benchmarkConcurrency',
+        message: 'Concurrent requests for benchmark:',
+        default: 10,
+        when: (answers) => answers.includeBenchmark === true
+    },
+    {
+        type: 'number',
+        name: 'benchmarkInputTokensMean',
+        message: 'Mean input tokens per request:',
+        default: 550,
+        when: (answers) => answers.includeBenchmark === true
+    },
+    {
+        type: 'number',
+        name: 'benchmarkOutputTokensMean',
+        message: 'Mean output tokens per request:',
+        default: 150,
+        when: (answers) => answers.includeBenchmark === true
+    },
+    {
+        type: 'confirm',
+        name: 'benchmarkStreaming',
+        message: 'Enable streaming for benchmark?',
+        default: true,
+        when: (answers) => answers.includeBenchmark === true
+    },
+    {
+        type: 'input',
+        name: 'benchmarkRequestCount',
+        message: 'Total request count (leave empty for service default):',
+        default: '',
+        when: (answers) => answers.includeBenchmark === true
+    },
+    {
+        type: 'input',
+        name: 'benchmarkS3OutputPath',
+        message: 'Benchmark results S3 path (leave empty for auto-created bucket):',
+        default: '',
+        when: (answers) => answers.includeBenchmark === true
+    }
+];
+
 export {
     deploymentConfigPrompts,
     frameworkPrompts, // Deprecated: kept for backward compatibility
@@ -1123,8 +1399,11 @@ export {
     hfTokenPrompts,
     ngcApiKeyPrompts,
     modulePrompts,
+    loraPrompts,
+    benchmarkPrompts,
     infrastructurePrompts,
     infraRegionAndTargetPrompts,
+    infraExistingEndpointPrompts,
     infraInstancePrompts,
     infraAsyncPrompts,
     infraBatchTransformPrompts,
@@ -1134,5 +1413,8 @@ export {
     destinationPrompts,
     baseImageSearchPrompts,
     baseImagePrompts,
-    formatImageChoices
+    formatImageChoices,
+    filterByCudaGeneration,
+    getInstanceCudaGeneration,
+    instanceCatalogRaw
 };

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

@@ -150,6 +150,18 @@ export default class RegistryCommandHandler {
             }
         }
 
+        // Parse icList from JSON string if provided
+        const icListRaw = options.icList || options['ic-list'];
+        if (icListRaw) {
+            try {
+                entry.deployment.icList = typeof icListRaw === 'string'
+                    ? JSON.parse(icListRaw)
+                    : icListRaw;
+            } catch (err) {
+                console.log(`Warning: Could not parse ic-list JSON: ${err.message}`);
+            }
+        }
+
         try {
             const id = registry.add(entry);
             console.log('✅ Deployment entry logged successfully.');

package/src/lib/schema-sync.js

@@ -188,6 +188,37 @@ export function loadServiceModel(serviceName, registryPath) {
     return readFileSync(modelPath, 'utf8');
 }
 
+/**
+ * Check whether the SageMaker service model includes the CreateAIBenchmarkJob operation shape.
+ * Used to determine if benchmark parameter validation can be performed.
+ *
+ * @param {string} [registryPath] - Override registry path
+ * @returns {{ available: boolean, reason?: string }}
+ */
+export function hasBenchmarkShape(registryPath) {
+    const regPath = registryPath || getRegistryPath();
+    const modelContent = loadServiceModel('sagemaker', regPath);
+
+    if (!modelContent) {
+        return { available: false, reason: 'SageMaker service model not found in registry' };
+    }
+
+    try {
+        const model = JSON.parse(modelContent);
+        const operations = model.operations || {};
+        const shapes = model.shapes || {};
+
+        // Check for the CreateAIBenchmarkJob operation or its input shape
+        if (operations.CreateAIBenchmarkJob || shapes.CreateAIBenchmarkJobRequest) {
+            return { available: true };
+        }
+
+        return { available: false, reason: 'service model does not include AI Benchmark operations' };
+    } catch {
+        return { available: false, reason: 'Failed to parse SageMaker service model' };
+    }
+}
+
 /**
  * Store a service model in the registry.
  * @param {string} serviceName - Service name (e.g., 'sagemaker')

package/src/lib/template-manager.js

@@ -65,7 +65,7 @@ export default class TemplateManager {
             ],
             buildTargets: ['codebuild'],
             deploymentTargets: ['realtime-inference', 'async-inference', 'batch-transform', 'hyperpod-eks'],
-            testTypes: ['local-model-cli', 'local-model-server', 'hosted-model-endpoint'],
+            testTypes: ['local-model-cli', 'local-model-server', 'hosted-model-endpoint', 'sagemaker-ai-automated-benchmarking'],
             awsRegions: [
                 'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2',
                 'eu-west-1', 'eu-west-2', 'eu-central-1', 'eu-north-1',
@@ -134,6 +134,9 @@ export default class TemplateManager {
 
         // Validate batch transform specific fields
         this._validateBatchTransformConfig();
+
+        // Validate benchmark specific fields
+        this._validateBenchmarkConfig();
         
         // Validate instance type format (ml.*.*) - only for realtime-inference
         if (this.answers.instanceType && this.answers.instanceType !== 'custom') {
@@ -297,6 +300,51 @@ export default class TemplateManager {
         }
     }
 
+    /**
+     * Validates benchmark configuration parameters
+     * @private
+     * @throws {Error} If benchmark configuration is invalid
+     */
+    _validateBenchmarkConfig() {
+        if (!this.answers.includeBenchmark) return;
+
+        // Gate to supported architectures
+        const dc = this.answers.deploymentConfig;
+        const arch = dc ? dc.split('-')[0] : this.answers.architecture;
+        if (arch !== 'transformers' && arch !== 'diffusors') {
+            throw new Error('⚠️  Benchmarking is only supported with transformers and diffusors architectures.');
+        }
+
+        // Gate to supported deployment targets
+        if (this.answers.deploymentTarget === 'hyperpod-eks') {
+            throw new Error('⚠️  Benchmarking is only supported with managed-inference, async-inference, and batch-transform deployment targets');
+        }
+
+        // Validate numeric parameters
+        if (this.answers.benchmarkConcurrency !== undefined) {
+            if (!Number.isInteger(this.answers.benchmarkConcurrency) || this.answers.benchmarkConcurrency < 1) {
+                throw new Error('⚠️  benchmarkConcurrency must be an integer >= 1');
+            }
+        }
+        if (this.answers.benchmarkInputTokensMean !== undefined) {
+            if (!Number.isInteger(this.answers.benchmarkInputTokensMean) || this.answers.benchmarkInputTokensMean < 1) {
+                throw new Error('⚠️  benchmarkInputTokensMean must be an integer >= 1');
+            }
+        }
+        if (this.answers.benchmarkOutputTokensMean !== undefined) {
+            if (!Number.isInteger(this.answers.benchmarkOutputTokensMean) || this.answers.benchmarkOutputTokensMean < 1) {
+                throw new Error('⚠️  benchmarkOutputTokensMean must be an integer >= 1');
+            }
+        }
+
+        // Validate S3 path format
+        if (this.answers.benchmarkS3OutputPath && this.answers.benchmarkS3OutputPath.trim() !== '') {
+            if (!this.answers.benchmarkS3OutputPath.startsWith('s3://')) {
+                throw new Error('⚠️  benchmarkS3OutputPath must start with "s3://". Example: s3://my-bucket/benchmark-results/');
+            }
+        }
+    }
+
     /**
      * Validates GPU instance type requirement for GPU-requiring backends.
      * Called when deploymentConfig is present.

package/src/lib/validate-runner.js

@@ -21,7 +21,7 @@ import SchemaValidationEngine from './schema-validation-engine.js';
 import ServiceModelParser from './service-model-parser.js';
 import CrossCuttingChecker from './cross-cutting-checker.js';
 import HuggingFaceClient from './huggingface-client.js';
-import { getRegistryPath, loadManifest } from './schema-sync.js';
+import { getRegistryPath, loadManifest, hasBenchmarkShape } from './schema-sync.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -52,6 +52,115 @@ export function parseDoConfig(configPath) {
     return config;
 }
 
+/**
+ * Validate benchmark parameters against service model constraints.
+ * Called when the CreateAIBenchmarkJob shape is available in the synced schema.
+ *
+ * Validates:
+ * - Concurrency: integer, min 1
+ * - S3OutputLocation: string, starts with s3://
+ * - AIBenchmarkJobName: pattern ^[a-zA-Z0-9](-*[a-zA-Z0-9])*, max 63 chars
+ *
+ * Requirements: 8.1, 8.2, 8.3
+ *
+ * @param {Object} config - Parsed do/config values
+ * @returns {Array<Object>} Array of validation findings
+ */
+export function validateBenchmarkParams(config) {
+    const findings = [];
+
+    // Validate Concurrency (integer, min 1)
+    if (config.BENCHMARK_CONCURRENCY !== null && config.BENCHMARK_CONCURRENCY !== undefined && config.BENCHMARK_CONCURRENCY !== '') {
+        const concurrency = Number(config.BENCHMARK_CONCURRENCY);
+        if (!Number.isInteger(concurrency) || concurrency < 1) {
+            findings.push({
+                severity: 'error',
+                operation: 'CreateAIBenchmarkJob',
+                fieldPath: 'Concurrency',
+                constraint: 'integer >= 1',
+                invalidValue: config.BENCHMARK_CONCURRENCY,
+                remediationHint: 'BENCHMARK_CONCURRENCY must be a positive integer (>= 1)'
+            });
+        }
+    }
+
+    // Validate S3OutputLocation (string, starts with s3://)
+    if (config.BENCHMARK_S3_OUTPUT_PATH !== null && config.BENCHMARK_S3_OUTPUT_PATH !== undefined && config.BENCHMARK_S3_OUTPUT_PATH !== '') {
+        const s3Path = config.BENCHMARK_S3_OUTPUT_PATH;
+        // Skip dynamic shell expressions (e.g., s3://...$(aws ...))
+        if (!s3Path.includes('$(') && !s3Path.startsWith('s3://')) {
+            findings.push({
+                severity: 'error',
+                operation: 'CreateAIBenchmarkJob',
+                fieldPath: 'OutputConfig.S3OutputLocation',
+                constraint: 'must start with s3://',
+                invalidValue: s3Path,
+                remediationHint: 'BENCHMARK_S3_OUTPUT_PATH must start with "s3://". Example: s3://my-bucket/benchmark-results/'
+            });
+        }
+    }
+
+    // Validate AIBenchmarkJobName pattern (^[a-zA-Z0-9](-*[a-zA-Z0-9])*, max 63 chars)
+    if (config.BENCHMARK_JOB_NAME !== null && config.BENCHMARK_JOB_NAME !== undefined && config.BENCHMARK_JOB_NAME !== '') {
+        const jobName = config.BENCHMARK_JOB_NAME;
+        // Skip dynamic shell expressions
+        if (!jobName.includes('$(') && !jobName.includes('${')) {
+            const namePattern = /^[a-zA-Z0-9](-*[a-zA-Z0-9])*$/;
+            if (jobName.length > 63) {
+                findings.push({
+                    severity: 'error',
+                    operation: 'CreateAIBenchmarkJob',
+                    fieldPath: 'AIBenchmarkJobName',
+                    constraint: 'max 63 characters',
+                    invalidValue: jobName,
+                    remediationHint: 'AIBenchmarkJobName must be at most 63 characters'
+                });
+            } else if (!namePattern.test(jobName)) {
+                findings.push({
+                    severity: 'error',
+                    operation: 'CreateAIBenchmarkJob',
+                    fieldPath: 'AIBenchmarkJobName',
+                    constraint: 'pattern: ^[a-zA-Z0-9](-*[a-zA-Z0-9])*',
+                    invalidValue: jobName,
+                    remediationHint: 'AIBenchmarkJobName must start with alphanumeric and contain only alphanumeric characters and hyphens'
+                });
+            }
+        }
+    }
+
+    // Validate input tokens mean (integer, min 1)
+    if (config.BENCHMARK_INPUT_TOKENS_MEAN !== null && config.BENCHMARK_INPUT_TOKENS_MEAN !== undefined && config.BENCHMARK_INPUT_TOKENS_MEAN !== '') {
+        const inputTokens = Number(config.BENCHMARK_INPUT_TOKENS_MEAN);
+        if (!Number.isInteger(inputTokens) || inputTokens < 1) {
+            findings.push({
+                severity: 'error',
+                operation: 'CreateAIWorkloadConfig',
+                fieldPath: 'WorkloadSpec.parameters.prompt_input_tokens_mean',
+                constraint: 'integer >= 1',
+                invalidValue: config.BENCHMARK_INPUT_TOKENS_MEAN,
+                remediationHint: 'BENCHMARK_INPUT_TOKENS_MEAN must be a positive integer (>= 1)'
+            });
+        }
+    }
+
+    // Validate output tokens mean (integer, min 1)
+    if (config.BENCHMARK_OUTPUT_TOKENS_MEAN !== null && config.BENCHMARK_OUTPUT_TOKENS_MEAN !== undefined && config.BENCHMARK_OUTPUT_TOKENS_MEAN !== '') {
+        const outputTokens = Number(config.BENCHMARK_OUTPUT_TOKENS_MEAN);
+        if (!Number.isInteger(outputTokens) || outputTokens < 1) {
+            findings.push({
+                severity: 'error',
+                operation: 'CreateAIWorkloadConfig',
+                fieldPath: 'WorkloadSpec.parameters.output_tokens_mean',
+                constraint: 'integer >= 1',
+                invalidValue: config.BENCHMARK_OUTPUT_TOKENS_MEAN,
+                remediationHint: 'BENCHMARK_OUTPUT_TOKENS_MEAN must be a positive integer (>= 1)'
+            });
+        }
+    }
+
+    return findings;
+}
+
 /**
  * Run the full validation pipeline.
  *
@@ -171,6 +280,20 @@ export async function run(options = {}) {
         }
     }
 
+    // Run benchmark parameter validation (Requirements 8.1, 8.2, 8.3)
+    if (config.BENCHMARK_CONCURRENCY || config.BENCHMARK_INPUT_TOKENS_MEAN ||
+        config.BENCHMARK_OUTPUT_TOKENS_MEAN || config.BENCHMARK_S3_OUTPUT_PATH) {
+        const benchmarkCheck = hasBenchmarkShape(registryPath);
+        if (benchmarkCheck.available) {
+            const benchmarkFindings = validateBenchmarkParams(config);
+            for (const finding of benchmarkFindings) {
+                report.addFinding(finding);
+            }
+        } else {
+            console.log('⚠️  Benchmark validation skipped: service model does not include AI Benchmark operations. Run `bootstrap sync-schemas` to update.');
+        }
+    }
+
     const summary = report.getSummary();
 
     // Load manifest for version info
@@ -213,4 +336,4 @@ export async function run(options = {}) {
     return exitCode;
 }
 
-export default { run, parseDoConfig };
+export default { run, parseDoConfig, validateBenchmarkParams };