@simulatte/doppler 0.1.6 → 0.1.7

package/src/training/tensor-factory.d.ts

@@ -0,0 +1,9 @@
+import type { Tensor, TensorDType } from '../gpu/tensor.js';
+
+export declare function createUploadedTensor(
+  data: ArrayBufferView,
+  dtype: TensorDType,
+  shape: number[],
+  label: string,
+  usage?: number | undefined
+): Tensor;

package/src/training/tensor-factory.js

@@ -0,0 +1,13 @@
+import { acquireBuffer, releaseBuffer, uploadData } from '../memory/buffer-pool.js';
+import { createTensor } from '../gpu/tensor.js';
+
+export function createUploadedTensor(data, dtype, shape, label, usage = undefined) {
+  const buffer = acquireBuffer(data.byteLength, usage, label);
+  try {
+    uploadData(buffer, data);
+    return createTensor(buffer, dtype, [...shape], label);
+  } catch (error) {
+    releaseBuffer(buffer);
+    throw error;
+  }
+}

package/src/training/trainer.js

@@ -1,17 +1,15 @@
 import { AutogradTape } from './autograd.js';
 import { loadBackwardRegistry } from '../config/backward-registry-loader.js';
 import { runScale } from '../gpu/kernels/index.js';
-import { acquireBuffer, uploadData, releaseBuffer } from '../memory/buffer-pool.js';
-import { createTensor } from '../gpu/tensor.js';
+import { releaseBuffer } from '../memory/buffer-pool.js';
 import { createCrossEntropyObjective } from './objectives/cross_entropy.js';
+import { createUploadedTensor } from './tensor-factory.js';
 
 function createLossGradient(loss, lossScale) {
   const lossElements = loss.shape.reduce((acc, value) => acc * value, 1);
   const gradData = new Float32Array(lossElements);
   gradData.fill(lossScale);
-  const gradBuf = acquireBuffer(gradData.byteLength, undefined, 'loss_grad_output');
-  uploadData(gradBuf, gradData);
-  return createTensor(gradBuf, 'f32', [...loss.shape], 'loss_grad_output');
+  return createUploadedTensor(gradData, 'f32', loss.shape, 'loss_grad_output');
 }
 
 function normalizeLossResult(value) {

package/src/training/ul_dataset.js

@@ -1,6 +1,6 @@
-import { acquireBuffer, uploadData, readBuffer, releaseBuffer } from '../memory/buffer-pool.js';
-import { createTensor } from '../gpu/tensor.js';
+import { readBuffer, releaseBuffer } from '../memory/buffer-pool.js';
 import { resolveUlScheduledLambda } from './ul_schedule.js';
+import { createUploadedTensor } from './tensor-factory.js';
 
 function xorshift32(value) {
   let x = value >>> 0;
@@ -79,9 +79,7 @@ export async function buildNoisyLatentsFromInputTensor(inputTensor, ulConfig, op
     noisy[i] = alpha * inputData[i] + sigma * n;
   }
 
-  const noisyBuffer = acquireBuffer(noisy.byteLength, undefined, 'ul_noisy_latents');
-  uploadData(noisyBuffer, noisy);
-  const noisyTensor = createTensor(noisyBuffer, 'f32', [...inputTensor.shape], 'ul_noisy_latents');
+  const noisyTensor = createUploadedTensor(noisy, 'f32', inputTensor.shape, 'ul_noisy_latents');
   const cleanStats = summarizeArray(inputData);
   const noiseStats = summarizeArray(noise);
   const noisyStats = summarizeArray(noisy);

package/src/training/workloads.js

@@ -4,6 +4,11 @@ import { resolve } from 'node:path';
 import { isPlainObject } from '../utils/plain-object.js';
 import { sha256Hex } from '../utils/sha256.js';
 import { VALID_LORA_TARGET_MODULES } from '../config/schema/adapter.schema.js';
+import {
+  DEFAULT_TRAINING_GRADIENT_CONFIG,
+  DEFAULT_TRAINING_OPTIMIZER_CONFIG,
+  DEFAULT_TRAINING_PRECISION_CONFIG,
+} from '../config/schema/training.schema.js';
 
 export const TRAINING_WORKLOAD_SCHEMA_VERSION = 1;
 export const TRAINING_WORKLOAD_KINDS = Object.freeze(['lora', 'distill', 'ul']);
@@ -140,64 +145,57 @@ function inferLegacyKind(payload, contextLabel) {
   if (explicitKind) return explicitKind;
   const workloadKind = typeof payload?.workloadKind === 'string' ? payload.workloadKind.trim() : '';
   if (workloadKind) return workloadKind;
-  const id = String(payload?.id || '').trim();
-  if (id.startsWith('distill-')) return 'distill';
-  if (id.startsWith('lora-')) return 'lora';
-  if (id.startsWith('ul-') || id.startsWith('ul_training') || id.startsWith('ul-training')) {
+  const trainingTests = Array.isArray(payload?.trainingTests)
+    ? payload.trainingTests.map((entry) => String(entry))
+    : null;
+  const hasLegacyUlShape = trainingTests
+    && trainingTests.length > 0
+    && trainingTests.every((entry) => entry === 'ul-stage1' || entry === 'ul-stage2')
+    && Number.isInteger(Number(payload?.trainingBenchSteps));
+  if (hasLegacyUlShape) {
     return 'ul';
   }
-  if (Array.isArray(payload?.trainingTests) && payload.trainingTests.every((entry) => LEGACY_DISTILL_TEST_IDS.includes(String(entry)))) {
-    return 'distill';
-  }
   throw new Error(`${contextLabel}.kind is required.`);
 }
 
 function normalizeScheduler(value, label) {
-  const scheduler = asObject(value, label, { optional: true }) || {};
+  const scheduler = asObject(value, label);
   return {
-    enabled: scheduler.enabled === true,
-    type: asNonEmptyString(scheduler.type ?? 'constant', `${label}.type`),
-    warmupSteps: asNonNegativeInteger(
-      scheduler.warmupSteps ?? 0,
-      `${label}.warmupSteps`,
-      { optional: true }
-    ) ?? 0,
-    stepSize: asPositiveInteger(scheduler.stepSize ?? 1, `${label}.stepSize`, { optional: true }) ?? 1,
-    gamma: asFiniteNumber(scheduler.gamma ?? 1, `${label}.gamma`, { optional: true }) ?? 1,
-    totalSteps: asPositiveInteger(scheduler.totalSteps ?? 1, `${label}.totalSteps`, { optional: true }) ?? 1,
-    minLr: asFiniteNumber(scheduler.minLr ?? 0, `${label}.minLr`, { optional: true }) ?? 0,
+    enabled: asBoolean(scheduler.enabled, `${label}.enabled`),
+    type: asNonEmptyString(scheduler.type, `${label}.type`),
+    warmupSteps: asNonNegativeInteger(scheduler.warmupSteps, `${label}.warmupSteps`),
+    stepSize: asPositiveInteger(scheduler.stepSize, `${label}.stepSize`),
+    gamma: asFiniteNumber(scheduler.gamma, `${label}.gamma`),
+    totalSteps: asPositiveInteger(scheduler.totalSteps, `${label}.totalSteps`),
+    minLr: asFiniteNumber(scheduler.minLr, `${label}.minLr`),
   };
 }
 
 function normalizeTrainingConfig(value, label) {
   const training = asObject(value, label);
   const optimizer = asObject(training.optimizer, `${label}.optimizer`);
-  const precision = isPlainObject(training.precision)
-    ? training.precision
-    : { activations: training.precision ?? 'f16' };
-  const gradientClipping = isPlainObject(training.gradientClipping)
-    ? training.gradientClipping
-    : { maxNorm: training.gradientClipping ?? 1 };
+  const precision = asObject(training.precision, `${label}.precision`);
+  const gradientClipping = asObject(training.gradientClipping, `${label}.gradientClipping`);
   return {
     optimizer: {
-      type: asNonEmptyString(optimizer.type ?? 'adam', `${label}.optimizer.type`),
+      type: asNonEmptyString(optimizer.type, `${label}.optimizer.type`),
       lr: asFiniteNumber(optimizer.lr, `${label}.optimizer.lr`),
-      beta1: asFiniteNumber(optimizer.beta1 ?? 0.9, `${label}.optimizer.beta1`, { optional: true }) ?? 0.9,
-      beta2: asFiniteNumber(optimizer.beta2 ?? 0.999, `${label}.optimizer.beta2`, { optional: true }) ?? 0.999,
-      eps: asFiniteNumber(optimizer.eps ?? 1e-8, `${label}.optimizer.eps`, { optional: true }) ?? 1e-8,
-      weightDecay: asFiniteNumber(optimizer.weightDecay ?? 0, `${label}.optimizer.weightDecay`, { optional: true }) ?? 0,
+      beta1: asFiniteNumber(optimizer.beta1, `${label}.optimizer.beta1`),
+      beta2: asFiniteNumber(optimizer.beta2, `${label}.optimizer.beta2`),
+      eps: asFiniteNumber(optimizer.eps, `${label}.optimizer.eps`),
+      weightDecay: asFiniteNumber(optimizer.weightDecay, `${label}.optimizer.weightDecay`),
       scheduler: normalizeScheduler(optimizer.scheduler, `${label}.optimizer.scheduler`),
     },
     batchSize: asPositiveInteger(training.batchSize, `${label}.batchSize`),
-    accumSteps: asPositiveInteger(training.accumSteps ?? 1, `${label}.accumSteps`, { optional: true }) ?? 1,
+    accumSteps: asPositiveInteger(training.accumSteps, `${label}.accumSteps`),
     steps: asPositiveInteger(training.steps, `${label}.steps`),
     precision: {
-      activations: asNonEmptyString(precision.activations ?? 'f16', `${label}.precision.activations`),
-      gradients: asNonEmptyString(precision.gradients ?? 'f32', `${label}.precision.gradients`),
-      loraParams: asNonEmptyString(precision.loraParams ?? 'f32', `${label}.precision.loraParams`),
+      activations: asNonEmptyString(precision.activations, `${label}.precision.activations`),
+      gradients: asNonEmptyString(precision.gradients, `${label}.precision.gradients`),
+      loraParams: asNonEmptyString(precision.loraParams, `${label}.precision.loraParams`),
     },
     gradientClipping: {
-      maxNorm: asFiniteNumber(gradientClipping.maxNorm ?? 1, `${label}.gradientClipping.maxNorm`, { optional: true }) ?? 1,
+      maxNorm: asFiniteNumber(gradientClipping.maxNorm, `${label}.gradientClipping.maxNorm`),
     },
   };
 }
@@ -215,7 +213,7 @@ function normalizeEvalDatasets(value, label) {
       id: asNonEmptyString(dataset.id, `${label}[${index}].id`),
       datasetPath: asNonEmptyString(dataset.datasetPath ?? dataset.path, `${label}[${index}].datasetPath`),
       evalKind: asEnum(
-        dataset.evalKind ?? dataset.kind ?? 'text_generation',
+        dataset.evalKind ?? dataset.kind,
         `${label}[${index}].evalKind`,
         TRAINING_EVAL_KINDS
       ),
@@ -230,11 +228,7 @@ function normalizeEvalDatasets(value, label) {
             `${label}[${index}].decodePolicy.maxTokens`,
             { optional: true }
           ),
-          stopOnEos: asBoolean(
-            decodePolicy.stopOnEos ?? true,
-            `${label}[${index}].decodePolicy.stopOnEos`,
-            { optional: true }
-          ) ?? true,
+          stopOnEos: asBoolean(decodePolicy.stopOnEos, `${label}[${index}].decodePolicy.stopOnEos`),
         }
         : null,
       scoreboardColumns: asStringArray(
@@ -267,11 +261,11 @@ function normalizeStagePlan(value, label) {
   return value.map((entry, index) => {
     const stage = asObject(entry, `${label}[${index}]`);
     const selectionMetric = asNonEmptyString(
-      stage.selectionMetric ?? stage.metric ?? 'bleu',
+      stage.selectionMetric ?? stage.metric,
       `${label}[${index}].selectionMetric`
     );
     const selectionGoal = asEnum(
-      stage.selectionGoal ?? stage.goal ?? 'max',
+      stage.selectionGoal ?? stage.goal,
       `${label}[${index}].selectionGoal`,
       TRAINING_SELECTION_GOALS
     );
@@ -281,15 +275,12 @@ function normalizeStagePlan(value, label) {
       objective: asNonEmptyString(stage.objective, `${label}[${index}].objective`),
       steps: asPositiveInteger(stage.steps, `${label}[${index}].steps`),
       checkpointEvery: asPositiveInteger(
-        stage.checkpointEvery ?? stage.steps,
+        stage.checkpointEvery,
         `${label}[${index}].checkpointEvery`
       ),
       selectionMetric,
       selectionGoal,
-      evalSchedule: asNonEmptyString(
-        stage.evalSchedule ?? 'on_checkpoint',
-        `${label}[${index}].evalSchedule`
-      ),
+      evalSchedule: asNonEmptyString(stage.evalSchedule, `${label}[${index}].evalSchedule`),
     };
   });
 }
@@ -306,29 +297,29 @@ function normalizeLoraConfig(value, label) {
     }
   }
   return {
-    datasetFormat: asNonEmptyString(lora.datasetFormat ?? 'prompt_completion_jsonl', `${label}.datasetFormat`),
-    taskType: asNonEmptyString(lora.taskType ?? 'text_generation', `${label}.taskType`),
+    datasetFormat: asNonEmptyString(lora.datasetFormat, `${label}.datasetFormat`),
+    taskType: asNonEmptyString(lora.taskType, `${label}.taskType`),
     adapter: {
       rank: asPositiveInteger(adapter.rank, `${label}.adapter.rank`),
       alpha: asFiniteNumber(adapter.alpha, `${label}.adapter.alpha`),
-      dropout: asFiniteNumber(adapter.dropout ?? 0, `${label}.adapter.dropout`, { optional: true }) ?? 0,
+      dropout: asFiniteNumber(adapter.dropout, `${label}.adapter.dropout`),
       targetModules,
     },
     freeze: normalizeFreezeConfig(lora.freeze, `${label}.freeze`),
     export: exportConfig
       ? {
-        enabled: exportConfig.enabled !== false,
-        atCheckpoints: exportConfig.atCheckpoints === true,
-        select: asNonEmptyString(exportConfig.select ?? 'best', `${label}.export.select`),
+        enabled: asBoolean(exportConfig.enabled, `${label}.export.enabled`),
+        atCheckpoints: asBoolean(exportConfig.atCheckpoints, `${label}.export.atCheckpoints`),
+        select: asNonEmptyString(exportConfig.select, `${label}.export.select`),
         id: asNonEmptyString(exportConfig.id, `${label}.export.id`, { optional: true }),
         name: asNonEmptyString(exportConfig.name, `${label}.export.name`, { optional: true }),
-        format: asNonEmptyString(exportConfig.format ?? 'manifest_json', `${label}.export.format`),
+        format: asNonEmptyString(exportConfig.format, `${label}.export.format`),
       }
       : null,
     activation: activation
       ? {
-        enabled: activation.enabled === true,
-        autoActivate: activation.autoActivate === true,
+        enabled: asBoolean(activation.enabled, `${label}.activation.enabled`),
+        autoActivate: asBoolean(activation.autoActivate, `${label}.activation.autoActivate`),
         smokePrompt: asNonEmptyString(activation.smokePrompt, `${label}.activation.smokePrompt`, { optional: true }),
       }
       : null,
@@ -339,27 +330,21 @@ function normalizeDistillConfig(value, label) {
   const distill = asObject(value, label);
   return {
     stagePlan: normalizeStagePlan(distill.stagePlan, `${label}.stagePlan`),
-    studentGraphMode: asNonEmptyString(
-      distill.studentGraphMode ?? 'transformer_full',
-      `${label}.studentGraphMode`
-    ),
-    temperature: asFiniteNumber(distill.temperature ?? 1, `${label}.temperature`, { optional: true }) ?? 1,
-    alphaKd: asFiniteNumber(distill.alphaKd ?? 1, `${label}.alphaKd`, { optional: true }) ?? 1,
-    alphaCe: asFiniteNumber(distill.alphaCe ?? 0, `${label}.alphaCe`, { optional: true }) ?? 0,
-    tripletMargin: asFiniteNumber(distill.tripletMargin ?? 0.2, `${label}.tripletMargin`, { optional: true }) ?? 0.2,
+    studentGraphMode: asNonEmptyString(distill.studentGraphMode, `${label}.studentGraphMode`),
+    temperature: asFiniteNumber(distill.temperature, `${label}.temperature`),
+    alphaKd: asFiniteNumber(distill.alphaKd, `${label}.alphaKd`),
+    alphaCe: asFiniteNumber(distill.alphaCe, `${label}.alphaCe`),
+    tripletMargin: asFiniteNumber(distill.tripletMargin, `${label}.tripletMargin`),
     sourceLangs: asStringArray(distill.sourceLangs, `${label}.sourceLangs`, { optional: true, allowEmpty: true }),
     targetLangs: asStringArray(distill.targetLangs, `${label}.targetLangs`, { optional: true, allowEmpty: true }),
     pairAllowlist: asStringArray(distill.pairAllowlist, `${label}.pairAllowlist`, { optional: true, allowEmpty: true }),
-    strictPairContract: asBoolean(
-      distill.strictPairContract ?? false,
-      `${label}.strictPairContract`,
-      { optional: true }
-    ) ?? false,
+    strictPairContract: asBoolean(distill.strictPairContract, `${label}.strictPairContract`),
     subsetSpec: asObject(distill.subsetSpec, `${label}.subsetSpec`, { optional: true }),
   };
 }
 
 function normalizeLegacyUlPayload(payload, contextLabel) {
+  const optimizerOverrides = isPlainObject(payload.training?.optimizer) ? payload.training.optimizer : {};
   return {
     schemaVersion: asPositiveInteger(payload.schemaVersion, `${contextLabel}.schemaVersion`),
     kind: 'ul',
@@ -393,19 +378,25 @@ function normalizeLegacyUlPayload(payload, contextLabel) {
       TRAINING_WORKLOAD_SURFACE_SUPPORT
     ),
     training: normalizeTrainingConfig({
-      optimizer: payload.training?.optimizer ?? {
-        type: 'adam',
-        lr: 2e-4,
+      optimizer: {
+        ...DEFAULT_TRAINING_OPTIMIZER_CONFIG,
+        ...optimizerOverrides,
+        scheduler: {
+          ...DEFAULT_TRAINING_OPTIMIZER_CONFIG.scheduler,
+          ...(isPlainObject(optimizerOverrides.scheduler) ? optimizerOverrides.scheduler : {}),
+        },
       },
       batchSize: payload.training?.batchSize ?? 1,
-      accumSteps: payload.training?.accumSteps ?? 1,
+      accumSteps: payload.training?.accumSteps ?? DEFAULT_TRAINING_GRADIENT_CONFIG.accumSteps,
       steps: payload.training?.steps ?? payload.trainingBenchSteps ?? 1,
-      precision: payload.training?.precision ?? {
-        activations: 'f16',
-        gradients: 'f32',
-        loraParams: 'f32',
+      precision: {
+        ...DEFAULT_TRAINING_PRECISION_CONFIG,
+        ...(payload.training?.precision ?? {}),
+      },
+      gradientClipping: {
+        maxNorm: payload.training?.gradientClipping?.maxNorm
+          ?? DEFAULT_TRAINING_GRADIENT_CONFIG.maxNorm,
       },
-      gradientClipping: payload.training?.gradientClipping ?? { maxNorm: 1 },
     }, `${contextLabel}.training`),
     pipeline: {
       legacyWorkloadType: 'ul',

package/src/version.js

@@ -1,2 +1,2 @@
-export const DOPPLER_VERSION = '0.1.6';
+export const DOPPLER_VERSION = '0.1.7';
 export const DOPPLER_PROVIDER_VERSION = DOPPLER_VERSION;

package/tools/convert-safetensors-node.js

@@ -14,42 +14,43 @@ function parseArgs(argv) {
   const positional = [];
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
-    if (arg === '--output-dir') {
-      out.outputDir = argv[i + 1] ?? null;
+    const nextValue = () => {
+      const value = argv[i + 1];
+      if (value == null || String(value).startsWith('--')) {
+        throw new Error(`Missing value for ${arg}.`);
+      }
       i += 1;
+      return value;
+    };
+    if (arg === '--output-dir') {
+      out.outputDir = nextValue();
       continue;
     }
     if (arg === '--config') {
-      out.configPath = argv[i + 1] ?? null;
-      i += 1;
+      out.configPath = nextValue();
       continue;
     }
     if (arg === '--converter-config') {
       throw new Error('--converter-config has been removed. Use --config <path.json>.');
     }
     if (arg === '--workers') {
-      execution.workers = argv[i + 1] ?? null;
-      i += 1;
+      execution.workers = nextValue();
       continue;
     }
     if (arg === '--worker-policy') {
-      execution.workerCountPolicy = argv[i + 1] ?? null;
-      i += 1;
+      execution.workerCountPolicy = nextValue();
       continue;
     }
     if (arg === '--row-chunk-rows') {
-      execution.rowChunkRows = argv[i + 1] ?? null;
-      i += 1;
+      execution.rowChunkRows = nextValue();
       continue;
     }
     if (arg === '--row-chunk-min-tensor-bytes') {
-      execution.rowChunkMinTensorBytes = argv[i + 1] ?? null;
-      i += 1;
+      execution.rowChunkMinTensorBytes = nextValue();
       continue;
     }
     if (arg === '--max-in-flight-jobs') {
-      execution.maxInFlightJobs = argv[i + 1] ?? null;
-      i += 1;
+      execution.maxInFlightJobs = nextValue();
       continue;
     }
     if (arg === '--use-gpu-cast') {
@@ -57,12 +58,17 @@ function parseArgs(argv) {
       continue;
     }
     if (arg === '--gpu-cast-min-tensor-bytes') {
-      execution.gpuCastMinTensorBytes = argv[i + 1] ?? null;
-      i += 1;
+      execution.gpuCastMinTensorBytes = nextValue();
       continue;
     }
+    if (arg.startsWith('--')) {
+      throw new Error(`Unknown flag: ${arg}`);
+    }
     positional.push(arg);
   }
+  if (positional.length > 1) {
+    throw new Error(`Unexpected positional arguments: ${positional.slice(1).join(', ')}`);
+  }
   out.inputDir = positional[0] ?? null;
   out.execution = Object.keys(execution).length > 0 ? execution : null;
   return out;

package/tools/doppler-cli.js

@@ -22,8 +22,6 @@ const DEFAULT_CLI_POLICY = {
       allowed: ['auto', 'node', 'browser'],
     },
     bench: {
-      modelId: 'gemma-3-270m-it-wf16-ef16-hf16',
-      surface: 'browser',
       cacheMode: 'warm',
     },
     cacheMode: null,
@@ -82,7 +80,7 @@ function usage() {
     '    - run: CLI-only run controls (surface, browser options, and bench save/compare/manifest settings).',
     '',
     'Example:',
-    '  doppler verify --config \'{"request":{"suite":"inference","modelId":"gemma-3-270m-it-wf16-ef16-hf16"}}\' --json',
+    '  doppler verify --config \'{"request":{"suite":"inference","modelId":"gemma-3-270m-it-f16-af32"}}\' --json',
   ].join('\n');
 }
 
@@ -439,10 +437,6 @@ export async function resolveBrowserModelUrl(request, browserOptions = {}) {
   const staticRootDir = resolveStaticRootDir(browserOptions);
   const externalModel = await resolveExternalModelDirectory(resolveRdrrRoot(browserOptions), modelId);
   const candidates = [
-    {
-    modelUrl: `/models/curated/${encodedModelId}`,
-    manifestPath: path.join(staticRootDir, 'models', 'curated', modelId, 'manifest.json'),
-    },
     {
     modelUrl: `/models/local/${encodedModelId}`,
     manifestPath: path.join(staticRootDir, 'models', 'local', modelId, 'manifest.json'),
@@ -528,6 +522,9 @@ function parseSurface(value, command, policy = DEFAULT_CLI_POLICY) {
   if (command === 'convert' && normalized === 'browser') {
     throw new Error('convert is not supported on browser relay. Use --surface node or --surface auto.');
   }
+  if ((command === 'lora' || command === 'distill') && normalized === 'browser') {
+    throw new Error(`${command} is not supported on browser relay. Use --surface node or --surface auto.`);
+  }
   return normalized;
 }
 
@@ -587,13 +584,10 @@ function resolveBenchRunOptions(runConfig, policy = DEFAULT_CLI_POLICY) {
 function resolveSurfaceForCommand(command, parsed, runConfig, policy = DEFAULT_CLI_POLICY) {
   const fromCli = asStringOrNull(parsed.flags.surface);
   const fromRun = asStringOrNull(runConfig?.surface);
-  const fromPolicy = command === 'bench'
-    ? asStringOrNull(policy?.defaults?.bench?.surface)
-    : null;
-  return parseSurface(fromCli ?? fromRun ?? fromPolicy, command, policy);
+  return parseSurface(fromCli ?? fromRun ?? null, command, policy);
 }
 
-async function buildRequest(parsed, policy = DEFAULT_CLI_POLICY) {
+export async function buildRequest(parsed, policy = DEFAULT_CLI_POLICY) {
   const command = parsed.command;
   if (!command || !TOOLING_COMMANDS.includes(command)) {
     throw new Error(`Unsupported command "${command || ''}"`);
@@ -612,21 +606,15 @@ async function buildRequest(parsed, policy = DEFAULT_CLI_POLICY) {
   }
   requestInput.command = command;
 
-  if (command === 'bench' && !asStringOrNull(requestInput.modelId) && !asStringOrNull(requestInput.modelUrl)) {
-    const benchDefaultModelId = asStringOrNull(policy?.defaults?.bench?.modelId);
-    if (benchDefaultModelId) {
-      requestInput.modelId = benchDefaultModelId;
-    }
-  }
-
   applyRuntimeFlagOverride(requestInput, runtimeOverride);
 
   const surfaceFromCli = asStringOrNull(parsed.flags.surface) !== null;
+  const surface = resolveSurfaceForCommand(command, parsed, envelope.run, policy);
 
   return {
     request: normalizeToolingCommandRequest(requestInput),
     runConfig: envelope.run,
-    surface: resolveSurfaceForCommand(command, parsed, envelope.run, policy),
+    surface,
     surfaceFromCli,
     benchRunOptions: resolveBenchRunOptions(envelope.run, policy),
   };
@@ -723,6 +711,32 @@ function isTrainingCommandFlow(request) {
   return request.command === 'bench' && request.workloadType === 'training';
 }
 
+function resolveErrorSurface(error, fallbackSurface = null) {
+  return (
+    asStringOrNull(fallbackSurface)
+    || asStringOrNull(error?.surface)
+    || asStringOrNull(error?.details?.surface)
+    || null
+  );
+}
+
+export function createCliToolingErrorEnvelope(error, context = {}) {
+  return createToolingErrorEnvelope(error, {
+    surface: resolveErrorSurface(error, context.surface),
+    request: context.request ?? null,
+  });
+}
+
+export function finalizeCliCommandResponse(response, request) {
+  if (!isPlainObject(response) || !Object.prototype.hasOwnProperty.call(response, 'request')) {
+    return response;
+  }
+  return {
+    ...response,
+    request,
+  };
+}
+
 async function runCommandOnSurface(request, surface, runConfig, jsonOutput) {
   if (surface === 'node') {
     const nodeRequest = await resolveNodeModelUrl(request);
@@ -732,7 +746,8 @@ async function runCommandOnSurface(request, surface, runConfig, jsonOutput) {
         console.error(`[surface] node resolved modelUrl=${nodeRequest.modelUrl}`);
       }
     }
-    return runNodeCommand(nodeRequest, buildNodeRunOptions(jsonOutput));
+    const response = await runNodeCommand(nodeRequest, buildNodeRunOptions(jsonOutput));
+    return finalizeCliCommandResponse(response, request);
   }
 
   const browserOptions = buildBrowserRunOptions(runConfig, jsonOutput, request);
@@ -746,7 +761,8 @@ async function runCommandOnSurface(request, surface, runConfig, jsonOutput) {
     }
   }
 
-  return runBrowserCommandInNode(browserRequest, browserOptions);
+  const response = await runBrowserCommandInNode(browserRequest, browserOptions);
+  return finalizeCliCommandResponse(response, request);
 }
 
 async function runWithAutoSurface(request, runConfig, jsonOutput, policy = DEFAULT_CLI_POLICY) {
@@ -763,9 +779,12 @@ async function runWithAutoSurface(request, runConfig, jsonOutput, policy = DEFAU
     }
     if (isTrainingCommandFlow(request)) {
       const downgradeError = new Error(
-        'Training command auto-surface downgrade is blocked. Re-run with --surface node after fixing Node WebGPU support, or explicitly choose --surface browser.'
+        (request.command === 'lora' || request.command === 'distill')
+          ? 'Training command auto-surface downgrade is blocked. Re-run with --surface node after fixing Node WebGPU support.'
+          : 'Training command auto-surface downgrade is blocked. Re-run with --surface node after fixing Node WebGPU support, or explicitly choose --surface browser.'
       );
       downgradeError.code = 'training_surface_downgrade_blocked';
+      downgradeError.surface = 'node';
       downgradeError.command = request.command;
       downgradeError.suite = request.suite;
       downgradeError.workloadType = request.workloadType || null;
@@ -1021,7 +1040,7 @@ async function runManifestSweep(manifest, commandContext, jsonOutput, policy = D
       results.push({
         label,
         response: null,
-        error: createToolingErrorEnvelope(error, {
+        error: createCliToolingErrorEnvelope(error, {
           surface: surface === 'auto' ? null : surface,
           request,
         }),
@@ -1404,7 +1423,7 @@ async function main() {
     printMetricsSummary(response.result);
   } catch (error) {
     if (jsonOutputRequested) {
-      console.log(JSON.stringify(createToolingErrorEnvelope(error, errorContext), null, 2));
+      console.log(JSON.stringify(createCliToolingErrorEnvelope(error, errorContext), null, 2));
       process.exitCode = 1;
       return;
     }