@simulatte/doppler 0.1.6 → 0.1.7

package/src/inference/pipelines/text/attention/projections.js

@@ -1,4 +1,4 @@
-import { acquireBuffer } from '../../../../memory/buffer-pool.js';
+import { releaseBuffer } from '../../../../memory/buffer-pool.js';
 import { isWeightBuffer, getLayout, getWeightDtype } from '../../../../gpu/weight-buffer.js';
 import {
   runMatmul,
@@ -36,7 +36,7 @@ function getRmsNormRunner(recorder) {
 }
 
 function releaseOwnedWeightBuffer(layerWeight, resolvedWeightBuffer, releaseTemporary) {
-  if (layerWeight instanceof GPUBuffer || isWeightBuffer(layerWeight)) {
+  if ((typeof GPUBuffer !== 'undefined' && layerWeight instanceof GPUBuffer) || isWeightBuffer(layerWeight)) {
     return;
   }
   if (!resolvedWeightBuffer) {
@@ -66,10 +66,16 @@ async function projectSingleQkvTensor({
 }) {
   const runMatmulForMode = getMatmulRunner(recorder);
   const layerWeight = layerWeights?.[weightKey];
-  let projected;
+  if (!layerWeight) {
+    throw new Error(`Attention projection requires ${weightKey}.`);
+  }
+  if (!getWeightBuffer) {
+    throw new Error(`Attention projection requires getWeightBuffer for ${role}.`);
+  }
 
-  if (layerWeight && getWeightBuffer) {
-    const projBuffer = getWeightBuffer(layerWeight, role);
+  let projected;
+  const projBuffer = getWeightBuffer(layerWeight, role);
+  try {
     projected = await runMatmulForMode(normed, projBuffer, numTokens, outputSize, hiddenSize, {
       transposeB: 'auto',
       role,
@@ -77,26 +83,31 @@ async function projectSingleQkvTensor({
       kernelPath,
       outputDtype: matmulOutputDtype,
     });
+  } finally {
     releaseOwnedWeightBuffer(layerWeight, projBuffer, releaseTemporary);
-  } else {
-    const fallback = acquireBuffer(numTokens * outputSize * 4, undefined, outputLabel);
-    projected = createTensor(fallback, normed.dtype, [numTokens, outputSize], outputLabel);
   }
 
   const loraModule = getLoRAModule(lora, layerIdx, loraKey);
   if (loraModule && getWeightBuffer) {
-    const combined = await applyLoRA(
-      normed,
-      projected,
-      loraModule,
-      { M: numTokens, N: outputSize, K: hiddenSize },
-      getWeightBuffer,
-      recorder ?? undefined,
-      { kernelPath }
-    );
-    if (combined.buffer !== projected.buffer) {
-      releaseTemporary(projected.buffer);
-      projected = combined;
+    try {
+      const combined = await applyLoRA(
+        normed,
+        projected,
+        loraModule,
+        { M: numTokens, N: outputSize, K: hiddenSize },
+        getWeightBuffer,
+        recorder ?? undefined,
+        { kernelPath }
+      );
+      if (combined.buffer !== projected.buffer) {
+        releaseTemporary(projected.buffer);
+        projected = combined;
+      }
+    } catch (error) {
+      if (projected?.buffer) {
+        releaseTemporary(projected.buffer);
+      }
+      throw error;
     }
   }
 
@@ -212,24 +223,42 @@ async function projectQueryWithOptionalGate({
       bOffset: gateOffset,
       outputDtype: matmulOutputDtype,
     });
+  } catch (error) {
+    if (qTensor) {
+      releaseTemporary(qTensor.buffer);
+    }
+    if (qGateTensor) {
+      releaseTemporary(qGateTensor.buffer);
+    }
+    throw error;
   } finally {
     releaseOwnedWeightBuffer(qWeight, qWeightBuffer, releaseTemporary);
   }
 
   const loraModule = getLoRAModule(lora, layerIdx, 'q_proj');
   if (loraModule && getWeightBuffer) {
-    const combined = await applyLoRA(
-      normed,
-      qTensor,
-      loraModule,
-      { M: numTokens, N: qSize, K: hiddenSize },
-      getWeightBuffer,
-      recorder ?? undefined,
-      { kernelPath }
-    );
-    if (combined.buffer !== qTensor.buffer) {
-      releaseTemporary(qTensor.buffer);
-      qTensor = combined;
+    try {
+      const combined = await applyLoRA(
+        normed,
+        qTensor,
+        loraModule,
+        { M: numTokens, N: qSize, K: hiddenSize },
+        getWeightBuffer,
+        recorder ?? undefined,
+        { kernelPath }
+      );
+      if (combined.buffer !== qTensor.buffer) {
+        releaseTemporary(qTensor.buffer);
+        qTensor = combined;
+      }
+    } catch (error) {
+      if (qTensor?.buffer) {
+        releaseTemporary(qTensor.buffer);
+      }
+      if (qGateTensor?.buffer) {
+        releaseTemporary(qGateTensor.buffer);
+      }
+      throw error;
     }
   }
 
@@ -289,82 +318,103 @@ export async function projectAttentionQKV({
   if (useFusedQKV && layerWeights.qkvProj && layerWeights.qkvSizes) {
     const [qSizeFused, kSizeFused, vSizeFused] = layerWeights.qkvSizes;
     const qkvSizeTotal = qSizeFused + kSizeFused + vSizeFused;
-    const qkvTensor = await runMatmulForMode(normed, layerWeights.qkvProj, numTokens, qkvSizeTotal, hiddenSize, {
-      transposeB: 'auto',
-      role: 'qkv_proj',
+    let qkvTensor = null;
+    try {
+      qkvTensor = await runMatmulForMode(normed, layerWeights.qkvProj, numTokens, qkvSizeTotal, hiddenSize, {
+        transposeB: 'auto',
+        role: 'qkv_proj',
+        layerIdx,
+        kernelPath,
+        outputDtype: matmulOutputDtype,
+      });
+      const split = await runSplitForMode(qkvTensor, {
+        numTokens,
+        qSize: qSizeFused,
+        kSize: kSizeFused,
+        vSize: vSizeFused,
+      });
+      releaseTemporary(qkvTensor.buffer);
+      if (onFusedQKV) {
+        onFusedQKV({ qSize: qSizeFused, kSize: kSizeFused, vSize: vSizeFused, totalSize: qkvSizeTotal });
+      }
+      return { qTensor: split.Q, qGateTensor: null, kTensor: split.K, vTensor: split.V, usedFusedQKV: true };
+    } catch (error) {
+      if (qkvTensor) {
+        releaseTemporary(qkvTensor.buffer);
+      }
+      throw error;
+    }
+  }
+
+  let qTensor = null;
+  let qGateTensor = null;
+  let kTensor = null;
+  let vTensor = null;
+  try {
+    ({ qTensor, qGateTensor } = await projectQueryWithOptionalGate({
+      recorder,
+      normed,
+      layerWeights,
+      numTokens,
+      numHeads,
+      headDim,
+      hiddenSize,
       layerIdx,
       kernelPath,
-      outputDtype: matmulOutputDtype,
+      matmulOutputDtype,
+      getWeightBuffer,
+      lora,
+      releaseTemporary,
+      attentionOutputGate,
+    }));
+
+    kTensor = await projectSingleQkvTensor({
+      recorder,
+      normed,
+      layerWeights,
+      weightKey: 'kProj',
+      role: 'k_proj',
+      outputSize: numKVHeads * headDim,
+      outputLabel: 'K',
+      loraKey: 'k_proj',
+      numTokens,
+      hiddenSize,
+      layerIdx,
+      kernelPath,
+      matmulOutputDtype,
+      getWeightBuffer,
+      lora,
+      releaseTemporary,
     });
-    const split = await runSplitForMode(qkvTensor, {
+
+    vTensor = await projectSingleQkvTensor({
+      recorder,
+      normed,
+      layerWeights,
+      weightKey: 'vProj',
+      role: 'v_proj',
+      outputSize: numKVHeads * headDim,
+      outputLabel: 'V',
+      loraKey: 'v_proj',
       numTokens,
-      qSize: qSizeFused,
-      kSize: kSizeFused,
-      vSize: vSizeFused,
+      hiddenSize,
+      layerIdx,
+      kernelPath,
+      matmulOutputDtype,
+      getWeightBuffer,
+      lora,
+      releaseTemporary,
     });
-    releaseTemporary(qkvTensor.buffer);
-    if (onFusedQKV) {
-      onFusedQKV({ qSize: qSizeFused, kSize: kSizeFused, vSize: vSizeFused, totalSize: qkvSizeTotal });
+
+    return { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV: false };
+  } catch (error) {
+    for (const tensor of [qTensor, qGateTensor, kTensor, vTensor]) {
+      if (tensor?.buffer) {
+        releaseTemporary(tensor.buffer);
+      }
     }
-    return { qTensor: split.Q, qGateTensor: null, kTensor: split.K, vTensor: split.V, usedFusedQKV: true };
+    throw error;
   }
-
-  const { qTensor, qGateTensor } = await projectQueryWithOptionalGate({
-    recorder,
-    normed,
-    layerWeights,
-    numTokens,
-    numHeads,
-    headDim,
-    hiddenSize,
-    layerIdx,
-    kernelPath,
-    matmulOutputDtype,
-    getWeightBuffer,
-    lora,
-    releaseTemporary,
-    attentionOutputGate,
-  });
-
-  const kTensor = await projectSingleQkvTensor({
-    recorder,
-    normed,
-    layerWeights,
-    weightKey: 'kProj',
-    role: 'k_proj',
-    outputSize: numKVHeads * headDim,
-    outputLabel: 'K',
-    loraKey: 'k_proj',
-    numTokens,
-    hiddenSize,
-    layerIdx,
-    kernelPath,
-    matmulOutputDtype,
-    getWeightBuffer,
-    lora,
-    releaseTemporary,
-  });
-
-  const vTensor = await projectSingleQkvTensor({
-    recorder,
-    normed,
-    layerWeights,
-    weightKey: 'vProj',
-    role: 'v_proj',
-    outputSize: numKVHeads * headDim,
-    outputLabel: 'V',
-    loraKey: 'v_proj',
-    numTokens,
-    hiddenSize,
-    layerIdx,
-    kernelPath,
-    matmulOutputDtype,
-    getWeightBuffer,
-    lora,
-    releaseTemporary,
-  });
-
-  return { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV: false };
 }
 
 export async function applyAttentionQKNorm({

package/src/inference/pipelines/text/attention/record.js

@@ -90,9 +90,20 @@ export async function recordLayerAttentionGPU(
   const allowF16Attention = wantsF16Output && kvCacheDtype === 'f16';
   let attentionInput = input;
   let attentionInputTemp = false;
+  let normed = attentionInput;
+  let qTensor = null;
+  let qGateTensor = null;
+  let kTensor = null;
+  let vTensor = null;
+  let attnOutput = null;
+  let attnForProjection = null;
+  let output = null;
+  let finalOutput = null;
+  let oProjInputTemp = null;
   if (wantsF16Output && !allowF16Attention) {
     attentionInput = await recordCastF16ToF32(recorder, input);
     attentionInputTemp = true;
+    normed = attentionInput;
   }
 
   if (!layerWeights) {
@@ -108,7 +119,7 @@ export async function recordLayerAttentionGPU(
 
   // 1. Input norm
 
-  let normed = attentionInput;
+  try {
   if (!skipInputNorm && layerWeights.inputNorm && getNormWeightBuffer) {
     const normWeightBuf = getNormWeightBuffer(layerWeights.inputNorm, 'input_norm');
     normed = await recordRMSNorm(recorder, attentionInput, normWeightBuf, rmsNormEps, {
@@ -132,7 +143,8 @@ export async function recordLayerAttentionGPU(
 
   // 2. Q/K/V projections
   const matmulOutputDtype = resolveAttentionProjectionOutputDtype(desiredOutputDtype);
-  let { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
+  let usedFusedQKV = false;
+  ({ qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
     recorder,
     normed,
     layerWeights,
@@ -153,7 +165,7 @@ export async function recordLayerAttentionGPU(
         trace.attn(layerIdx, `Using fused QKV path: ${qSizeFused}+${kSizeFused}+${vSizeFused}=${totalSize}`);
       }
       : null,
-  });
+  }));
 
   // Optional per-head Q/K normalization.
   // Some models use RMSNorm with (1+weight) offset formula, controlled by rmsNormWeightOffset.
@@ -502,9 +514,9 @@ export async function recordLayerAttentionGPU(
     throw new Error(`Unsupported attention kernel variant "${attentionKernelVariant}" at layer ${layerIdx}`);
   }
 
-  const attnOutput = await runAttentionKernel();
+  attnOutput = await runAttentionKernel();
 
-  let attnForProjection = attnOutput;
+  attnForProjection = attnOutput;
   if (qGateTensor) {
     attnForProjection = await recordSiLU(recorder, attnOutput, {
       size: numTokens * numHeads * headDim,
@@ -518,10 +530,10 @@ export async function recordLayerAttentionGPU(
 
   // 6. Output projection (with optional fused residual for decode)
 
-  let output;
+  output = null;
   let residualFused = false;
   let oProjInput = attnForProjection;
-  let oProjInputTemp = null;
+  oProjInputTemp = null;
   if (layerWeights.oProj && getWeightBuffer) {
     const oProjBuf = getWeightBuffer(layerWeights.oProj, 'o_proj');
     const loraO = getLoRAModule(lora, layerIdx, 'o_proj');
@@ -589,7 +601,7 @@ export async function recordLayerAttentionGPU(
     }
   }
 
-  let finalOutput = output;
+  finalOutput = output;
 
   const buffersToTrack = [];
   if (output.buffer !== attnForProjection.buffer) {
@@ -619,4 +631,46 @@ export async function recordLayerAttentionGPU(
   }
 
   return { output: finalOutput, residualFused };
+  } catch (error) {
+    const tracked = new Set();
+    const trackOnce = (buffer) => {
+      if (!buffer || tracked.has(buffer)) return;
+      tracked.add(buffer);
+      recorder.trackTemporaryBuffer(buffer);
+    };
+    if (finalOutput?.buffer && finalOutput.buffer !== output?.buffer) {
+      trackOnce(finalOutput.buffer);
+    }
+    if (output?.buffer && output.buffer !== attnForProjection?.buffer) {
+      trackOnce(output.buffer);
+    }
+    if (oProjInputTemp?.buffer) {
+      trackOnce(oProjInputTemp.buffer);
+    }
+    if (attnForProjection?.buffer && attnForProjection.buffer !== attnOutput?.buffer) {
+      trackOnce(attnForProjection.buffer);
+    }
+    if (attnOutput?.buffer) {
+      trackOnce(attnOutput.buffer);
+    }
+    if (qGateTensor?.buffer) {
+      trackOnce(qGateTensor.buffer);
+    }
+    if (qTensor?.buffer) {
+      trackOnce(qTensor.buffer);
+    }
+    if (kTensor?.buffer) {
+      trackOnce(kTensor.buffer);
+    }
+    if (vTensor?.buffer) {
+      trackOnce(vTensor.buffer);
+    }
+    if (normed?.buffer && normed.buffer !== attentionInput?.buffer) {
+      trackOnce(normed.buffer);
+    }
+    if (attentionInputTemp && attentionInput?.buffer) {
+      trackOnce(attentionInput.buffer);
+    }
+    throw error;
+  }
 }

package/src/inference/pipelines/text/attention/run.js

@@ -97,9 +97,20 @@ export async function runLayerAttentionGPU(
   const allowF16Attention = wantsF16Output && kvCacheDtype === 'f16';
   let attentionInput = input;
   let attentionInputTemp = false;
+  let normed = attentionInput;
+  let qTensor = null;
+  let qGateTensor = null;
+  let kTensor = null;
+  let vTensor = null;
+  let attnOutput = null;
+  let attnForProjection = null;
+  let output = null;
+  let finalOutput = null;
+  let oProjInputTemp = null;
   if (wantsF16Output && !allowF16Attention) {
     attentionInput = await castF16ToF32(input);
     attentionInputTemp = true;
+    normed = attentionInput;
   }
 
   // Debug: attention input for configured layers
@@ -123,7 +134,7 @@ export async function runLayerAttentionGPU(
 
   // 1. Input norm
   
-  let normed = attentionInput;
+  try {
   if (!skipInputNorm && layerWeights.inputNorm && getNormWeightBuffer) {
     const normWeightBuf = getNormWeightBuffer(layerWeights.inputNorm, 'input_norm');
 
@@ -183,7 +194,8 @@ export async function runLayerAttentionGPU(
 
   // 2. Q/K/V projections
   const matmulOutputDtype = resolveAttentionProjectionOutputDtype(desiredOutputDtype);
-  let { qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
+  let usedFusedQKV = false;
+  ({ qTensor, qGateTensor, kTensor, vTensor, usedFusedQKV } = await projectAttentionQKV({
     recorder: null,
     normed,
     layerWeights,
@@ -204,7 +216,7 @@ export async function runLayerAttentionGPU(
         trace.attn(layerIdx, `Using fused QKV path: ${qSizeFused}+${kSizeFused}+${vSizeFused}=${totalSize}`);
       }
       : null,
-  });
+  }));
 
   // Trace Q/K/V projections
   if (kernelTrace.enabled) {
@@ -669,7 +681,7 @@ export async function runLayerAttentionGPU(
     throw new Error(`Unsupported attention kernel variant "${attentionKernelVariant}" at layer ${layerIdx}`);
   }
 
-  const attnOutput = await runAttentionKernel();
+  attnOutput = await runAttentionKernel();
 
   // Trace attention output
   if (kernelTrace.enabled) {
@@ -692,7 +704,7 @@ export async function runLayerAttentionGPU(
     await debugCheckBuffer(attnOutput.buffer, `L${layerIdx} attention output (before o_proj, GPU)`, numTokens, numHeads * headDim);
   }
 
-  let attnForProjection = attnOutput;
+  attnForProjection = attnOutput;
   if (qGateTensor) {
     attnForProjection = await runSiLU(attnOutput, {
       size: numTokens * numHeads * headDim,
@@ -706,10 +718,10 @@ export async function runLayerAttentionGPU(
 
   // 6. Output projection (with optional fused residual for decode)
   
-  let output;
+  output = null;
   let residualFused = false;
   let oProjInput = attnForProjection;
-  let oProjInputTemp = null;
+  oProjInputTemp = null;
   if (layerWeights.oProj && getWeightBuffer) {
     const oProjBuf = getWeightBuffer(layerWeights.oProj, 'o_proj');
     const loraO = getLoRAModule(lora, layerIdx, 'o_proj');
@@ -807,7 +819,7 @@ export async function runLayerAttentionGPU(
     await debugCheckBuffer(output.buffer, `L${layerIdx} attention output (after o_proj, GPU)`, numTokens, hiddenSize);
   }
 
-  let finalOutput = output;
+  finalOutput = output;
   
   const buffersToRelease = [];
   if (output.buffer !== attnForProjection.buffer) {
@@ -832,4 +844,46 @@ export async function runLayerAttentionGPU(
   }
 
   return { output: finalOutput, residualFused };
+  } catch (error) {
+    const released = new Set();
+    const releaseOnce = (buffer) => {
+      if (!buffer || released.has(buffer)) return;
+      released.add(buffer);
+      releaseBuffer(buffer);
+    };
+    if (finalOutput?.buffer && finalOutput.buffer !== output?.buffer) {
+      releaseOnce(finalOutput.buffer);
+    }
+    if (output?.buffer && output.buffer !== attnForProjection?.buffer) {
+      releaseOnce(output.buffer);
+    }
+    if (oProjInputTemp?.buffer) {
+      releaseOnce(oProjInputTemp.buffer);
+    }
+    if (attnForProjection?.buffer && attnForProjection.buffer !== attnOutput?.buffer) {
+      releaseOnce(attnForProjection.buffer);
+    }
+    if (attnOutput?.buffer) {
+      releaseOnce(attnOutput.buffer);
+    }
+    if (qGateTensor?.buffer) {
+      releaseOnce(qGateTensor.buffer);
+    }
+    if (qTensor?.buffer) {
+      releaseOnce(qTensor.buffer);
+    }
+    if (kTensor?.buffer) {
+      releaseOnce(kTensor.buffer);
+    }
+    if (vTensor?.buffer) {
+      releaseOnce(vTensor.buffer);
+    }
+    if (normed?.buffer && normed.buffer !== attentionInput?.buffer) {
+      releaseOnce(normed.buffer);
+    }
+    if (attentionInputTemp && attentionInput?.buffer) {
+      releaseOnce(attentionInput.buffer);
+    }
+    throw error;
+  }
 }

package/src/inference/pipelines/text/config.js

@@ -134,11 +134,10 @@ function resolveIntermediateSizeForRuntime(manifest, inf, arch, modelId) {
   if (inferred == null || inferred === fromArch) {
     return fromArch;
   }
-  log.warn(
-    'Config',
-    `Manifest "${modelId}" has intermediateSize=${fromArch}, inferred ${inferred} from FFN tensor shapes; using inferred value.`
+  throw new Error(
+    `Manifest "${modelId}" has intermediateSize=${fromArch}, but FFN tensors imply ${inferred}. ` +
+    'Re-convert the model so manifest architecture matches the weights.'
   );
-  return inferred;
 }
 
 // =============================================================================

package/src/inference/pipelines/text/embed.js

@@ -319,14 +319,8 @@ export async function embed(tokenIds, embedBuffer, config) {
     const firstTokenId = tokenIdArray[0];
     const bytesPerElement = useF16 ? 2 : 4;
     const sampleSize = Math.min(32 * bytesPerElement, hiddenSize * bytesPerElement);
-    const staging = device.createBuffer({ size: sampleSize, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ });
-    const enc = device.createCommandEncoder();
-    enc.copyBufferToBuffer(gatherOutput.buffer, 0, staging, 0, sampleSize);
-    device.queue.submit([enc.finish()]);
-    await staging.mapAsync(GPUMapMode.READ);
-    const data = decodeReadback(staging.getMappedRange().slice(0), gatherOptions.outputDtype);
-    staging.unmap();
-    staging.destroy();
+    const readback = await readBuffer(gatherOutput.buffer, sampleSize);
+    const data = decodeReadback(readback, gatherOptions.outputDtype);
 
     // Compute statistics
     let sum = 0, sumSq = 0;

package/src/inference/pipelines/text/execution-plan.js

@@ -1,4 +1,3 @@
-import { log } from '../../../debug/index.js';
 import { resolveKernelPath } from '../../../config/kernel-path-loader.js';
 import { selectRuleValue } from '../../../rules/rule-registry.js';
 import {
@@ -9,19 +8,36 @@ import {
 export const PRIMARY_EXECUTION_PLAN_ID = 'primary';
 export const FINITENESS_FALLBACK_EXECUTION_PLAN_ID = 'finiteness_fallback';
 
-function normalizePositiveInt(value, fallback, label) {
-  if (!Number.isFinite(value)) return fallback;
-  const normalized = Math.floor(value);
-  if (normalized >= 1) return normalized;
-  log.warn('Pipeline', `[ExecutionPlan] ${label}=${value} is invalid; using ${fallback}.`);
-  return fallback;
+function assertOptionalBoolean(value, label) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== 'boolean') {
+    throw new Error(`[ExecutionPlan] ${label} must be boolean when provided; got ${JSON.stringify(value)}.`);
+  }
+  return value;
 }
 
-function normalizeStopCheckMode(value, fallback) {
-  if (value === 'batch' || value === 'per-token') {
-    return value;
+function assertOptionalPositiveInt(value, label) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`[ExecutionPlan] ${label} must be a positive integer when provided; got ${JSON.stringify(value)}.`);
+  }
+  return value;
+}
+
+function assertOptionalStopCheckMode(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (value !== 'batch' && value !== 'per-token') {
+    throw new Error(
+      `[ExecutionPlan] stopCheckMode must be "batch" or "per-token" when provided; got ${JSON.stringify(value)}.`
+    );
   }
-  return fallback;
+  return value;
 }
 
 function resolveFallbackActivationDtype(primaryActivationDtype) {
@@ -244,11 +260,17 @@ export function activateFallbackExecutionPlan(container) {
 
 function resolveExecutionOverrides(options = {}) {
   return {
-    disableCommandBatching: options.disableCommandBatching,
-    disableMultiTokenDecode: options.disableMultiTokenDecode,
-    batchSize: options.batchSize,
-    stopCheckMode: options.stopCheckMode,
-    maxTokens: options.maxTokens,
+    disableCommandBatching: assertOptionalBoolean(
+      options.disableCommandBatching,
+      'disableCommandBatching'
+    ),
+    disableMultiTokenDecode: assertOptionalBoolean(
+      options.disableMultiTokenDecode,
+      'disableMultiTokenDecode'
+    ),
+    batchSize: assertOptionalPositiveInt(options.batchSize, 'batchSize'),
+    stopCheckMode: assertOptionalStopCheckMode(options.stopCheckMode),
+    maxTokens: assertOptionalPositiveInt(options.maxTokens, 'maxTokens'),
   };
 }
 
@@ -268,9 +290,9 @@ export function resolveExecutionSessionPlan(container, options = {}) {
     deferredRoundingWindowTokens: activePlan.deferredRoundingWindowTokens,
     disableCommandBatching: overrides.disableCommandBatching ?? activePlan.defaultDisableCommandBatching,
     disableMultiTokenDecode: overrides.disableMultiTokenDecode ?? activePlan.defaultDisableMultiTokenDecode,
-    batchSize: normalizePositiveInt(overrides.batchSize, activePlan.defaultBatchSize, 'batchSize'),
-    stopCheckMode: normalizeStopCheckMode(overrides.stopCheckMode, activePlan.defaultStopCheckMode),
-    maxTokens: normalizePositiveInt(overrides.maxTokens, activePlan.defaultMaxTokens, 'maxTokens'),
+    batchSize: overrides.batchSize ?? activePlan.defaultBatchSize,
+    stopCheckMode: overrides.stopCheckMode ?? activePlan.defaultStopCheckMode,
+    maxTokens: overrides.maxTokens ?? activePlan.defaultMaxTokens,
     readbackInterval: activePlan.readbackInterval,
     ringTokens: activePlan.ringTokens,
     ringStop: activePlan.ringStop,