badgr-cli 1.0.12 → 1.0.15

package/src/commands/run.js

@@ -1,14 +1,13 @@
+import readline from 'readline';
 import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { rankAlternatives, promptFallback } from '../fallback.js';
 
 /**
- * badgr run python train.py --gpu A100           # attached (default)
+ * badgr run python train.py                    # gpu=auto, attached
+ * badgr run python train.py --gpu A100         # specific GPU
  * badgr run --image my/image:latest --gpu L40S --detach
- *
- * Attaches by default: polls status + streams logs until the job finishes,
- * then exits with the job's exit code. Pass --detach to return immediately.
  */
 export function parseRunArgs(args) {
   const flags = {};
@@ -38,26 +37,15 @@ function fmtRuntime(ms) {
   return `${m}m ${s % 60}s`;
 }
 
-// Polls above this count without a response while 'running' → heartbeat lost.
-const HEARTBEAT_WARN_POLLS  = 3;   // ~12s  → warn
-const HEARTBEAT_KILL_POLLS  = 15;  // ~60s  → treat as infrastructure failure
+const HEARTBEAT_WARN_POLLS  = 3;
+const HEARTBEAT_KILL_POLLS  = 15;
 
-/**
- * Classify a failure into 'customer_code' or 'infrastructure'.
- * customer_code: process ran and exited non-zero.
- * infrastructure: provider issue — job never completed normally.
- */
 export function classifyFailure(finalStatus, exitCode) {
   if (finalStatus === 'failed' && (exitCode === null || exitCode === undefined)) return 'infrastructure';
   if (exitCode !== null && exitCode !== undefined && exitCode !== 0) return 'customer_code';
   return null;
 }
 
-/**
- * Poll until terminal status, streaming new log lines.
- * Returns { status, exitCode, runtimeMs, failureType }.
- * Calls onTeardown(reason) when SIGINT, maxRuntime, maxCost, or heartbeat loss hits.
- */
 async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost = null, ratePerHour = 0, onTeardown }) {
   const TERMINAL = new Set(['stopped', 'failed', 'completed']);
   const POLL_MS  = 4000;
@@ -81,14 +69,12 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
       const elapsedMs  = Date.now() - startMs;
       const spentSoFar = ratePerHour * (elapsedMs / 3_600_000);
 
-      // Hard spend cap
       if (maxCost !== null && spentSoFar >= maxCost) {
         tearing = true;
         onTeardown('max-cost');
         return { status: 'timeout', exitCode: null, runtimeMs: elapsedMs, failureType: null };
       }
 
-      // Hard runtime cap
       if (maxRuntimeMs !== null && elapsedMs >= maxRuntimeMs) {
         tearing = true;
         onTeardown('max-runtime');
@@ -107,7 +93,7 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
         if (lastStatus === 'running') {
           const lostSec = Math.round((consecutiveErrs * POLL_MS) / 1000);
           if (consecutiveErrs === HEARTBEAT_WARN_POLLS) {
-            console.log(chalk.yellow(`\n  ⚠ No heartbeat for ${lostSec}s — Vast machine may be unresponsive`));
+            console.log(chalk.yellow(`\n  ⚠ No heartbeat for ${lostSec}s — cloud machine may be unresponsive`));
           } else if (consecutiveErrs >= HEARTBEAT_KILL_POLLS) {
             tearing = true;
             onTeardown('heartbeat-lost');
@@ -155,41 +141,103 @@ async function attachToJob(config, depId, { chalk, maxRuntimeMs = null, maxCost
   }
 }
 
+// Ask the backend for the cheapest available GPU right now.
+// Returns { gpu, region, price } or null when nothing is available.
+async function findAutoGpu(config, chalk) {
+  try {
+    const params = new URLSearchParams({ max_price: '10' });
+    return await callApi(`/capacity/auto?${params}`, {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+    });
+  } catch (err) {
+    if (err.errorData?.code === 'NO_CAPACITY_MATCH') return null;
+    throw err;
+  }
+}
+
+function askConfirm(prompt) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => rl.question(prompt, ans => { rl.close(); resolve(ans.trim()); }));
+}
+
 export async function runCommand(config, args, chalk) {
   const { flags, positional } = parseRunArgs(args);
 
   if (positional.length === 0 && !flags.image) {
-    console.error(chalk.red('Usage: badgr run <command...> --gpu <type>'));
-    console.error(chalk.red('       badgr run --image my/image:latest --gpu A100'));
+    console.error(chalk.red('Usage: badgr run <command...>'));
+    console.error(chalk.red('       badgr run --image my/image:latest'));
     return;
   }
 
   requireApiKey(config);
 
-  const command        = positional.length > 0 ? positional : undefined;
-  const gpu            = flags.gpu || 'RTX_4090';
-  const image          = flags.image || (command ? 'python:3.11-slim' : undefined);
-  const detach         = flags.detach || false;
-  const fallbackMode   = flags.noFallback ? 'none' : (flags.fallback || 'closest');
-  const maxRuntimeMs   = flags.maxRuntime ? flags.maxRuntime * 60 * 1000 : null;
-  const maxCost        = flags.maxCost ?? null;
-
-  console.log(chalk.bold('\n⚡ Running GPU job\n'));
-  if (command) console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
-  if (image)   console.log(`  ${chalk.bold('Image:')}    ${image}`);
-  console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
-  if (flags.maxRuntime) console.log(`  ${chalk.bold('Max runtime:')} ${flags.maxRuntime}min`);
-  if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
-  if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}   $${flags.maxPrice.toFixed(2)}/hr`);
-  if (detach)  console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
-  console.log();
+  const command      = positional.length > 0 ? positional : undefined;
+  const image        = flags.image || (command ? 'python:3.11-slim' : undefined);
+  const detach       = flags.detach || false;
+  const fallbackMode = flags.noFallback ? 'none' : (flags.fallback || 'closest');
+  const maxRuntimeMs = flags.maxRuntime ? flags.maxRuntime * 60 * 1000 : null;
+  const maxCost      = flags.maxCost ?? null;
+
+  // ── Auto GPU selection (no --gpu specified) ────────────────────────────────
+  let gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : null;
+  let autoRegion = null;
+
+  if (!gpu) {
+    console.log(chalk.bold('\n⚡ Running GPU job\n'));
+    if (command) console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
+    if (image)   console.log(`  ${chalk.bold('Image:')}    ${image}`);
+    console.log();
+    process.stdout.write(chalk.dim('  Finding GPU...'));
+
+    let best;
+    try {
+      best = await findAutoGpu(config, chalk);
+    } catch (err) {
+      process.stdout.write('\n');
+      console.error(chalk.red(`\n  ✗ Could not find GPU capacity: ${err.message}\n`));
+      process.exit(1);
+    }
 
-  // Safety guidance for jobs without a spend cap
-  if (!detach && !flags.maxRuntime && !maxCost) {
-    console.log(chalk.dim('  Tip: add --max-runtime 60 or --max-cost 5.00 to cap spend automatically'));
-  }
-  if (flags.maxRuntime > 60) {
-    console.log(chalk.yellow('  Note: jobs over 60min should checkpoint progress to recover from failures'));
+    process.stdout.write('\n');
+
+    if (!best) {
+      console.error(chalk.red('\n  ✗ No GPU capacity available right now.\n'));
+      console.error(chalk.dim('  Run `badgr capacity` for details, or try again in a few minutes.'));
+      process.exit(1);
+    }
+
+    console.log(`\n  ${chalk.bold('Best match:')} ${chalk.cyan(best.gpu)} in ${best.region} — ${chalk.green('$' + best.price.toFixed(2) + '/hr')} estimated`);
+    console.log();
+
+    if (process.stdin.isTTY) {
+      const answer = await askConfirm(`  Press ${chalk.bold('Enter')} to run, or ${chalk.bold('q')} to cancel: `);
+      if (answer.toLowerCase() === 'q') {
+        console.log(chalk.dim('\n  Cancelled.\n'));
+        process.exit(0);
+      }
+    } else {
+      console.log(chalk.dim(`  Auto-selecting ${best.gpu} (non-interactive).`));
+    }
+
+    gpu = best.gpu;
+    autoRegion = best.region;
+    console.log();
+  } else {
+    // Specific GPU requested — show header
+    console.log(chalk.bold('\n⚡ Running GPU job\n'));
+    if (command) console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
+    if (image)   console.log(`  ${chalk.bold('Image:')}    ${image}`);
+    console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
+    if (flags.maxRuntime) console.log(`  ${chalk.bold('Max runtime:')} ${flags.maxRuntime}min`);
+    if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
+    if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}   $${flags.maxPrice.toFixed(2)}/hr`);
+    if (detach)           console.log(`  ${chalk.dim('(detached — returns immediately)')}`);
+    console.log();
+
+    if (!detach && !flags.maxRuntime && !maxCost) {
+      console.log(chalk.dim('  Tip: add --max-runtime 60 or --max-cost 5.00 to cap spend automatically'));
+    }
   }
 
   console.log(chalk.dim('  Finding best available GPU capacity...'));
@@ -198,11 +246,13 @@ export async function runCommand(config, args, chalk) {
   }
 
   function buildBody(gpuOverride, regionOverride) {
-    const effectiveRegion = regionOverride ?? (flags.region ? flags.region.toUpperCase() : undefined);
+    const effectiveRegion = regionOverride
+      ?? autoRegion
+      ?? (flags.region ? flags.region.toUpperCase() : undefined);
     return {
       command,
       image,
-      gpu: (gpuOverride || gpu).toUpperCase().replace('-', '_'),
+      gpu: (gpuOverride || gpu),
       gpu_count: flags.count || 1,
       ...(effectiveRegion ? { region: effectiveRegion } : {}),
       max_price_per_hour: flags.maxPrice,
@@ -227,15 +277,14 @@ export async function runCommand(config, args, chalk) {
         process.exit(1);
       }
 
-      // Merge same-GPU-other-regions and cross-GPU alternatives into one ranked list.
       const pool = [
         ...(Array.isArray(d.same_gpu_other_regions) ? d.same_gpu_other_regions : []),
         ...(Array.isArray(d.alternatives)            ? d.alternatives            : []),
       ];
 
       if (pool.length === 0) {
-        console.error(chalk.red(`\n  ✗ ${gpu} isn't available right now and no alternatives found.\n`));
-        console.error(chalk.dim('  Try increasing --max-price or contact support for a manual quote.'));
+        console.error(chalk.red(`\n  ✗ ${gpu} isn't available right now and no alternatives were found.\n`));
+        console.error(chalk.dim('  Try `badgr capacity` to see what\'s available, or try again shortly.'));
         process.exit(1);
       }
 
@@ -247,7 +296,7 @@ export async function runCommand(config, args, chalk) {
         process.exit(0);
       }
 
-      console.log(chalk.dim(`\n  Running on ${chosen.gpu} in ${chosen.region}...\n`));
+      console.log(chalk.dim(`\n  Trying ${chosen.gpu} in ${chosen.region}...\n`));
 
       try {
         dep = await callApi('/run', {
@@ -259,19 +308,30 @@ export async function runCommand(config, args, chalk) {
       } catch (err2) {
         const d2 = err2.errorData;
         if (d2?.code === 'PROVISIONING_FAILED' || d2?.code === 'PROVIDER_ADAPTER_ERROR') {
-          console.error(chalk.red(`\n  ✗ Badgr found ${chosen.gpu} capacity, but the provider adapter failed during provisioning.`));
-          if (d2.message) console.error(chalk.dim(`  Detail: ${d2.message}`));
+          console.error(chalk.red(`\n  ✗ Badgr found ${chosen.gpu} capacity but could not start the machine. Please try again.\n`));
+          if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
+            if (d2?.debug_error) console.error(chalk.dim(`  Provider detail: ${d2.debug_error}`));
+          }
         } else {
-          console.error(chalk.red(`\n  ✗ Job failed to start on ${chosen.gpu}: ${err2.message}`));
+          console.error(chalk.red(`\n  ✗ Job failed to start on ${chosen.gpu}: ${err2.message}\n`));
+        }
+        if (!(process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true')) {
+          console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\n`));
         }
-        console.error(chalk.dim(`\n  Debug: BADGR_DEBUG=1 badgr run … — shows full request/response\n`));
         process.exit(1);
       }
+    } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
+      console.error(chalk.red(`\n  ✗ Badgr found ${gpu} capacity but could not start the machine. Please try again.\n`));
+      if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
+        if (d?.debug_error) console.error(chalk.dim(`  Provider detail: ${d.debug_error}`));
+      } else {
+        console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.\n`));
+      }
+      process.exit(1);
     } else {
-      console.error(chalk.red(`\n  ✗ Job failed to start: ${err.message}`));
-      console.error(chalk.dim(`\n  Debug: BADGR_DEBUG=1 badgr run … — shows full request/response`));
-      console.error(chalk.dim(`  Config:  badgr config`));
-      console.error(chalk.dim(`  Docs:    badgr --help\n`));
+      console.error(chalk.red(`\n  ✗ Could not start job: ${err.message}\n`));
+      console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr run … for a full trace.`));
+      console.error(chalk.dim(`  Check config: badgr config\n`));
       process.exit(1);
     }
   }
@@ -281,13 +341,13 @@ export async function runCommand(config, args, chalk) {
     receiptId:    rcptId,
     action:       'badgr run',
     deploymentId: dep.deployment_id,
-    provider:     dep.provider,
     gpu:          dep.gpu_type,
     status:       dep.status,
     createdAt:    new Date().toISOString(),
   });
 
-  console.log(chalk.bold(`\n  Job ID:    ${chalk.cyan(dep.deployment_id)}`));
+  console.log();
+  console.log(chalk.bold(`  Job ID:    ${chalk.cyan(dep.deployment_id)}`));
   console.log(`  ${chalk.bold('GPU:')}      ${dep.gpu_type} × ${dep.gpu_count}`);
   if (dep.cost_per_hour > 0) console.log(`  ${chalk.bold('Rate:')}     $${dep.cost_per_hour.toFixed(2)}/hr`);
   console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
@@ -298,16 +358,14 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
-  // ── Attached mode: stream logs until job completes ────────────────────────
   const ratePerHour = dep.cost_per_hour || 0;
-  console.log(chalk.dim('\n  ── Attaching (Ctrl+C tears down job) ─────────────────────────\n'));
+  console.log(chalk.dim('\n  ── Streaming logs (Ctrl+C to stop job) ─────────────────────────\n'));
 
-  // Teardown helper — called on SIGINT, max-runtime, max-cost, or heartbeat loss.
   async function teardown(reason) {
     const labels = {
       'max-runtime':    chalk.yellow('\n  ⏱ Max runtime reached — stopping job...'),
       'max-cost':       chalk.yellow('\n  💰 Spend cap reached — stopping job...'),
-      'heartbeat-lost': chalk.red('\n  ✗ Heartbeat lost — infrastructure failure, stopping job...'),
+      'heartbeat-lost': chalk.red('\n  ✗ No response from machine — stopping job...'),
       'interrupted':    chalk.yellow('\n  Stopping job...'),
     };
     console.log(labels[reason] ?? chalk.yellow('\n  Stopping job...'));
@@ -318,8 +376,7 @@ export async function runCommand(config, args, chalk) {
     }
     const runtimeMs = Date.now() - attachStart;
     const finalCost = ratePerHour * (runtimeMs / 3_600_000);
-    const failureType = reason === 'heartbeat-lost' ? 'infrastructure' : null;
-    updateReceipt(rcptId, { status: reason, runtimeSeconds: Math.round(runtimeMs / 1000), finalCost, failureType });
+    updateReceipt(rcptId, { status: reason, runtimeSeconds: Math.round(runtimeMs / 1000), finalCost });
     console.log(chalk.dim(`  Runtime: ${fmtRuntime(runtimeMs)}  •  Est. cost: $${finalCost.toFixed(4)}`));
     console.log(chalk.dim('  Job stopped. Billing ended.\n'));
     process.exit(reason === 'interrupted' ? 0 : 1);
@@ -345,7 +402,6 @@ export async function runCommand(config, args, chalk) {
     failureType,
   });
 
-  // ── Job summary ──────────────────────────────────────────────────────────
   console.log(`  ${chalk.bold('Runtime:')}  ${fmtRuntime(runtimeMs)}`);
   if (ratePerHour > 0) {
     console.log(`  ${chalk.bold('Cost:')}     $${finalCost.toFixed(4)}  (${chalk.dim(`$${ratePerHour.toFixed(2)}/hr`)})`);
@@ -353,18 +409,19 @@ export async function runCommand(config, args, chalk) {
   if (exitCode !== null && exitCode !== undefined) {
     console.log(`  ${chalk.bold('Exit code:')} ${exitCode !== 0 ? chalk.red(exitCode) : chalk.green(exitCode)}`);
   }
+  console.log(`  ${chalk.bold('Receipt:')}  ${chalk.dim(rcptId)}`);
 
   if (finalStatus === 'failed' || (exitCode !== null && exitCode !== 0)) {
-    const label = failureType === 'infrastructure'
-      ? chalk.red(`\n  ✗ Infrastructure failure (${dep.deployment_id}) — not your code\n`)
-      : chalk.red(`\n  ✗ Job failed (${dep.deployment_id})\n`);
-    console.error(label);
     if (failureType === 'infrastructure') {
-      console.error(chalk.dim('  This is a provider-side failure. Contact support with your receipt ID.'));
+      console.error(chalk.red(`\n  ✗ Machine failure — this is not your code.\n`));
+      console.error(chalk.dim('  Contact support with your receipt ID for a refund.'));
+    } else {
+      console.error(chalk.red(`\n  ✗ Job failed (exit ${exitCode ?? 'unknown'})\n`));
+      console.error(chalk.dim(`  Check logs: badgr logs ${dep.deployment_id}`));
     }
-    console.error(chalk.dim(`  Logs: badgr logs ${dep.deployment_id}\n`));
+    console.log();
     process.exit(exitCode ?? 1);
   } else {
-    console.log(chalk.green(`\n  ✓ Job complete\n`));
+    console.log(chalk.green(`\n  ✓ Complete\n`));
   }
 }

package/src/commands/serve.js

@@ -4,11 +4,10 @@ import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../
 import { rankAlternatives, promptFallback } from '../fallback.js';
 
 /**
+ * badgr serve meta-llama/Llama-3.1-8B-Instruct
  * badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
  *
- * Provisions a persistent vLLM endpoint, health-checks it before printing
- * "Endpoint ready", and returns an OpenAI-compatible base URL.
- * Stop billing with `badgr down <id>`.
+ * GPU defaults to "AUTO" — backend infers from model size.
  */
 export function parseServeArgs(args) {
   const flags = {};
@@ -27,24 +26,21 @@ export function parseServeArgs(args) {
   return { model, flags };
 }
 
-// Poll GET <endpointUrl>/models until it returns 200 or timeout expires.
-// Returns true if healthy, false if timed out.
 async function waitForEndpoint(endpointUrl, timeoutMs = 5 * 60 * 1000, chalk) {
   const deadline = Date.now() + timeoutMs;
-  const modelsUrl = `${endpointUrl}/models`;
   let attempt = 0;
 
   while (Date.now() < deadline) {
     attempt++;
     try {
-      const res = await fetch(modelsUrl, { signal: AbortSignal.timeout(8000) });
+      const res = await fetch(`${endpointUrl}/models`, { signal: AbortSignal.timeout(8000) });
       if (res.ok) return true;
     } catch {
-      // network not up yet — keep polling
+      // still starting
     }
     const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1000);
     process.stdout.write(
-      `\r  ${chalk.dim(`Waiting for endpoint… ${elapsed}s (attempt ${attempt})`)}   `
+      `\r  ${chalk.dim(`Health-checking /v1/models… ${elapsed}s`)}   `
     );
     await new Promise(r => setTimeout(r, 8000));
   }
@@ -56,40 +52,43 @@ export async function serveCommand(config, args, chalk) {
   const { model, flags } = parseServeArgs(args);
 
   if (!model) {
-    console.error(chalk.red('Usage: badgr serve <model> --gpu <type>'));
-    console.error(chalk.red('       badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S'));
+    console.error(chalk.red('Usage: badgr serve <model>'));
+    console.error(chalk.red('       badgr serve meta-llama/Llama-3.1-8B-Instruct'));
     return;
   }
 
   requireApiKey(config);
 
-  const gpu = flags.gpu || 'L40S';
+  // gpu=AUTO tells the backend to infer the right GPU from model size
+  const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : 'AUTO';
+  const gpuLabel = gpu === 'AUTO' ? 'auto' : gpu;
 
-  console.log(chalk.bold('\n🚀 Serving model\n'));
+  console.log(chalk.bold('\nServing model\n'));
   console.log(`  ${chalk.bold('Model:')}  ${model}`);
-  console.log(`  ${chalk.bold('GPU:')}    ${gpu}`);
+  console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
   console.log();
-  console.log(chalk.dim('  Finding best available GPU capacity...'));
-  if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
-    console.log(chalk.dim(`  API: ${config.baseUrl}`));
-  }
+  process.stdout.write(chalk.dim('  Finding GPU capacity...\n'));
 
   const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
 
+  function buildBody(gpuOverride, regionOverride) {
+    return {
+      model,
+      gpu: gpuOverride || gpu,
+      gpu_count: flags.count || 1,
+      ...(regionOverride || effectiveRegion ? { region: regionOverride || effectiveRegion } : {}),
+      max_price_per_hour: flags.maxPrice,
+      name: flags.name,
+    };
+  }
+
   let dep;
   try {
     dep = await callApi('/serve', {
       method: 'POST',
       apiKey: config.apiKey,
       baseUrl: config.baseUrl,
-      body: {
-        model,
-        gpu: gpu.toUpperCase().replace('-', '_'),
-        gpu_count: flags.count || 1,
-        ...(effectiveRegion ? { region: effectiveRegion } : {}),
-        max_price_per_hour: flags.maxPrice,
-        name: flags.name,
-      },
+      body: buildBody(),
     });
   } catch (err) {
     const d = err.errorData;
@@ -100,68 +99,60 @@ export async function serveCommand(config, args, chalk) {
       ];
 
       if (pool.length === 0) {
-        console.error(chalk.red(`\n  ✗ ${gpu} isn't available right now and no alternatives found.\n`));
-        console.error(chalk.dim('  Try increasing --max-price or contact support for a manual quote.'));
+        console.error(chalk.red(`\n  ✗ No GPU capacity available right now.\n`));
+        console.error(chalk.dim('  Run `badgr capacity` to see alternatives, or try again shortly.'));
         process.exit(1);
       }
 
-      const ranked = rankAlternatives(gpu, pool, 'closest');
-      const chosen = await promptFallback(gpu, ranked, chalk);
+      const ranked = rankAlternatives(gpuLabel, pool, 'closest');
+      const chosen = await promptFallback(gpuLabel, ranked, chalk);
 
       if (!chosen) {
         console.log(chalk.dim('\n  Cancelled.\n'));
         process.exit(0);
       }
 
-      console.log(chalk.dim(`\n  Serving on ${chosen.gpu} in ${chosen.region}...\n`));
+      console.log(chalk.dim(`\n  Trying ${chosen.gpu} in ${chosen.region}...\n`));
 
       try {
         dep = await callApi('/serve', {
           method: 'POST',
           apiKey: config.apiKey,
           baseUrl: config.baseUrl,
-          body: {
-            model,
-            gpu: chosen.gpu.toUpperCase().replace('-', '_'),
-            gpu_count: flags.count || 1,
-            region: chosen.region,
-            max_price_per_hour: flags.maxPrice,
-            name: flags.name,
-          },
+          body: buildBody(chosen.gpu, chosen.region),
         });
       } catch (err2) {
         const d2 = err2.errorData;
         if (d2?.code === 'PROVISIONING_FAILED' || d2?.code === 'PROVIDER_ADAPTER_ERROR') {
-          console.error(chalk.red(`\n  ✗ Badgr found ${chosen.gpu} capacity, but the provider adapter failed during provisioning.`));
-          if (d2.message) console.error(chalk.dim(`  Detail: ${d2.message}`));
+          console.error(chalk.red(`\n  ✗ Badgr found ${chosen.gpu} capacity but could not start the endpoint. Please try again.\n`));
         } else {
-          console.error(chalk.red(`\n  ✗ Serve failed on ${chosen.gpu}: ${err2.message}`));
+          console.error(chalk.red(`\n  ✗ Failed to start endpoint on ${chosen.gpu}: ${err2.message}\n`));
         }
-        console.error(chalk.dim(`\n  Debug: BADGR_DEBUG=1 badgr serve … — shows full request/response\n`));
+        console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
         process.exit(1);
       }
+    } else if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
+      console.error(chalk.red(`\n  ✗ Badgr found capacity but could not start the endpoint. Please try again.\n`));
+      console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
+      process.exit(1);
     } else {
-      // Write a failure receipt so every serve attempt is auditable.
       const failRcptId = generateReceiptId();
       addReceipt({
         receiptId:   failRcptId,
         action:      'badgr serve',
         model,
-        gpu,
+        gpu: gpuLabel,
         status:      'failed',
         failureType: 'infrastructure',
         createdAt:   new Date().toISOString(),
       });
-      console.error(chalk.red(`\n  ✗ Serve failed: ${err.message}`));
+      console.error(chalk.red(`\n  ✗ Could not start endpoint: ${err.message}`));
       console.error(chalk.dim(`\n  Receipt: ${failRcptId}`));
-      console.error(chalk.dim(`  Debug: BADGR_DEBUG=1 badgr serve … — shows full request/response`));
-      console.error(chalk.dim(`  Config:  badgr config`));
-      console.error(chalk.dim(`  Docs:    badgr --help\n`));
+      console.error(chalk.dim(`  Run BADGR_DEBUG=1 badgr serve … for a full trace.\n`));
       return;
     }
   }
 
-  // Mirror to local store so badgr down/status/receipts work offline
   addDeployment({
     id:          dep.deployment_id,
     name:        dep.name,
@@ -169,7 +160,6 @@ export async function serveCommand(config, args, chalk) {
     model:       dep.model || model,
     gpu:         dep.gpu_type,
     count:       dep.gpu_count,
-    provider:    dep.provider,
     status:      dep.status,
     endpointUrl: dep.endpoint_url || dep.openai_base_url,
     receiptId:   dep.receipt_id,
@@ -182,7 +172,6 @@ export async function serveCommand(config, args, chalk) {
     receiptId:    rcptId,
     action:       'badgr serve',
     deploymentId: dep.deployment_id,
-    provider:     dep.provider,
     gpu:          dep.gpu_type,
     status:       dep.status,
     createdAt:    new Date().toISOString(),
@@ -190,48 +179,41 @@ export async function serveCommand(config, args, chalk) {
 
   const endpointUrl = dep.endpoint_url || dep.openai_base_url || config.baseUrl;
 
-  // ── Health check before declaring "ready" ─────────────────────────────────
+  // ── Health check ──────────────────────────────────────────────────────────
   let endpointReady = false;
-
   if (flags.noWait) {
-    console.log(chalk.yellow('\n⏳ Skipped health check (--no-wait)\n'));
+    console.log(chalk.yellow('\n  Skipped health check (--no-wait)\n'));
   } else {
-    console.log(chalk.dim('\n  Health-checking endpoint (up to 5 min)...'));
     endpointReady = await waitForEndpoint(endpointUrl, 5 * 60 * 1000, chalk);
     process.stdout.write('\n');
-    if (!endpointReady) {
-      updateReceipt(rcptId, { status: 'health_check_timeout' });
-    }
+    if (!endpointReady) updateReceipt(rcptId, { status: 'health_check_timeout' });
   }
 
-  // ── Print result ──────────────────────────────────────────────────────────
+  // ── Result ────────────────────────────────────────────────────────────────
   if (endpointReady) {
-    console.log(chalk.green('✓ Endpoint ready\n'));
+    console.log(chalk.green('\n✓ Endpoint ready\n'));
   } else {
-    console.log(chalk.yellow('⏳ Endpoint still starting (health check timed out)\n'));
-    console.log(chalk.dim('  The deployment was provisioned but did not respond within 5 minutes.'));
-    console.log(chalk.dim('  It may still be loading the model. Check:'));
-    console.log(chalk.dim(`    badgr status`));
-    console.log(chalk.dim(`    badgr logs ${dep.deployment_id}`));
-    console.log(chalk.dim(`    curl ${endpointUrl}/models`));
-    console.log(chalk.dim(`  If it never starts, run: badgr down ${dep.deployment_id}`));
+    console.log(chalk.yellow('\n⏳ Endpoint still starting\n'));
+    console.log(chalk.dim('  The deployment is provisioned but not yet responding.'));
+    console.log(chalk.dim(`  Check: badgr logs ${dep.deployment_id}`));
+    console.log(chalk.dim(`  Stop if it never starts: badgr down ${dep.deployment_id}`));
     console.log();
   }
 
-  console.log(`  ${chalk.bold('Deployment:')} ${chalk.cyan(dep.deployment_id)}`);
+  console.log(`  ${chalk.bold('Base URL:')}   ${chalk.cyan(endpointUrl)}`);
   console.log(`  ${chalk.bold('Model:')}      ${dep.model || model}`);
   console.log(`  ${chalk.bold('GPU:')}        ${dep.gpu_type} × ${dep.gpu_count}`);
-  console.log(`  ${chalk.bold('Endpoint:')}   ${chalk.cyan(endpointUrl)}`);
   if (dep.cost_per_hour > 0) console.log(`  ${chalk.bold('Rate:')}       $${dep.cost_per_hour.toFixed(2)}/hr`);
   console.log(`  ${chalk.bold('Logs:')}       ${chalk.dim(`badgr logs ${dep.deployment_id}`)}`);
-  console.log(`\n  ${chalk.bold('Receipt:')}    ${chalk.dim(rcptId)}`);
+  console.log(`  ${chalk.bold('Stop billing:')} ${chalk.dim(`badgr down ${dep.deployment_id}`)}`);
+  console.log();
 
   if (endpointReady) {
-    console.log(`\n  ${chalk.bold('Use with OpenAI SDK:')}`);
+    const keySnip = config.apiKey?.slice(0, 8) || 'sk-...';
+    console.log(`  ${chalk.bold('Use with OpenAI SDK:')}`);
     console.log(chalk.dim(`    from openai import OpenAI`));
-    console.log(chalk.dim(`    client = OpenAI(api_key="${config.apiKey?.slice(0, 8) || 'sk-...'}...", base_url="${endpointUrl}")`));
+    console.log(chalk.dim(`    client = OpenAI(base_url="${endpointUrl}", api_key="${keySnip}...")`));
     console.log(chalk.dim(`    resp = client.chat.completions.create(model="${dep.model || model}", messages=[...])`));
+    console.log();
   }
-
-  console.log(`\n  ${chalk.dim(`Stop billing: badgr down ${dep.deployment_id}`)}\n`);
 }