badgr-cli 1.0.30 → 1.0.32

package/src/commands/serve.js

@@ -1,10 +1,13 @@
 import { requireApiKey } from '../config.js';
+import { callApi } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 
 /**
  * badgr serve meta-llama/Llama-3.1-8B-Instruct
  * badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
+ * badgr serve BAAI/bge-large-en-v1.5 --task embed
+ * badgr serve --image ghcr.io/my-org/diffusers-api:latest --gpu L40S --env MODEL_ID=flux
  *
  * GPU defaults to "AUTO" — backend infers from model size.
  */
@@ -14,6 +17,8 @@ export function parseServeArgs(args) {
   let i = 0;
   while (i < args.length) {
     if (args[i] === '--gpu')        { flags.gpu = args[++i]; i++; continue; }
+    if (args[i] === '--image')      { flags.image = args[++i]; i++; continue; }
+    if (args[i] === '--task')       { flags.task = args[++i]; i++; continue; }
     if (args[i] === '--count')      { flags.count = parseInt(args[++i], 10); i++; continue; }
     if (args[i] === '--region')     { flags.region = args[++i]; i++; continue; }
     if (args[i] === '--tier')       { flags.tier = args[++i]; i++; continue; }
@@ -21,14 +26,32 @@ export function parseServeArgs(args) {
     if (args[i] === '--name')       { flags.name = args[++i]; i++; continue; }
     if (args[i] === '--no-wait')               { flags.noWait = true; i++; continue; }
     if (args[i] === '--max-cost')              { flags.maxCost = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--strict-capacity')    { flags.noMarketplaceFallback = true; i++; continue; }
-    if (args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
+    if (args[i] === '--health-path')           { flags.healthPath = args[++i]; i++; continue; }
+    // All three aliases map to noMarketplaceFallback
+    if (args[i] === '--no-fallback' ||
+        args[i] === '--strict-capacity' ||
+        args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
+    if (args[i] === '--env') {
+      const kv = args[++i]; i++;
+      if (!flags.env) flags.env = [];
+      flags.env.push(kv);
+      continue;
+    }
     positional.push(args[i++]);
   }
   const model = positional[0] || null;
   return { model, flags };
 }
 
+function parseEnvFlag(envList) {
+  const obj = {};
+  for (const kv of (envList || [])) {
+    const idx = kv.indexOf('=');
+    if (idx > 0) obj[kv.slice(0, idx)] = kv.slice(idx + 1);
+  }
+  return obj;
+}
+
 // Mirror of backend workload_profile.py infer_profile_from_model — for pre-flight display.
 function _inferServeProfile(modelName) {
   const s = modelName.toLowerCase();
@@ -46,61 +69,122 @@ function _inferServeProfile(modelName) {
   return                      { label: 'inference (70B+ model)',    vram: '80+ GB', gpus: ['H100', 'A100'] };
 }
 
-function _serveStageLabel(elapsedSec) {
-  if (elapsedSec < 45)  return 'Starting vLLM…';
-  if (elapsedSec < 150) return 'Downloading model…';
-  return 'Waiting for /v1/models…';
+function _serveStageLabel(elapsedSec, healthPath = '/models') {
+  if (healthPath === '/models') {
+    if (elapsedSec < 45)  return 'Starting vLLM…';
+    if (elapsedSec < 150) return 'Downloading model…';
+    return 'Waiting for /v1/models…';
+  }
+  if (elapsedSec < 30)  return 'Starting container…';
+  if (elapsedSec < 120) return 'Container starting…';
+  return `Waiting for ${healthPath}…`;
 }
 
-async function waitForEndpoint(endpointUrl, timeoutMs = 5 * 60 * 1000, chalk) {
+function _detectHealthPath(image) {
+  if (!image) return null;
+  return image.toLowerCase().includes('comfyui') ? '/system_stats' : null;
+}
+
+/**
+ * Poll the model endpoint until /models returns 200, or timeout.
+ * Also checks deployment status on each iteration — fails fast if the dep is dead.
+ * Returns { ready: boolean, timedOut: boolean, depFailed: boolean, failReason?: string }
+ */
+async function waitForEndpoint(endpointUrl, deploymentId, config, timeoutMs = 5 * 60 * 1000, chalk, healthPath = '/models') {
   const startMs  = Date.now();
   const deadline = startMs + timeoutMs;
 
   while (Date.now() < deadline) {
+    // Check deployment status first — fail fast on OOM/crash before waiting more
+    try {
+      const dep = await callApi(`/deployments/${deploymentId}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        timeoutMs: 10_000,
+      });
+      if (['failed', 'terminated', 'error', 'stopped'].includes(dep.status)) {
+        process.stdout.write('\n');
+        return { ready: false, timedOut: false, depFailed: true, failReason: dep.error || dep.status };
+      }
+    } catch {
+      // status check failed — continue to endpoint check
+    }
+
     try {
-      const res = await fetch(`${endpointUrl}/models`, { signal: AbortSignal.timeout(8000) });
-      if (res.ok) { process.stdout.write('\n'); return true; }
+      const res = await fetch(`${endpointUrl}${healthPath}`, { signal: AbortSignal.timeout(8000) });
+      if (res.ok) { process.stdout.write('\n'); return { ready: true, timedOut: false, depFailed: false }; }
     } catch {
       // still starting
     }
+
     const elapsed = Math.round((Date.now() - startMs) / 1000);
     process.stdout.write(
-      `\r  ${chalk.dim(_serveStageLabel(elapsed) + ` (${elapsed}s)`)}   `
+      `\r  ${chalk.dim(_serveStageLabel(elapsed, healthPath) + ` (${elapsed}s)`)}   `
     );
     await new Promise(r => setTimeout(r, 8000));
   }
+
   process.stdout.write('\n');
-  return false;
+  return { ready: false, timedOut: true, depFailed: false };
 }
 
 export async function serveCommand(config, args, chalk) {
   const { model, flags } = parseServeArgs(args);
+  const customImage = flags.image || null;
 
-  if (!model) {
+  if (!model && !customImage) {
     console.error(chalk.red('Usage: badgr serve <model>'));
     console.error(chalk.red('       badgr serve meta-llama/Llama-3.1-8B-Instruct'));
+    console.error(chalk.red('       badgr serve --image ghcr.io/my-org/api:latest --gpu L40S'));
     return;
   }
 
   requireApiKey(config);
 
-  // gpu=AUTO tells the backend to infer the right GPU from model size
-  const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
+  // ── Validate flags early ───────────────────────────────────────────────────
+  if (flags.count !== undefined && (!Number.isFinite(flags.count) || flags.count < 1)) {
+    console.error(chalk.red('  ✗ --count must be an integer greater than 0'));
+    process.exitCode = 1;
+    return;
+  }
+  if (flags.maxCost !== undefined && (!Number.isFinite(flags.maxCost) || flags.maxCost <= 0)) {
+    console.error(chalk.red('  ✗ --max-cost must be a number greater than 0'));
+    process.exitCode = 1;
+    return;
+  }
+  if (flags.region !== undefined && !['US', 'EU', 'AU'].includes(flags.region.toUpperCase())) {
+    console.error(chalk.red('  ✗ --region must be US, EU, or AU'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const envObj = parseEnvFlag(flags.env);
+
+  const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : (customImage ? 'L40S' : 'AUTO');
   const gpuLabel = gpu === 'AUTO' ? 'auto' : gpu;
 
   const effectiveTier = normalizeTier(flags.tier);
 
-  console.log(chalk.bold('\n⚡ Serving model\n'));
-  console.log(`  ${chalk.bold('Model:')}  ${model}`);
-  console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
+  if (customImage) {
+    console.log(chalk.bold('\n⚡ Serving custom container\n'));
+    console.log(`  ${chalk.bold('Image:')}  ${customImage}`);
+    console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
+    if (flags.task) console.log(`  ${chalk.bold('Task:')}   ${flags.task}`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}    ${flags.env.join(', ')}`);
+  } else {
+    console.log(chalk.bold('\n⚡ Serving model\n'));
+    console.log(`  ${chalk.bold('Model:')}  ${model}`);
+    console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
+    if (flags.task) console.log(`  ${chalk.bold('Task:')}   ${flags.task}`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}    ${flags.env.join(', ')}`);
 
-  // Show inferred workload so the user knows what Badgr detected.
-  if (gpu === 'AUTO') {
-    const prof = _inferServeProfile(model);
-    console.log();
-    console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
-    console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
-    if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}           $${flags.maxCost.toFixed(2)}`);
+    if (gpu === 'AUTO') {
+      const prof = _inferServeProfile(model);
+      console.log();
+      console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
+      console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
+      if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}           $${flags.maxCost.toFixed(2)}`);
+    }
   }
   console.log();
   process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
@@ -109,13 +193,16 @@ export async function serveCommand(config, args, chalk) {
 
   function buildBody(gpuOverride, tierOverride) {
     return {
-      model,
+      ...(model ? { model } : {}),
+      ...(customImage ? { image: customImage } : {}),
+      ...(flags.task ? { task: flags.task } : {}),
       gpu: gpuOverride || gpu,
       gpu_count: flags.count || 1,
       ...(effectiveRegion ? { region: effectiveRegion } : {}),
       max_price_per_hour: flags.maxPrice,
       name: flags.name,
       tier: tierOverride || effectiveTier,
+      ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
     };
   }
 
@@ -128,27 +215,19 @@ export async function serveCommand(config, args, chalk) {
       effectiveTier,
       chalk,
       { thing: 'endpoint', cmd: 'badgr serve' },
+      { allowTier2Fallback: !flags.noMarketplaceFallback },
     );
   } catch (err) {
-    const failRcptId = generateReceiptId();
-    addReceipt({
-      receiptId:   failRcptId,
-      action:      'badgr serve',
-      model,
-      gpu: gpuLabel,
-      status:      'failed',
-      failureType: 'infrastructure',
-      createdAt:   new Date().toISOString(),
-    });
     if (err.isPaymentRequired) {
       console.error(chalk.yellow(err.message));
       const rerun = `badgr serve ${args.join(' ')}`;
       console.error(chalk.dim(`After payment, rerun:\n  ${rerun}\n`));
+      process.exitCode = 1;
       return;
     }
-    console.error(chalk.red(`\n  ✗ Could not start endpoint: ${err.message}`));
-    console.error(chalk.dim(`\n  Receipt: ${failRcptId}`));
-    console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
+    // CapacityError message is pre-formatted with chalk
+    console.error(err.message);
+    process.exitCode = 1;
     return;
   }
 
@@ -180,18 +259,84 @@ export async function serveCommand(config, args, chalk) {
     createdAt:    new Date().toISOString(),
   });
 
-  const endpointUrl = dep.endpoint_url || dep.openai_base_url || config.baseUrl;
+  // ── Fix 7: never fall back to config.baseUrl for endpoint health check ─────
+  const endpointUrl = dep.endpoint_url || dep.openai_base_url;
+  if (!endpointUrl) {
+    console.error(chalk.red(
+      `\n  ✗ Deployment ${dep.deployment_id} has no endpoint URL yet.\n` +
+      `  Run: badgr status ${dep.deployment_id}\n`
+    ));
+    updateReceipt(rcptId, { status: 'no_endpoint_url' });
+    process.exitCode = 1;
+    return;
+  }
+
+  // ── Determine health check path ───────────────────────────────────────────
+  // Priority: explicit --health-path > auto-detect comfyui > /models for vLLM > null (skip)
+  let resolvedHealthPath;
+  if (flags.healthPath) {
+    resolvedHealthPath = flags.healthPath;
+  } else if (!customImage) {
+    resolvedHealthPath = '/models';
+  } else {
+    resolvedHealthPath = _detectHealthPath(customImage);  // '/system_stats' for comfyui, null otherwise
+  }
 
   // ── Health check ──────────────────────────────────────────────────────────
   let endpointReady = false;
   if (flags.noWait) {
     console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
+  } else if (resolvedHealthPath === null) {
+    console.log(chalk.yellow(
+      '\n  Skipping health check (custom image — add --health-path /your-readiness-path to enable)\n'
+    ));
   } else {
-    endpointReady = await waitForEndpoint(endpointUrl, 5 * 60 * 1000, chalk);
+    if (resolvedHealthPath !== '/models') {
+      process.stdout.write(chalk.dim(`  Checking ${resolvedHealthPath} for readiness…\n`));
+    }
+    // Check deployment status once before starting the 5-min wait
+    try {
+      const latest = await callApi(`/deployments/${dep.deployment_id}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        timeoutMs: 10_000,
+      });
+      if (['failed', 'terminated', 'error'].includes(latest.status)) {
+        console.error(chalk.red(
+          `\n  ✗ Deployment failed before endpoint became ready: ${latest.error || latest.status}\n`
+        ));
+        updateReceipt(rcptId, { status: 'failed', failReason: latest.error || latest.status });
+        process.exitCode = 1;
+        return;
+      }
+    } catch {
+      // status check failed — proceed with endpoint poll anyway
+    }
+
+    const healthResult = await waitForEndpoint(endpointUrl, dep.deployment_id, config, 5 * 60 * 1000, chalk, resolvedHealthPath);
     process.stdout.write('\n');
+
+    if (healthResult.depFailed) {
+      console.error(chalk.red(
+        `\n  ✗ Deployment failed during startup: ${healthResult.failReason || 'unknown error'}\n` +
+        `  Check logs: badgr logs ${dep.deployment_id}\n`
+      ));
+      updateReceipt(rcptId, { status: 'failed', failReason: healthResult.failReason });
+      process.exitCode = 1;
+      return;
+    }
+
+    endpointReady = healthResult.ready;
     if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
   }
 
+  // ── Update receipt with final state ───────────────────────────────────────
+  updateReceipt(rcptId, {
+    status:      endpointReady ? 'ready' : 'starting',
+    endpointUrl,
+    updatedAt:   new Date().toISOString(),
+  });
+
   // ── Result ────────────────────────────────────────────────────────────────
   if (endpointReady) {
     console.log(chalk.green('\n  ✓ Endpoint ready\n'));
@@ -205,7 +350,8 @@ export async function serveCommand(config, args, chalk) {
   const serveRate = dep.cost_per_hour || 0;
 
   console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
-  console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
+  if (dep.model || model) console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
+  if (customImage)        console.log(`  ${chalk.bold('Image:')}        ${customImage}`);
   console.log(`  ${chalk.bold('GPU:')}          ${dep.gpu_type} × ${dep.gpu_count}`);
   if (serveRate > 0) console.log(`  ${chalk.bold('Rate:')}         $${serveRate.toFixed(2)}/hr`);
   if (flags.maxCost) console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost.toFixed(2)}`);
@@ -220,8 +366,8 @@ export async function serveCommand(config, args, chalk) {
   }
   console.log(chalk.dim('  Billing continues until you run: ') + chalk.cyan(`badgr down ${dep.deployment_id}`));
 
-  if (endpointReady) {
-    const keySnip = config.apiKey?.slice(0, 8) || 'sk-...';
+  if (endpointReady && !customImage) {
+    const keySnip = config.apiKey?.slice(0, 4) || 'sk-...';
     console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);
     console.log(chalk.dim(`    from openai import OpenAI`));
     console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${keySnip}...")`));

package/src/fallback.js

@@ -10,48 +10,66 @@ export function normalizeTier(tier) {
   return (tier === '2' || tier === 'tier2' || tier === 'tier-2') ? '2' : (tier || '1');
 }
 
+/**
+ * Sentinel error thrown when callWithFallback cannot provision capacity.
+ * The message is already formatted for display; callers should print it and exit.
+ */
+export class CapacityError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CapacityError';
+    this.isCapacityError = true;
+  }
+}
+
 /**
  * Call an API endpoint with automatic tier-2 expansion on NO_CAPACITY_MATCH.
- * Returns the deployment object on success; throws or calls process.exit on failure.
+ * Returns the deployment object on success.
+ * Throws CapacityError (pre-formatted for display) on unrecoverable failure.
+ * Re-throws payment errors (err.isPaymentRequired) for callers to handle.
  *
- * @param {string}   endpoint   - '/run' or '/serve'
- * @param {object}   callOpts   - { apiKey, baseUrl }
- * @param {function} buildBody  - (tierOverride?) => body object
+ * @param {string}   endpoint          - '/run' or '/serve'
+ * @param {object}   callOpts          - { apiKey, baseUrl }
+ * @param {function} buildBody         - (tierOverride?) => body object
  * @param {string}   effectiveTier
  * @param {object}   chalk
- * @param {object}   labels     - { thing: 'job'|'endpoint', cmd: 'badgr run'|'badgr serve' }
+ * @param {object}   labels            - { thing: 'job'|'endpoint', cmd: 'badgr run'|'badgr serve' }
+ * @param {object}   [opts]
+ * @param {boolean}  [opts.allowTier2Fallback=true] - set false to disable tier-2 expansion
  */
-export async function callWithFallback(endpoint, callOpts, buildBody, effectiveTier, chalk, labels) {
+export async function callWithFallback(endpoint, callOpts, buildBody, effectiveTier, chalk, labels, opts = {}) {
   const { callApi } = await import('./api.js');
   const thing = labels?.thing ?? 'job';
   const cmd   = labels?.cmd   ?? 'badgr run';
+  const allowTier2Fallback = opts.allowTier2Fallback !== false; // default true
 
   async function attempt(body) {
-    return callApi(endpoint, { method: 'POST', ...callOpts, body });
+    return callApi(endpoint, { method: 'POST', ...callOpts, body, timeoutMs: 30_000 });
   }
 
-  function handleErr(err, isFallback) {
+  function buildCapacityError(err, isFallback) {
     const d = err.errorData;
+    let msg;
     if (d?.code === 'NO_CAPACITY_MATCH') {
-      console.error(chalk.red('\n  ✗ No suitable GPU capacity available right now.\n'));
-      console.error(chalk.dim('  Try `badgr capacity` to see what\'s available, or try again shortly.'));
+      msg = chalk.red('\n  ✗ No suitable GPU capacity available right now.\n') +
+            chalk.dim('  Try `badgr capacity` to see what\'s available, or try again shortly.');
     } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
       if (d?.low_cost_provider_failed) {
-        console.error(chalk.red(`\n  ✗ No suitable capacity available right now. Try again shortly.\n`));
+        msg = chalk.red(`\n  ✗ No suitable capacity available right now. Try again shortly.\n`);
       } else {
-        console.error(chalk.red(`\n  ✗ Capacity found but ${thing} failed to start. Please try again.\n`));
+        msg = chalk.red(`\n  ✗ Capacity found but ${thing} failed to start. Please try again.\n`);
         if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
-          if (d?.debug_error) console.error(chalk.dim(`  Detail: ${d.debug_error}`));
+          if (d?.debug_error) msg += chalk.dim(`  Detail: ${d.debug_error}`);
         } else {
-          console.error(chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.\n`));
+          msg += chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.\n`);
         }
       }
     } else {
-      console.error(chalk.red(`\n  ✗ Could not start ${thing}: ${err.message}\n`));
-      console.error(chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.`));
-      if (!isFallback) console.error(chalk.dim(`  Check config: badgr config\n`));
+      msg = chalk.red(`\n  ✗ Could not start ${thing}: ${err.message}\n`) +
+            chalk.dim(`  Run BADGR_DEBUG=1 ${cmd} … for a full trace.`);
+      if (!isFallback) msg += '\n' + chalk.dim(`  Check config: badgr config\n`);
     }
-    process.exit(1);
+    return new CapacityError(msg);
   }
 
   try {
@@ -59,26 +77,26 @@ export async function callWithFallback(endpoint, callOpts, buildBody, effectiveT
   } catch (err) {
     const d = err.errorData;
 
-    if (d?.code === 'NO_CAPACITY_MATCH' && effectiveTier !== '2') {
+    if (d?.code === 'NO_CAPACITY_MATCH' && effectiveTier !== '2' && allowTier2Fallback) {
       console.log(chalk.dim('\n  Primary capacity unavailable — expanding search...\n'));
       try {
         return await attempt(buildBody('2'));
       } catch (err2) {
-        handleErr(err2, true);
+        throw buildCapacityError(err2, true);
       }
     }
 
     if (err.isPaymentRequired) throw err; // let caller handle payment errors
-    handleErr(err, false);
+    throw buildCapacityError(err, false);
   }
 }
 
 // ── GPU fallback prompt ───────────────────────────────────────────────────────
 
 // GPU descriptions for display only — no scoring logic lives here.
-// Ranking is computed server-side and returned as `rank` on each alternative.
 const GPU_DISPLAY = {
   RTX_3080: { desc: 'Dev, light inference' },
+  RTX_3090: { desc: 'Dev, inference' },
   RTX_4080: { desc: 'Inference and dev workloads' },
   RTX_4090: { desc: 'Inference, training, dev' },
   L40S:     { desc: 'Inference, vLLM, batch jobs' },
@@ -89,27 +107,18 @@ const GPU_DISPLAY = {
 
 /**
  * Sort alternatives for display.
- *
- * - mode 'closest'  → use backend `rank` field (1 = best match); fall back to price.
- * - mode 'cheapest' → sort by price ascending only.
- *
- * The scoring algorithm has been removed from the CLI; the backend now
- * computes and attaches `rank` and `diff_desc` to every alternative.
  */
 export function rankAlternatives(requestedGpu, alternatives, mode = 'closest') {
   if (!alternatives || alternatives.length === 0) return [];
   if (mode === 'cheapest') return [...alternatives].sort((a, b) => a.price - b.price);
-  // 'closest': honour backend rank when present
   if (alternatives.some(a => a.rank != null)) {
     return [...alternatives].sort((a, b) => (a.rank ?? 999) - (b.rank ?? 999));
   }
-  // Older backend without rank — fall back to price
   return [...alternatives].sort((a, b) => a.price - b.price);
 }
 
 /**
- * One-line diff for display. Uses `diff_desc` from backend when present,
- * otherwise omits the diff rather than duplicating the scoring logic.
+ * One-line diff for display.
  */
 export function diffDescription(requestedGpu, altGpu, alt = {}) {
   return alt.diff_desc || '';

package/tests/commands.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { parseRunArgs, classifyFailure } from '../src/commands/run.js';
 import { parseServeArgs } from '../src/commands/serve.js';
 import { testCommand, parseTestArgs } from '../src/commands/test-run.js';
-import { rankAlternatives, diffDescription, promptFallback } from '../src/fallback.js';
+import { rankAlternatives, diffDescription, promptFallback, CapacityError } from '../src/fallback.js';
 
 describe('parseRunArgs', () => {
   it('parses a plain command', () => {
@@ -208,6 +208,47 @@ describe('parseServeArgs', () => {
     const { flags } = parseServeArgs(['my/model']);
     expect(flags.tier).toBeUndefined();
   });
+
+  it('parses --no-fallback as noMarketplaceFallback', () => {
+    const { flags } = parseServeArgs(['my/model', '--no-fallback']);
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('parses --strict-capacity as noMarketplaceFallback', () => {
+    const { flags } = parseServeArgs(['my/model', '--strict-capacity']);
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('parses --no-expanded-search as noMarketplaceFallback', () => {
+    const { flags } = parseServeArgs(['my/model', '--no-expanded-search']);
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('noMarketplaceFallback defaults to falsy when not passed', () => {
+    const { flags } = parseServeArgs(['my/model']);
+    expect(flags.noMarketplaceFallback).toBeFalsy();
+  });
+
+  it('model is not consumed by --no-fallback flag', () => {
+    const { model, flags } = parseServeArgs(['my/model', '--no-fallback']);
+    expect(model).toBe('my/model');
+    expect(flags.noMarketplaceFallback).toBe(true);
+  });
+
+  it('parses --health-path flag', () => {
+    const { flags } = parseServeArgs(['my/model', '--health-path', '/system_stats']);
+    expect(flags.healthPath).toBe('/system_stats');
+  });
+
+  it('parses --health-path with arbitrary path', () => {
+    const { flags } = parseServeArgs(['--image', 'my/image:latest', '--health-path', '/health']);
+    expect(flags.healthPath).toBe('/health');
+  });
+
+  it('healthPath defaults to undefined when not passed', () => {
+    const { flags } = parseServeArgs(['my/model']);
+    expect(flags.healthPath).toBeUndefined();
+  });
 });
 
 describe('testCommand', () => {
@@ -238,6 +279,16 @@ describe('parseTestArgs', () => {
   });
 });
 
+describe('CapacityError', () => {
+  it('is an Error subclass', () => {
+    const err = new CapacityError('no capacity');
+    expect(err).toBeInstanceOf(Error);
+    expect(err.isCapacityError).toBe(true);
+    expect(err.name).toBe('CapacityError');
+    expect(err.message).toBe('no capacity');
+  });
+});
+
 describe('promptFallback output', () => {
   it('does not print a Difference line', async () => {
     const lines = [];