llm-tuner 0.1.0

package/src/cli/index.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+import { select, input, confirm, search } from '@inquirer/prompts';
+import { detectHardware, detectEngines, Tuner, installPlans, runInstall, listPresets, presetsDir, fmtBytes, readSettings, writeSettings, THEMES, PROFILES, DEFAULT_PROFILE, TunerError } from '../core/index.js';
+import { t as translate, LOCALES, errorText } from '../i18n/index.js';
+import { profileChoices, profileNotes, profileSwitchNote, profileEventLines, shouldAskProfile } from './profile.js';
+
+const args = parseArgs(process.argv.slice(2));
+let { lang, theme } = await readSettings();
+const t = (key, params) => translate(lang, key, params);
+if ('lang' in args) {
+  if (!LOCALES.includes(args.lang)) {
+    console.error(translate('en', 'errors.unknownLocale', { lang: args.lang ?? '', list: LOCALES.join(', ') }));
+    process.exit(1);
+  }
+  lang = args.lang;
+  try { await writeSettings({ lang }); } catch (e) { console.error(c.y(t('cli.langNotSaved', { error: e.message }))); }
+}
+if ('theme' in args) {
+  if (!THEMES.includes(args.theme)) {
+    console.error(translate(lang, 'errors.unknownTheme', { theme: args.theme ?? '', list: THEMES.join(', ') }));
+    process.exit(1);
+  }
+  theme = args.theme;
+  try { await writeSettings({ theme }); } catch (e) { console.error(c.y(t('cli.themeNotSaved', { error: e.message }))); }
+}
+if ('profile' in args) {
+  if (!PROFILES.includes(args.profile)) {
+    console.error(translate(lang, 'errors.unknownProfile', { profile: args.profile ?? '', list: PROFILES.join(', ') }));
+    process.exit(1);
+  }
+}
+
+const isLight = () => theme === 'light';
+const c = {
+  b: (s) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s) => isLight() ? `\x1b[90m${s}\x1b[0m` : `\x1b[2m${s}\x1b[0m`,
+  g: (s) => isLight() ? `\x1b[32m${s}\x1b[0m` : `\x1b[92m${s}\x1b[0m`,
+  y: (s) => isLight() ? `\x1b[33m${s}\x1b[0m` : `\x1b[93m${s}\x1b[0m`,
+  r: (s) => isLight() ? `\x1b[31m${s}\x1b[0m` : `\x1b[91m${s}\x1b[0m`,
+  cyan: (s) => isLight() ? `\x1b[36m${s}\x1b[0m` : `\x1b[96m${s}\x1b[0m`,
+};
+
+if (args.help) {
+  console.log(t('cli.help', { presetsDir: presetsDir() }));
+  process.exit(0);
+}
+
+if (args.settings) {
+  try {
+    await settingsFlow();
+    process.exit(0);
+  } catch (e) {
+    if (e?.name === 'ExitPromptError') process.exit(130);
+    console.error(c.r(`\n${t('common.error', { message: errorText(lang, e) })}`));
+    process.exit(1);
+  }
+} else if (args.presets) {
+  const list = await listPresets({ engine: args.engine, modelKey: args.model });
+  if (!list.length) console.log(t('cli.noPresets'));
+  for (const p of list) console.log(`${p.engine.padEnd(9)} ${p.model}  ${p.ctx / 1024}K${p.profile ? `  ${p.profile}${p.variant && p.variant !== p.model ? ` (${p.variant})` : ''}` : ''}  KV ${p.kvType}  ${p.fullOffload ? t('candidate.allGpu') : t('cli.partial')}  ${p.shortTps} t/s  ${c.dim(p.createdAt.slice(0, 16).replace('T', ' '))}`);
+} else {
+  main().catch((e) => {
+    if (e?.name === 'ExitPromptError') process.exit(130);
+    console.error(c.r(`\n${t('common.error', { message: errorText(lang, e) })}`));
+    process.exit(1);
+  });
+}
+
+async function settingsFlow() {
+  while (true) {
+    const action = await select({
+      message: t('cli.settingsMenu'),
+      choices: [
+        { name: `${t('cli.settingsLanguage')}: ${lang === 'es' ? 'Español' : 'English'} (${lang})`, value: 'lang' },
+        { name: `${t('cli.settingsTheme')}: ${theme.charAt(0).toUpperCase() + theme.slice(1)}`, value: 'theme' },
+        { name: t('cli.settingsExit'), value: 'exit' },
+      ],
+    });
+
+    if (action === 'lang') {
+      lang = await select({
+        message: t('cli.settingsLanguage'),
+        default: lang,
+        choices: [
+          { name: 'English', value: 'en' },
+          { name: 'Español', value: 'es' },
+        ],
+      });
+      try {
+        await writeSettings({ lang });
+      } catch (e) {
+        console.error(c.y(t('cli.langNotSaved', { error: e.message })));
+      }
+    } else if (action === 'theme') {
+      theme = await select({
+        message: t('cli.settingsTheme'),
+        default: theme,
+        choices: [
+          { name: 'System', value: 'system' },
+          { name: 'Light', value: 'light' },
+          { name: 'Dark', value: 'dark' },
+        ],
+      });
+      try {
+        await writeSettings({ theme });
+      } catch (e) {
+        console.error(c.y(t('cli.themeNotSaved', { error: e.message })));
+      }
+    } else if (action === 'exit') {
+      console.log(c.g(t('cli.settingsSaved')));
+      break;
+    }
+  }
+}
+
+async function main() {
+  const out = (...a) => { if (!args.json) console.log(...a); };
+  out([
+    '',
+    `  ${c.cyan('  ╭───')}${c.dim('╷ ╷ ╷')}${c.cyan('───╮')}`,
+    `  ${c.cyan('╭─┤  ')}${c.cyan('┌───┐')}${c.cyan('  ├─╮  ')}${c.b('LLM Tuner')}`,
+    `  ${c.cyan('│ ')}${c.dim('╶┤')}${c.b(' │ █ │ ')}${c.dim('├╴')}${c.cyan('▲ │  ')}${c.dim(t('web.tagline'))}`,
+    `  ${c.cyan('╰─┤  ')}${c.cyan('└───┘')}${c.cyan('  ├──╯')}`,
+    `  ${c.cyan('  ╰───')}${c.dim('╵ ╵ ╵')}${c.cyan('───╯')}`,
+    '',
+  ].join('\n'));
+
+  const hw = await detectHardware();
+  out(c.dim(`  ${hw.cpu.brand} · ${fmtBytes(hw.ram.totalBytes)} RAM`));
+  for (const g of hw.gpus) out(c.dim(`  GPU${g.index} ${g.name} · ${fmtBytes(g.totalBytes)}${g.pcieGen ? ` · PCIe ${g.pcieGen}.0 x${g.pcieWidth}` : ''}${g.displayAttached ? t('cli.display') : ''}`));
+  if (!hw.gpus.length) out(c.y(`  ${t('cli.noGpu')}`));
+
+  // 1. Engine
+  let det = await detectEngines(hw);
+  let engineId = args.engine;
+  if (!engineId) {
+    engineId = await select({
+      message: t('cli.whichEngine'),
+      default: det.recommended,
+      choices: det.engines.map((e) => ({
+        name: `${e.name}  ${e.detection.installed ? c.g(t('cli.installed')) + (e.detection.version ? c.dim(' v' + e.detection.version) : '') : c.dim(t('cli.notInstalled'))}${e.id === det.recommended ? c.y(`  ${t('cli.recommended')}`) : ''}`,
+        value: e.id,
+      })),
+    });
+  }
+  if (!det.engines.find((e) => e.id === engineId)?.detection.installed) {
+    await installFlow(engineId);
+    det = await detectEngines(hw);
+    if (!det.engines.find((e) => e.id === engineId).detection.installed) throw new TunerError('errors.installNotFinished');
+  }
+  const tuner = await Tuner.create(engineId);
+
+  // 2. Model
+  let models = await tuner.listModels();
+  if (!models.length) {
+    out(c.y(`\n${t('cli.noModels', { engine: tuner.engine.name })}`));
+    const name = await input({ message: engineId === 'ollama' ? t('cli.downloadOllama') : t('cli.downloadLms') });
+    const bin = tuner.ctx.detection.bin;
+    const r = await runInstall(engineId === 'ollama' ? { cmd: bin, args: ['pull', name] } : { cmd: bin, args: ['get', name, '-y'] }, (l) => out(c.dim('  ' + l)));
+    if (r.code !== 0) throw new TunerError('errors.modelDownloadFailed');
+    models = await tuner.listModels();
+  }
+  const modelKey = args.model || await search({
+    message: t('cli.model'),
+    source: (term) => models
+      .filter((m) => !term || `${m.key} ${m.name}`.toLowerCase().includes(term.toLowerCase()))
+      .map((m) => ({ name: `${m.name}  ${c.dim(`${fmtBytes(m.sizeBytes)}${m.quant ? ' · ' + m.quant : ''}`)}`, value: m.key })),
+  });
+
+  // 3. Context
+  let ctx = Number(args.ctx) || null;
+  if (!ctx) {
+    const presets = await listPresets({ engine: engineId, modelKey });
+    const preview = await tuner.plan(modelKey, 8192);
+    const limit = preview.model.meta.trainContext || 131072;
+    const list = Object.entries(preview.maxContext).map(([k, v]) => `KV ${k} ${v ? Math.floor(v / 1024) + 'K' : '—'}`).join(' · ');
+    out(c.dim(`  ${t('cli.maxFullGpu', { list, train: Math.floor(limit / 1024) })}`));
+    if (presets.length) out(c.dim(`  ${t('cli.tunedContexts', { list: presets.map((p) => `${p.ctx / 1024}K (${p.shortTps} t/s)`).join(', ') })}`));
+    ctx = Number(await input({
+      message: t('cli.context'),
+      default: String(presets.at(-1)?.ctx || Math.min(16384, limit)),
+      validate: (v) => (Number(v) >= 512 && Number(v) <= limit) || t('cli.contextRange', { limit }),
+    }));
+  }
+
+  // 4. Profile
+  let profile = args.profile;
+  if (!profile && !shouldAskProfile(args)) {
+    profile = DEFAULT_PROFILE; // Non-interactive and fully flagged runs keep the behaviour scripts already rely on.
+  }
+  // The wizard gives the switch advice with its prompt; a profile that comes from a flag gets it with the load events.
+  const advisedByWizard = !profile;
+  if (!profile) {
+    const plan = await tuner.profilePlan(modelKey, ctx);
+    const { profile: stored } = await readSettings();
+    for (const line of profileNotes(plan, t)) {
+      out((line.level === 'warn' ? c.y : c.dim)(`  ${line.text}`));
+    }
+    profile = await select({
+      message: t('cli.profile'),
+      ...profileChoices(plan, t, { stored, mark: c.y, dim: c.dim }),
+    });
+    try {
+      await writeSettings({ profile });
+    } catch (e) {
+      console.error(c.y(t('cli.profileNotSaved', { error: e.message })));
+    }
+    const switchNote = profileSwitchNote(plan, profile, t, tuner.engine.name);
+    if (switchNote) out(c.dim(`  ${switchNote}`));
+  }
+
+  // 5. Load (preset or benchmark)
+  // Progress event before the current one: a fallback that repeats its reason is not printed twice.
+  let previous = null;
+  tuner.on('progress', (e) => {
+    if (args.json) return;
+    if (e.type === 'variant-picked' || e.type === 'profile-fallback') {
+      for (const line of profileEventLines(e, previous, t, advisedByWizard ? null : tuner.engine.name)) {
+        out((line.level === 'warn' ? c.y : c.dim)(`  ${line.text}`));
+      }
+    }
+    previous = e;
+    if (e.type === 'status') out(c.dim(`\n${t(e.code, e.params)}`));
+    if (e.type === 'preset-hit') out(c.g(`\n✓ ${t('cli.presetHit', { date: e.preset.createdAt.slice(0, 10), config: describe(e.preset.candidate), tps: e.preset.bench.short.genTps })}`));
+    if (e.type === 'candidate-start') out(`  [${e.index + 1}/${e.total}] ${describe(e.candidate)}`);
+    if (e.type === 'bench-progress' && e.phase === 'deep') out(c.dim(`      ${t('common.longPrompt', { tokens: e.promptTokens })}`));
+    if (e.type === 'candidate-done') {
+      const b = e.bench;
+      out(b.ok ? `      ${c.g('✓')} ${t('cli.benchShort', { tps: c.b(b.short.genTps + ' t/s') })}${b.deep ? t('cli.benchDeep', { tps: c.b(b.deep.genTps + ' t/s'), tokens: b.deep.promptTokens }) : ''} · CPU ${b.cpu.avg}% · VRAM ${vramStr(b.vramPeakBytes)}` : c.r(`      ✗ ${benchErrorText(b)}`));
+    }
+    if (e.type === 'preset-saved') out(c.g(`\n✓ ${t('common.presetSaved', { file: e.file })}`));
+  });
+
+  const result = await tuner.load(modelKey, ctx, {
+    profile,
+    force: !!args.force,
+    dryRun: !!args['dry-run'],
+    maxCandidates: Number(args.candidates) || 3,
+    confirmApply: async (preview) => {
+      out(c.b(`\n${t('cli.changes')}`));
+      if (engineId === 'lmstudio') {
+        preview.files.forEach((f) => out(`  ${f}`));
+        if (preview.restartsApp) out(c.y(`  ${t('cli.lmsRestart')}`));
+      } else {
+        out(`  ${t('cli.ollamaNewModel', { name: c.b(preview.tunedModel) })}`);
+        out(`  ${t('cli.ollamaServer', { env: Object.entries(preview.env).map(([k, v]) => `${k}=${v}`).join(' ') })}`);
+      }
+      return args.yes || confirm({ message: t('cli.confirmApply'), default: true });
+    },
+  });
+
+  if (args['dry-run']) out(c.y(`\n${t('cli.dryRun')}`));
+  if (result.applied?.backups?.length) out(c.dim(`  ${t('common.backups', { list: result.applied.backups.join(', ') })}`));
+  if (result.applied?.pendingCommands?.length) {
+    out(c.y(`\n${t('cli.pending')}`));
+    result.applied.pendingCommands.forEach((cmd) => out(`  ${cmd}`));
+  }
+  const l = result.loaded;
+  if (l) out(l.ok
+    ? c.g(`\n✓ ${t('cli.loaded', { engine: tuner.engine.name, tps: c.b(l.short.genTps + ' t/s') })}${l.model ? t('cli.usesModel', { model: l.model }) : ''}`)
+    : c.r(`\n✗ ${t('cli.loadFailed', { error: benchErrorText(l) })}`));
+  if (args.json) console.log(JSON.stringify(result, null, 2));
+}
+
+async function installFlow(engineId) {
+  const plans = await installPlans(engineId);
+  if (!plans.length) throw new TunerError('errors.noInstaller');
+  const plan = plans.length === 1 ? plans[0] : await select({ message: t('cli.installMethod'), choices: plans.map((p) => ({ name: t(p.labelCode), value: p })) });
+  console.log(c.dim(`  ${plan.shell || (plan.cmd ? [plan.cmd, ...plan.args].join(' ') : plan.url)}`));
+  if (!args.yes && !(await confirm({ message: t('cli.installNow'), default: true }))) process.exit(0);
+  const r = await runInstall(plan, (l) => console.log(c.dim('  ' + l)));
+  if (r.manual) await input({ message: t('cli.installManual') });
+  else if (r.code !== 0) throw new TunerError('errors.installerExit', { code: r.code });
+}
+
+function describe(cand) {
+  const where = cand.fullOffload ? t('candidate.allGpu') : t('candidate.layersGpu', { gpu: cand.gpuLayers, total: cand.totalLayers });
+  return `KV ${cand.kvType} · ${where}${cand.cpuMoeLayers ? t('candidate.expertsRam', { layers: cand.cpuMoeLayers }) : ''}${t('candidate.threads', { n: cand.threads })}${cand.probe ? t('candidate.probe') : ''}`;
+}
+
+function benchErrorText(b) {
+  return b.errorCode ? t(b.errorCode, b.errorParams) : b.error;
+}
+
+function vramStr(peaks = {}) {
+  const e = Object.entries(peaks || {});
+  return e.length ? e.map(([i, b]) => `GPU${i} ${(b / 1024 ** 3).toFixed(1)} GB`).join(' / ') : t('common.na');
+}
+
+function parseArgs(argv) {
+  const flags = new Set(['help', 'yes', 'dry-run', 'json', 'force', 'presets', 'settings']);
+  const o = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '-h') o.help = true;
+    if (a === '/settings' || a === '/setting' || a === 'settings') o.settings = true;
+    if (!a.startsWith('--')) continue;
+    const k = a.slice(2);
+    if (k === 'setting') { o.settings = true; continue; }
+    o[k] = flags.has(k) ? true : argv[++i];
+  }
+  return o;
+}

package/src/cli/profile.js

@@ -0,0 +1,74 @@
+// Pure helpers of the CLI profile step: no top-level side effects, so the tests import them without starting the wizard.
+import { PROFILES, fmtBytes } from '../core/index.js';
+
+// Reasons of a `variant-picked` event that mean the profile could not be honoured: the core flags them with a `profile-fallback` event right after.
+export const FALLBACK_REASONS = new Set(['profile.variant.noFullGpu']);
+
+/** True when the CLI has to ask for the load profile; `args` are the parsed flags. */
+export function shouldAskProfile(args) {
+  if (args.profile || args.yes || args.json) return false;
+  // Engine, model and context all from flags: a scripted run that asked nothing before the profiles existed, so it stays prompt-free.
+  const flagged = Boolean(args.engine && args.model && Number(args.ctx));
+  return !flagged;
+}
+
+/** Choices and preselection for the profile prompt, from a `Tuner.profilePlan()` result. */
+export function profileChoices(plan, t, { stored = null, mark = (s) => s, dim = (s) => s } = {}) {
+  const choices = PROFILES.map((profile) => {
+    const info = plan.profiles[profile];
+    // What the engine will load: the selected variant when it cannot switch to the profile's pick.
+    const variant = plan.variants.find((v) => v.key === info.loads);
+    const quant = variant?.quant ?? null;
+    const uses = quant ? `${quant} · KV ${info.kvTypes.join(', ')}` : `KV ${info.kvTypes.join(', ')}`;
+    const name = `${t(`profile.name.${profile}`)}  ${dim(`${t(`profile.desc.${profile}`)} · ${uses}`)}`;
+    const isRecommended = profile === plan.recommended.profile;
+    return {
+      name: isRecommended ? `${name}${mark(`  ${t('cli.recommended')}`)}` : name,
+      value: profile,
+      short: t(`profile.name.${profile}`),
+    };
+  });
+  return { choices, default: stored ?? plan.recommended.profile };
+}
+
+/** Lines shown with the profile prompt, as `{ text, level }` with level `note` or `warn`: why a profile is recommended, a warning when the preview is conservative and which heavier variants would fit. */
+export function profileNotes(plan, t) {
+  const notes = [{ text: t(plan.recommended.reasonCode), level: 'note' }];
+  if (plan.vramBusy) {
+    // The plan was made with the VRAM that is free now; a real load frees it first.
+    notes.push({ text: t('profile.preview.vramBusy'), level: 'warn' });
+  }
+  for (const h of plan.hints) {
+    notes.push({ text: t('cli.profileHint', { quant: h.quant, size: fmtBytes(h.estimatedBytes) }), level: 'note' });
+  }
+  return notes;
+}
+
+/** Advice to select another variant in the engine, or null when the profile loads its own pick. */
+export function profileSwitchNote(plan, profile, t, engine) {
+  const info = plan.profiles[profile];
+  if (!info?.recommendSwitch) return null;
+  return t('cli.profileSwitch', { quant: info.quant ?? info.variant, engine });
+}
+
+/** Lines to print for a `variant-picked` or `profile-fallback` event, as `{ text, level }` with level `note` or `warn`; `previous` is the event before it and `engine` the engine name, or null to leave the switch advice out. */
+export function profileEventLines(event, previous, t, engine = null) {
+  const { variant } = event;
+  // Nothing to say without the variant; throwing here would reject the load from inside the progress listener.
+  if (!variant) return [];
+  const isFallback = event.type === 'profile-fallback';
+  const lines = [];
+
+  // A fallback that repeats the reason of the line before it is not printed again.
+  if (!(isFallback && event.reasonCode === previous?.reasonCode)) {
+    const level = isFallback || FALLBACK_REASONS.has(event.reasonCode) ? 'warn' : 'note';
+    lines.push({ text: t(event.reasonCode, { quant: variant.quant ?? '?', key: variant.key }), level });
+  }
+
+  // The engine cannot load the pick itself: tell the user which variant to select there.
+  if (event.type === 'variant-picked' && event.recommendSwitch && engine) {
+    lines.push({ text: t('cli.profileSwitch', { quant: variant.quant ?? variant.key, engine }), level: 'note' });
+  }
+
+  return lines;
+}

package/src/core/benchmark.js

@@ -0,0 +1,101 @@
+import { fetchJson, cpuSnapshot, cpuBusyPercent } from './util.js';
+import { startVramSampler } from './hardware.js';
+
+// Deterministic pseudo-random generator so every run gets the same prompt.
+function rng(seed) {
+  let s = seed >>> 0;
+  return () => ((s = (s * 1664525 + 1013904223) >>> 0) / 2 ** 32);
+}
+
+const WORDS = ['user', 'order', 'cache', 'item', 'queue', 'token', 'config', 'buffer', 'session', 'payload', 'record', 'index', 'stream', 'result', 'handler', 'worker', 'price', 'account', 'event', 'metric'];
+const VERBS = ['load', 'parse', 'build', 'update', 'validate', 'compute', 'merge', 'flush', 'resolve', 'render', 'fetch', 'encode'];
+
+/**
+ * Synthetic but realistic-looking source code, roughly `tokens` long.
+ * Code tokenizes at ~3.3 chars/token on modern BPE vocabularies.
+ */
+export function makeCodePrompt(tokens, charsPerToken = 3.3, seed = 42) {
+  const r = rng(seed);
+  const pick = (a) => a[Math.floor(r() * a.length)];
+  const target = Math.max(64, Math.floor(tokens * charsPerToken));
+  let out = '// Module under review. Read it carefully; questions follow at the end.\n\n';
+  let n = 0;
+  while (out.length < target) {
+    const a = pick(WORDS), b = pick(WORDS), v = pick(VERBS);
+    const fn = `${v}${a[0].toUpperCase()}${a.slice(1)}${n++}`;
+    out += `export function ${fn}(${a}s, options = {}) {\n` +
+      `  const ${b}Map = new Map();\n` +
+      `  for (const ${a} of ${a}s) {\n` +
+      `    if (!${a} || ${a}.${b}Id == null) continue;\n` +
+      `    const key = \`\${${a}.${b}Id}:\${options.${pick(WORDS)} ?? ${Math.floor(r() * 1000)}}\`;\n` +
+      `    const prev = ${b}Map.get(key) ?? { count: 0, total: 0 };\n` +
+      `    ${b}Map.set(key, { count: prev.count + 1, total: prev.total + (${a}.${pick(WORDS)} || 0) * ${(r() * 10).toFixed(2)} });\n` +
+      `  }\n  return [...${b}Map.entries()].filter(([, v]) => v.count > ${Math.floor(r() * 5)});\n}\n\n`;
+  }
+  return out.slice(0, target) + '\n}\n\n// Task: explain what the last function does, then write an optimized version of it with comments.\n';
+}
+
+/** Sample CPU and VRAM while `fn` runs. */
+export async function withSampling(fn) {
+  const vram = startVramSampler(500);
+  const samples = [];
+  let prev = cpuSnapshot();
+  const timer = setInterval(() => { const now = cpuSnapshot(); samples.push(cpuBusyPercent(prev, now)); prev = now; }, 500);
+  try {
+    const result = await fn();
+    return { result, cpu: summarize(samples), vramPeakBytes: vram.stop() };
+  } finally {
+    clearInterval(timer);
+    vram.stop();
+  }
+}
+
+const summarize = (s) => (s.length ? { avg: +(s.reduce((a, b) => a + b, 0) / s.length).toFixed(1), max: +Math.max(...s).toFixed(1) } : { avg: null, max: null });
+
+/**
+ * Benchmark a model already served by LM Studio or Ollama through its HTTP API.
+ * Runs a short prompt (pure decode speed) and a deep one (speed with a full context).
+ */
+export async function runApiBenchmark({ kind, baseUrl, model, depthTokens = 4000, genTokens = 200, ollamaOptions = {}, onProgress = () => {} }) {
+  const one = async (label, promptTokens) => {
+    onProgress({ phase: label, promptTokens });
+    const prompt = makeCodePrompt(promptTokens);
+    if (kind === 'ollama') {
+      const res = await fetchJson(`${baseUrl}/api/generate`, {
+        method: 'POST', timeout: 1_800_000,
+        body: { model, prompt, raw: true, stream: false, options: { ...ollamaOptions, num_predict: genTokens, temperature: 0.2 } },
+      });
+      const d = res?.json;
+      if (!res?.ok || !d?.eval_count) return { ok: false, error: d?.error || res?.text?.slice(0, 300) || 'no response' };
+      return {
+        ok: true,
+        promptTokens: d.prompt_eval_count,
+        genTokens: d.eval_count,
+        genTps: +(d.eval_count / (d.eval_duration / 1e9)).toFixed(1),
+        ppTps: d.prompt_eval_duration ? +(d.prompt_eval_count / (d.prompt_eval_duration / 1e9)).toFixed(0) : null,
+      };
+    }
+    const res = await fetchJson(`${baseUrl}/api/v0/chat/completions`, {
+      method: 'POST', timeout: 1_800_000,
+      body: { model, messages: [{ role: 'user', content: prompt }], max_tokens: genTokens, temperature: 0.2, stream: false },
+    });
+    const d = res?.json;
+    if (!res?.ok || !d?.stats) return { ok: false, error: d?.error?.message || d?.error || res?.text?.slice(0, 300) || 'no response' };
+    return {
+      ok: true,
+      promptTokens: d.usage?.prompt_tokens,
+      genTokens: d.usage?.completion_tokens,
+      genTps: +d.stats.tokens_per_second.toFixed(1),
+      ppTps: d.stats.time_to_first_token ? +(d.usage.prompt_tokens / d.stats.time_to_first_token).toFixed(0) : null,
+    };
+  };
+
+  const { result, cpu, vramPeakBytes } = await withSampling(async () => {
+    const short = await one('short', 200);
+    if (!short.ok) return { short };
+    const deep = depthTokens > 400 ? await one('deep', depthTokens) : null;
+    return { short, deep };
+  });
+  const ok = result.short.ok && (!result.deep || result.deep.ok);
+  return { ok, error: ok ? null : (result.deep?.error || result.short.error), short: result.short, deep: result.deep, cpu, vramPeakBytes };
+}