create-quiver 0.15.0 → 0.15.1

package/src/create-quiver/index.js

@@ -22,6 +22,7 @@ const {
   runLifecycleResume: runAiLifecycleResume,
   runLifecycleRun: runAiLifecycleRun,
   runLifecycleStatus: runAiLifecycleStatus,
+  runModelsList: runAiModelsList,
   runOnboard,
   runPlan: runAiPlan,
   runPrepareContext: runAiPrepareContext,
@@ -172,7 +173,8 @@ const COMMAND_HELP_GROUPS = [
       ['ai resume', 'Resume guidance from the last valid lifecycle phase without chat memory.'],
       ['ai onboard', 'Run or print the planner onboarding prompt with a token-aware context pack.'],
       ['ai prepare-context', 'Preview or write docs-only AI context updates with assumptions and risks.'],
-      ['ai agent set|list|show', 'Manage planner, executor, reviewer, and doctor provider profiles without secrets; use set --dry-run to preview.'],
+      ['ai agent set|list|show|doctor|repair', 'Manage, diagnose, and dry-run repair planner, executor, reviewer, and doctor provider profiles without secrets.'],
+      ['ai models list', 'List provider/model ids known by Quiver without claiming account availability.'],
       ['ai plan', 'Generate versioned planner drafts for acceptance criteria, technical plan, or spec phase.'],
       ['ai revise', 'Create a new planner draft from human feedback without approving it.'],
       ['ai repair-plan', 'Repair an approved technical plan into a new structured draft without mutating the approved artifact.'],
@@ -261,7 +263,8 @@ function printUsage() {
   npx create-quiver ai specs list [--json]
   npx create-quiver ai slices list [--json]
   npx create-quiver ai trace report [options]
-  npx create-quiver ai agent <set|list|show> [role] [options]
+  npx create-quiver ai agent <set|list|show|doctor|repair> [role] [options]
+  npx create-quiver ai models list [--provider codex|claude|gemini] [--json]
   npx create-quiver ai prepare-context [options]
   npx create-quiver ai revise [options]
   npx create-quiver ai repair-plan [options]
@@ -321,7 +324,7 @@ Options:
       --allow-dirty           For ai execute-slice, allow pre-existing dirty files and ignore them for scope diff
       --mode <name>           Execution mode for ai execute-plan (auto, manual, delegated)
       --provider <name>       Provider CLI to preflight for prepare or AI commands
-      --model <label>         Free-form model label for AI agent profiles
+      --model <model-id>      Technical model id for AI agent profiles or provider-backed AI commands
       --version <n>           Draft version to approve for AI planner phases
       --run <id>              AI lifecycle run id
       --ssh-host-alias <name> SSH host alias to validate for prepare or AI commands
@@ -359,7 +362,10 @@ Examples:
   cd ./my-project && npx create-quiver ai trace report
   cd ./my-project && npx create-quiver ai agent set planner --provider codex --model gpt-5.5 --dry-run
   cd ./my-project && npx create-quiver ai agent set planner --provider codex --model gpt-5.5
+  cd ./my-project && npx create-quiver ai agent doctor
+  cd ./my-project && npx create-quiver ai agent repair --dry-run
   cd ./my-project && npx create-quiver ai agent list
+  cd ./my-project && npx create-quiver ai models list --provider codex
   cd ./my-project && npx create-quiver ai plan --phase acceptance --input requirements.md --dry-run
   cd ./my-project && npx create-quiver ai revise --phase acceptance --input feedback.md --dry-run
   cd ./my-project && npx create-quiver ai approve --phase acceptance --version 1
@@ -1050,10 +1056,10 @@ function parseArgs(argv) {
     if (result.aiCommand === 'run' && !result.aiRunCommand && positional.length > 0) {
       result.aiRunCommand = positional.shift();
     }
-    if ((result.aiCommand === 'specs' || result.aiCommand === 'slices' || result.aiCommand === 'trace' || result.aiCommand === 'active-slice') && !result.aiSecondaryCommand && positional.length > 0) {
+    if ((result.aiCommand === 'specs' || result.aiCommand === 'slices' || result.aiCommand === 'models' || result.aiCommand === 'trace' || result.aiCommand === 'active-slice') && !result.aiSecondaryCommand && positional.length > 0) {
       result.aiSecondaryCommand = positional.shift();
     }
-    if ((result.aiCommand === 'specs' || result.aiCommand === 'slices') && result.aiSecondaryCommand && result.aiSecondaryCommand !== 'list') {
+    if ((result.aiCommand === 'specs' || result.aiCommand === 'slices' || result.aiCommand === 'models') && result.aiSecondaryCommand && result.aiSecondaryCommand !== 'list') {
       throw new Error(formatError(`unsupported ai ${result.aiCommand} subcommand: ${result.aiSecondaryCommand}. Supported tasks: list`));
     }
     if (result.aiCommand === 'trace' && result.aiSecondaryCommand && result.aiSecondaryCommand !== 'report') {
@@ -2704,8 +2710,8 @@ async function resolveInteractiveInitOptions(args, targetDir, projectName, optio
 
   if (agentGuidance.value === 'show') {
     ux.nextSteps([
-      'npx create-quiver ai agent set planner --provider codex --model "<modelo-planner>" --dry-run',
-      'npx create-quiver ai agent set executor --provider claude --model "<modelo-executor>" --dry-run',
+      'npx create-quiver ai agent set planner --provider codex --model gpt-5.5 --dry-run',
+      'npx create-quiver ai agent set executor --provider claude --model claude-sonnet-4-6 --dry-run',
     ], { title: 'Despues de inicializar' });
   }
 
@@ -2836,7 +2842,7 @@ async function run(argv) {
 
   if (args.mode === 'ai') {
     if (!args.aiCommand) {
-      throw new Error(formatError('missing ai subcommand. Use: npx create-quiver ai onboard | prepare-context | run | active-slice | status | resume | inspect | export | specs | slices | trace | plan | revise | repair-plan | review-plan | approve | approvals | agent | prompt-slice | execute-slice | execute-plan | doctor | pr'));
+      throw new Error(formatError('missing ai subcommand. Use: npx create-quiver ai onboard | prepare-context | run | active-slice | status | resume | inspect | export | specs | slices | models | trace | plan | revise | repair-plan | review-plan | approve | approvals | agent | prompt-slice | execute-slice | execute-plan | doctor | pr'));
     }
 
     if (args.aiCommand === 'run') {
@@ -2909,13 +2915,23 @@ async function run(argv) {
       return;
     }
 
+    if (args.aiCommand === 'models') {
+      runAiModelsList({
+        json: args.json,
+        provider: args.aiProviderExplicit ? args.aiProvider : undefined,
+      });
+      return;
+    }
+
     if (args.aiCommand === 'agent') {
-      runAiAgent(process.cwd(), {
+      await runAiAgent(process.cwd(), {
         command: args.aiAgentCommand,
         context: args.aiContext || undefined,
         defaultProfile: args.aiDefaultProfile,
         displayName: args.aiDisplayName || undefined,
         id: args.aiProfileId || undefined,
+        interactive: args.interactive,
+        json: args.json,
         label: args.aiLabel || undefined,
         model: args.aiModel || undefined,
         provider: args.aiProviderExplicit ? args.aiProvider : undefined,
@@ -3120,7 +3136,7 @@ async function run(argv) {
       return;
     }
 
-    throw new Error(formatError(`unsupported ai subcommand: ${args.aiCommand}. Supported tasks: onboard, prepare-context, run, active-slice, status, resume, inspect, export, specs, slices, trace, plan, revise, repair-plan, review-plan, approve, approvals, agent, prompt-slice, execute-slice, execute-plan, doctor, pr`));
+    throw new Error(formatError(`unsupported ai subcommand: ${args.aiCommand}. Supported tasks: onboard, prepare-context, run, active-slice, status, resume, inspect, export, specs, slices, models, trace, plan, revise, repair-plan, review-plan, approve, approvals, agent, prompt-slice, execute-slice, execute-plan, doctor, pr`));
   }
 
   if (args.mode === 'graph') {

package/src/create-quiver/lib/agent-profiles.js

@@ -2,6 +2,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { assertSupportedProvider, formatProviderList } = require('./ai/providers');
+const { normalizeModelSelection } = require('./ai/model-catalog');
+const { preflightProvider } = require('./ai/preflight');
 const { quiverInternalPaths } = require('./init-layout');
 
 const AGENT_PROFILE_ROLES = Object.freeze(['planner', 'executor', 'reviewer', 'doctor']);
@@ -87,6 +89,11 @@ function normalizeStoredProfile(profile, role, fallbackId = 'default') {
     label: normalizeOptionalText(profile?.label, 'label'),
     displayName: normalizeOptionalText(profile?.displayName || profile?.display_name, 'displayName'),
     context: normalizeOptionalText(profile?.context, 'context'),
+    modelSource: normalizeOptionalText(profile?.modelSource || profile?.model_source, 'modelSource'),
+    modelAlias: normalizeOptionalText(profile?.modelAlias || profile?.model_alias, 'modelAlias'),
+    validation_status: normalizeOptionalText(profile?.validation_status || profile?.validationStatus, 'validation_status'),
+    validated_at: normalizeOptionalText(profile?.validated_at || profile?.validatedAt, 'validated_at'),
+    validation_error: normalizeOptionalText(profile?.validation_error || profile?.validationError, 'validation_error'),
     default: profile?.default === true,
     updated_at: profile?.updated_at || '',
   };
@@ -181,25 +188,44 @@ function setAgentProfile(projectRoot, role, options = {}) {
 function buildAgentProfileState(projectRoot, role, options = {}) {
   const normalizedRole = normalizeAgentProfileRole(role);
   const provider = assertSupportedProvider(options.provider);
-  const model = normalizeOptionalText(options.model, 'model');
+  const rawModel = normalizeOptionalText(options.model, 'model');
   const label = normalizeOptionalText(options.label, 'label');
-  const displayName = normalizeOptionalText(options.displayName || options.display_name, 'displayName');
+  const rawDisplayName = normalizeOptionalText(options.displayName || options.display_name, 'displayName');
   const context = normalizeOptionalText(options.context, 'context');
   const state = readAgentProfiles(projectRoot);
   const currentProfiles = getAgentProfilesForRole(projectRoot, normalizedRole);
   const currentDefault = currentProfiles.find((profile) => profile.default) || currentProfiles[0] || {};
-  const id = normalizeProfileId(options.id || currentDefault.id || label || model || provider);
+  const modelSelection = rawModel
+    ? normalizeModelSelection(provider, rawModel, { displayName: rawDisplayName })
+    : null;
+  const id = normalizeProfileId(options.id || currentDefault.id || label || modelSelection?.model || rawModel || provider);
   const current = currentProfiles.find((profile) => profile.id === id) || {};
+  const model = modelSelection?.model || current.model || '';
+  const displayName = rawDisplayName
+    || modelSelection?.displayName
+    || current.displayName
+    || model
+    || label
+    || provider;
   const now = options.now instanceof Date ? options.now.toISOString() : new Date().toISOString();
   const shouldBeDefault = options.default === true || currentProfiles.length === 0 || (options.default !== false && current.default === true);
+  const modelSource = modelSelection?.modelSource || current.modelSource || (model ? 'custom' : '');
+  const modelAlias = modelSelection && modelSelection.input && modelSelection.input !== model
+    ? modelSelection.input
+    : (current.modelAlias || '');
   const profile = {
     id,
     role: normalizedRole,
     provider,
     model: model || current.model || '',
     label: label || current.label || '',
-    displayName: displayName || current.displayName || model || label || provider,
+    displayName,
     context: context || current.context || '',
+    modelSource,
+    modelAlias,
+    validation_status: current.validation_status || (model ? 'not-tested' : ''),
+    validated_at: current.validated_at || '',
+    validation_error: current.validation_error || '',
     default: shouldBeDefault,
     updated_at: now,
   };
@@ -243,10 +269,312 @@ function resolveProfileProvider(projectRoot, role, fallbackProvider) {
   return assertSupportedProvider(fallbackProvider);
 }
 
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function rawText(value) {
+  return String(value || '').trim();
+}
+
+function rawDisplayName(profile, role) {
+  return rawText(profile.displayName || profile.display_name || profile.model || profile.provider || role);
+}
+
+function collectRawAgentProfileEntries(state) {
+  const entries = [];
+  for (const role of AGENT_PROFILE_ROLES) {
+    const setKey = profileSetKey(role);
+    const setProfiles = Array.isArray(state.profile_sets?.[setKey]) ? state.profile_sets[setKey] : [];
+    if (setProfiles.length > 0) {
+      setProfiles.forEach((profile, index) => {
+        entries.push({
+          role,
+          profile,
+          id: normalizeProfileId(profile?.id || profile?.label, index === 0 ? 'default' : `${role}-${index + 1}`),
+          source: 'profile_sets',
+          setKey,
+          index,
+        });
+      });
+      continue;
+    }
+
+    if (state.profiles?.[role]) {
+      entries.push({
+        role,
+        profile: state.profiles[role],
+        id: normalizeProfileId(state.profiles[role]?.id || state.profiles[role]?.label, 'default'),
+        source: 'profiles',
+        index: null,
+      });
+    }
+  }
+  return entries;
+}
+
+function createAgentProfileFinding(severity, code, message, entry, extra = {}) {
+  return {
+    severity,
+    code,
+    message,
+    role: entry.role,
+    profileId: entry.id,
+    fix: extra.fix || '',
+    before: extra.before,
+    after: extra.after,
+  };
+}
+
+function classifyAgentProfileEntry(projectRoot, entry, options = {}) {
+  const findings = [];
+  const profile = entry.profile || {};
+  const providerInput = rawText(profile.provider).toLowerCase();
+  const modelInput = rawText(profile.model);
+  const displayName = rawDisplayName(profile, entry.role);
+  let provider = providerInput;
+  let status = 'ok';
+
+  if (!providerInput) {
+    findings.push(createAgentProfileFinding(
+      'error',
+      'missing-provider',
+      `Profile ${entry.role}/${entry.id} is missing provider.`,
+      entry,
+      { fix: `npx create-quiver ai agent set ${entry.role} --provider <provider> --model <model>` },
+    ));
+  } else {
+    try {
+      provider = assertSupportedProvider(providerInput);
+      const runPreflight = options.checkProviderCli !== false;
+      if (runPreflight) {
+        const preflight = options.preflightProvider || preflightProvider;
+        try {
+          preflight(provider, {
+            cwd: projectRoot,
+            probe: options.providerProbe,
+            probeArgs: options.providerProbeArgs,
+          });
+        } catch (error) {
+          findings.push(createAgentProfileFinding(
+            'warning',
+            error && error.code === 'MISSING_PROVIDER_CLI' ? 'provider-cli-missing' : 'provider-cli-unverified',
+            `Provider CLI for '${provider}' could not be verified.`,
+            entry,
+            { fix: `Install and authenticate the ${provider} CLI, then rerun npx create-quiver ai agent doctor.` },
+          ));
+        }
+      }
+    } catch (error) {
+      findings.push(createAgentProfileFinding(
+        'error',
+        'unsupported-provider',
+        `Profile ${entry.role}/${entry.id} uses unsupported provider '${profile.provider}'.`,
+        entry,
+        { fix: `Use one of: ${formatProviderList()}.` },
+      ));
+      provider = providerInput;
+    }
+  }
+
+  if (!modelInput) {
+    findings.push(createAgentProfileFinding(
+      'warning',
+      'missing-model',
+      `Profile ${entry.role}/${entry.id} has no model selected.`,
+      entry,
+      { fix: `npx create-quiver ai agent set ${entry.role} --provider ${provider || '<provider>'} --model <model>` },
+    ));
+  } else if (providerInput && findings.every((finding) => finding.code !== 'unsupported-provider')) {
+    const modelSelection = normalizeModelSelection(provider, modelInput, {
+      displayName: rawText(profile.displayName || profile.display_name),
+    });
+    if (modelSelection.modelSource === 'catalog' && modelSelection.model !== modelInput) {
+      findings.push(createAgentProfileFinding(
+        'warning',
+        'display-model-alias',
+        `Profile ${entry.role}/${entry.id} stores display alias '${modelInput}' as the technical model id.`,
+        entry,
+        {
+          fix: 'Run npx create-quiver ai agent repair --dry-run to preview the normalized profile.',
+          before: { model: modelInput, displayName: rawText(profile.displayName || profile.display_name) },
+          after: { model: modelSelection.model, displayName: modelSelection.displayName },
+        },
+      ));
+    }
+    if (modelSelection.modelSource === 'custom') {
+      const validationStatus = rawText(profile.validation_status || profile.validationStatus);
+      if (!['validated', 'ok', 'passed'].includes(validationStatus.toLowerCase())) {
+        findings.push(createAgentProfileFinding(
+          'warning',
+          'custom-model-unvalidated',
+          `Profile ${entry.role}/${entry.id} uses custom model '${modelInput}' without live validation evidence.`,
+          entry,
+          { fix: `Run a dry-run or provider smoke with ${provider} before using this profile in automation.` },
+        ));
+      }
+    }
+  }
+
+  if (profile.default === true) {
+    findings.push(createAgentProfileFinding(
+      'info',
+      'default-profile',
+      `Profile ${entry.role}/${entry.id} is the default ${entry.role} profile.`,
+      entry,
+    ));
+  }
+
+  if (findings.some((finding) => finding.severity === 'error')) status = 'error';
+  else if (findings.some((finding) => finding.severity === 'warning')) status = 'warning';
+
+  return {
+    role: entry.role,
+    id: entry.id,
+    source: entry.source,
+    provider,
+    model: modelInput,
+    displayName,
+    default: profile.default === true,
+    status,
+    findings,
+  };
+}
+
+function addDuplicateDisplayNameFindings(checks) {
+  const groups = new Map();
+  for (const check of checks) {
+    const key = `${check.role}:${rawText(check.displayName).toLowerCase()}`;
+    if (!check.displayName) continue;
+    const group = groups.get(key) || [];
+    group.push(check);
+    groups.set(key, group);
+  }
+
+  for (const group of groups.values()) {
+    if (group.length < 2) continue;
+    const ids = group.map((item) => `${item.role}/${item.id}`).join(', ');
+    for (const check of group) {
+      check.findings.push({
+        severity: 'warning',
+        code: 'duplicate-display-name',
+        message: `Display name '${check.displayName}' is shared by ${ids}.`,
+        role: check.role,
+        profileId: check.id,
+        fix: 'Use --display-name or --id to make selector entries easier to distinguish.',
+      });
+      if (check.status !== 'error') check.status = 'warning';
+    }
+  }
+}
+
+function buildAgentProfileDoctorReport(projectRoot, options = {}) {
+  const state = readAgentProfiles(projectRoot);
+  const entries = collectRawAgentProfileEntries(state);
+  const checks = entries.map((entry) => classifyAgentProfileEntry(projectRoot, entry, options));
+  addDuplicateDisplayNameFindings(checks);
+  const findings = checks.flatMap((check) => check.findings);
+  const errors = findings.filter((finding) => finding.severity === 'error').length;
+  const warnings = findings.filter((finding) => finding.severity === 'warning').length;
+  const info = findings.filter((finding) => finding.severity === 'info').length;
+  const suggestedFixes = Array.from(new Set(findings
+    .map((finding) => finding.fix)
+    .filter(Boolean)));
+
+  return {
+    ok: errors === 0,
+    summary: {
+      profiles: checks.length,
+      defaults: checks.filter((check) => check.default).length,
+      errors,
+      warnings,
+      info,
+    },
+    checks,
+    findings,
+    suggestedFixes,
+  };
+}
+
+function repairProfileObject(profile, provider, modelSelection) {
+  const before = {
+    model: rawText(profile.model),
+    displayName: rawText(profile.displayName || profile.display_name),
+    modelSource: rawText(profile.modelSource || profile.model_source),
+    modelAlias: rawText(profile.modelAlias || profile.model_alias),
+    validation_status: rawText(profile.validation_status || profile.validationStatus),
+  };
+  const after = {
+    ...before,
+    model: modelSelection.model,
+    displayName: before.displayName || modelSelection.displayName,
+    modelSource: 'catalog',
+    modelAlias: before.model,
+    validation_status: before.validation_status || 'not-tested',
+  };
+
+  profile.model = after.model;
+  profile.displayName = after.displayName;
+  profile.modelSource = after.modelSource;
+  profile.modelAlias = after.modelAlias;
+  profile.validation_status = after.validation_status;
+  return { before, after, provider };
+}
+
+function buildAgentProfileRepairPlan(projectRoot, options = {}) {
+  const state = readAgentProfiles(projectRoot);
+  const nextState = cloneJson(state);
+  const entries = collectRawAgentProfileEntries(state);
+  const changes = [];
+
+  for (const entry of entries) {
+    const profile = entry.profile || {};
+    const providerInput = rawText(profile.provider).toLowerCase();
+    const modelInput = rawText(profile.model);
+    if (!providerInput || !modelInput) continue;
+
+    let provider;
+    try {
+      provider = assertSupportedProvider(providerInput);
+    } catch (error) {
+      continue;
+    }
+
+    const modelSelection = normalizeModelSelection(provider, modelInput, {
+      displayName: rawText(profile.displayName || profile.display_name),
+    });
+    if (modelSelection.modelSource !== 'catalog' || modelSelection.model === modelInput) {
+      continue;
+    }
+
+    const target = entry.source === 'profile_sets'
+      ? nextState.profile_sets[entry.setKey][entry.index]
+      : nextState.profiles[entry.role];
+    const repair = repairProfileObject(target, provider, modelSelection);
+    changes.push({
+      role: entry.role,
+      profileId: entry.id,
+      provider,
+      reason: 'display-model-alias',
+      before: repair.before,
+      after: repair.after,
+    });
+  }
+
+  return {
+    dryRun: true,
+    wouldWrite: false,
+    changes,
+    nextState: options.includeState === true ? nextState : undefined,
+  };
+}
+
 module.exports = {
   AGENT_PROFILE_ROLES,
   PROFILE_STATE_VERSION,
   agentProfilesPath,
+  buildAgentProfileDoctorReport,
+  buildAgentProfileRepairPlan,
   getAgentProfileById,
   getAgentProfilesForRole,
   resolveAgentProfileDisplayName,

package/src/create-quiver/lib/ai/execution-plan.js

@@ -12,6 +12,7 @@ const { branchDelete, runGit, statusPorcelain, worktreeAdd, worktreePrune, workt
 const { withLock } = require('../locks');
 const { safeBranchName, worktreesRootForRepo } = require('../slice');
 const { buildGraph, computeLevels, detectFileConflicts, isFoundationSliceId, readAllSlices, topoSort, SliceGraphError } = require('../slice-graph');
+const { resolveProviderModelSelection } = require('./providers');
 const { runExecuteSlice } = require('./executor');
 
 const EXCLUDED_STATUSES = new Set(['completed', 'skipped', 'cancelled']);
@@ -641,13 +642,17 @@ async function runExecutePlan(repoRoot, options = {}) {
   const executionMode = normalizeExecutionMode(options.mode || options.executionMode);
   const runtimeProfile = resolveExecutorRuntimeProfile(repoRoot, options);
   const provider = runtimeProfile.provider;
+  const explicitModel = String(options.model || '').trim();
+  const resolvedModel = runtimeProfile.model
+    ? resolveProviderModelSelection(provider, runtimeProfile.model).model
+    : '';
   const resolvedOptions = {
     ...options,
     mode: executionMode,
-    model: runtimeProfile.model,
+    model: explicitModel ? resolvedModel : undefined,
     provider,
     profile: runtimeProfile,
-    resolvedModel: runtimeProfile.model,
+    resolvedModel,
     resolvedProvider: provider,
   };
 

package/src/create-quiver/lib/ai/executor.js

@@ -86,6 +86,13 @@ function resolveExecutorRuntimeProfile(repoRoot, role, options = {}) {
   };
 }
 
+function runtimeModelExecutionOptions(runtimeProfile, options = {}) {
+  return {
+    model: runtimeProfile.model,
+    blockModelAlias: Boolean(runtimeProfile.profile && !String(options.model || '').trim()),
+  };
+}
+
 function createCommandUx(options = {}) {
   if (options.ux) {
     return options.ux;
@@ -955,7 +962,7 @@ async function runExecuteSlice(repoRoot, options = {}) {
       prompt,
       cwd: canonicalRepoRoot,
       timeoutMs,
-      model: runtimeProfile.model,
+      ...runtimeModelExecutionOptions(runtimeProfile, options),
       enforceModelSelection: false,
     });
   } catch (error) {
@@ -1028,7 +1035,7 @@ async function runExecuteSlice(repoRoot, options = {}) {
         tempRoot: options.tempRoot,
         tempFileName: options.tempFileName,
         tempFilePrefix: options.tempFilePrefix,
-        model: runtimeProfile.model,
+      ...runtimeModelExecutionOptions(runtimeProfile, options),
         enforceModelSelection: Boolean(runtimeProfile.model),
       }),
     });