badgr-cli 1.0.37 → 1.0.39

package/src/commands/run.js

@@ -3,6 +3,7 @@ import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
+import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
 
 /**
  * badgr run python train.py                    # gpu=auto, attached
@@ -13,32 +14,42 @@ import { formatCliError } from '../errors.js';
 export function parseRunArgs(args) {
   const flags = {};
   const positional = [];
+
+  // Split at -- so badgr flags and the user command don't collide.
+  // Everything before -- is parsed for flags; everything after becomes commandArgv.
+  const sepIdx = args.indexOf('--');
+  const flagArgs = sepIdx === -1 ? args : args.slice(0, sepIdx);
+  const commandArgv = sepIdx === -1 ? null : args.slice(sepIdx + 1);
+
   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] === '--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; }
-    if (args[i] === '--max-price')      { flags.maxPrice = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--name')           { flags.name = args[++i]; i++; continue; }
-    if (args[i] === '--detach')          { flags.detach = true; i++; continue; }
-    if (args[i] === '--fallback')           { flags.fallback = args[++i]; i++; continue; }
-    if (args[i] === '--no-fallback')        { flags.noFallback = true; i++; continue; }
-    if (args[i] === '--strict-capacity')    { flags.noFallback = true; i++; continue; }
-    if (args[i] === '--no-expanded-search') { flags.noFallback = true; i++; continue; }
-    if (args[i] === '--max-runtime')     { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--max-cost')        { flags.maxCost = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--min-vram')        { flags.minVram = parseFloat(args[++i]); i++; continue; }
-    if (args[i] === '--env') {
-      const kv = args[++i]; i++;
+  while (i < flagArgs.length) {
+    if (flagArgs[i] === '--gpu')            { flags.gpu = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--image')          { flags.image = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--count')          { flags.count = parseInt(flagArgs[++i], 10); i++; continue; }
+    if (flagArgs[i] === '--region')         { flags.region = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--tier')           { flags.tier = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--max-price')      { flags.maxPrice = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--name')           { flags.name = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--detach')          { flags.detach = true; i++; continue; }
+    if (flagArgs[i] === '--fallback')           { flags.fallback = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--no-fallback')        { flags.noFallback = true; i++; continue; }
+    if (flagArgs[i] === '--strict-capacity')    { flags.noFallback = true; i++; continue; }
+    if (flagArgs[i] === '--no-expanded-search') { flags.noFallback = true; i++; continue; }
+    if (flagArgs[i] === '--max-runtime')     { flags.maxRuntime = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--max-cost')        { flags.maxCost = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--min-vram')        { flags.minVram = parseFloat(flagArgs[++i]); i++; continue; }
+    if (flagArgs[i] === '--dry-run')         { flags.dryRun = true; i++; continue; }
+    if (flagArgs[i] === '--save')            { flags.save = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--workspace')       { flags.workspace = flagArgs[++i]; i++; continue; }
+    if (flagArgs[i] === '--env') {
+      const kv = flagArgs[++i]; i++;
       if (!flags.env) flags.env = [];
       flags.env.push(kv);
       continue;
     }
-    positional.push(args[i++]);
+    positional.push(flagArgs[i++]);
   }
-  return { flags, positional };
+  return { flags, positional, commandArgv };
 }
 
 function parseEnvFlag(envList) {
@@ -331,10 +342,33 @@ const _KNOWN_RUN_FLAGS = new Set([
   '--gpu', '--image', '--count', '--region', '--tier', '--max-price', '--name',
   '--detach', '--fallback', '--no-fallback', '--strict-capacity',
   '--no-expanded-search', '--max-runtime', '--max-cost', '--min-vram', '--env',
+  '--dry-run',
 ]);
 
 export async function runCommand(config, args, chalk) {
-  const { flags, positional } = parseRunArgs(args);
+  // `badgr run template <name> [flags]` — expand template defaults then re-dispatch
+  if (args[0] === 'template') {
+    const name = args[1];
+    const t = name && TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name || '(none)'}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    if (t.type !== 'job') {
+      console.error(chalk.red(`\n  "${name}" is an endpoint template — use: badgr serve template ${name}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const overrides = parseTemplateOverrides(args.slice(2));
+    const expandedArgs = buildTemplateFlags(t, overrides);
+    if (overrides.maxRuntime != null) expandedArgs.push('--max-runtime', String(overrides.maxRuntime));
+    console.log(chalk.dim(`  Template: ${t.title}  →  badgr run ${expandedArgs.join(' ')}\n`));
+    return runCommand(config, expandedArgs, chalk);
+  }
+
+  const { flags, positional, commandArgv } = parseRunArgs(args);
 
   // Detect flags that ended up in the command because of broken shell line continuation
   // (e.g. `\ ` with trailing space instead of `\<newline>`).
@@ -353,12 +387,17 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
-  if (positional.length === 0 && !flags.image) {
-    console.error(chalk.red('Usage: badgr run <command...>'));
+  if (positional.length === 0 && commandArgv === null && !flags.image) {
+    console.error(chalk.red('Usage: badgr run --gpu <GPU> --image <image> --max-cost <n> -- <command...>'));
     console.error(chalk.red('       badgr run --image my/image:latest'));
     return;
   }
-
+  if (commandArgv !== null && commandArgv.length === 0 && !flags.image) {
+    console.error(chalk.red('  ✗ No command after --. Provide a command or --image.'));
+    console.error(chalk.dim('  Example: badgr run --gpu RTX_4090 --max-cost 1 -- node script.js'));
+    process.exitCode = 1;
+    return;
+  }
   requireApiKey(config);
 
   // ── Validate flags early ───────────────────────────────────────────────────
@@ -382,7 +421,18 @@ export async function runCommand(config, args, chalk) {
     process.exitCode = 1;
     return;
   }
-  const command      = positional.length > 0 ? positional : undefined;
+
+  if (!flags.maxCost && !flags.dryRun) {
+    console.error(chalk.red('\n  ✗ --max-cost is required for run workloads.\n'));
+    console.error(chalk.dim('  Example: badgr run --gpu RTX_4090 --image node:20 --max-cost 5 -- node script.js\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  // commandArgv is set when -- separator was used; fall back to positional for legacy syntax.
+  const command = commandArgv !== null
+    ? (commandArgv.length > 0 ? commandArgv : undefined)
+    : (positional.length > 0 ? positional : undefined);
   const cmdStr = command ? command.join(' ') : '';
   const isSmoke = cmdStr.length < 80 && /print\s*\(|['"]hello/i.test(cmdStr);
   const inferredImage = isSmoke ? 'python:3.11-alpine' : 'python:3.11-slim';
@@ -401,6 +451,19 @@ export async function runCommand(config, args, chalk) {
 
   const gpu = flags.gpu ? flags.gpu.toUpperCase().replace('-', '_') : undefined;
 
+  if (flags.dryRun) {
+    console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    if (command)          console.log(`  ${chalk.bold('Command:')}      ${command.join(' ')}`);
+    if (image)            console.log(`  ${chalk.bold('Image:')}        ${image}`);
+    console.log(`  ${chalk.bold('GPU:')}          ${gpu || chalk.dim('auto')}`);
+    console.log(`  ${chalk.bold('Max runtime:')}  ${effectiveMaxRuntime}min`);
+    if (maxCost)          console.log(`  ${chalk.bold('Max cost:')}     $${maxCost}`);
+    if (flags.maxPrice)   console.log(`  ${chalk.bold('Max price:')}    $${flags.maxPrice}/hr`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}         ${flags.env.join(', ')}`);
+    console.log(chalk.dim('\n  Remove --dry-run to provision.\n'));
+    return;
+  }
+
   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}`);
@@ -418,6 +481,23 @@ export async function runCommand(config, args, chalk) {
   console.log();
 
 
+  // Resolve --workspace name → ws_… ID before submitting
+  let resolvedWorkspaceId = flags.workspace ?? null;
+  if (resolvedWorkspaceId && !resolvedWorkspaceId.startsWith('ws_')) {
+    try {
+      const wsData = await callApi(`/workspaces?limit=100`, { apiKey: config.apiKey, baseUrl: config.baseUrl });
+      const match = (wsData?.workspaces ?? []).find(w => w.name === resolvedWorkspaceId);
+      if (!match) {
+        console.error(chalk.red(`Workspace not found: ${resolvedWorkspaceId}`));
+        process.exitCode = 1; return;
+      }
+      resolvedWorkspaceId = match.workspace_id;
+    } catch (err) {
+      console.error(chalk.red(`Could not resolve workspace: ${err.message}`));
+      process.exitCode = 1; return;
+    }
+  }
+
   console.log(chalk.dim('  Finding suitable capacity...'));
   if (process.env.BADGR_DEBUG === '1' || process.env.BADGR_DEBUG === 'true') {
     console.log(chalk.dim(`  API: ${config.baseUrl}`));
@@ -438,6 +518,7 @@ export async function runCommand(config, args, chalk) {
       ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
       max_runtime_seconds: effectiveMaxRuntime * 60,
       ...(maxCost ? { max_cost_usd: maxCost } : {}),
+      ...(resolvedWorkspaceId ? { workspace_id: resolvedWorkspaceId } : {}),
     };
   }
 
@@ -628,6 +709,34 @@ export async function runCommand(config, args, chalk) {
     } catch { /* already stopped */ }
     console.log(chalk.green(`\n  ✓ Complete`));
     console.log(chalk.dim(`  Billing ended`));
+
+    if (flags.save && config.apiKey) {
+      try {
+        const saved = await callApi('/workloads', {
+          method: 'POST',
+          apiKey: config.apiKey,
+          baseUrl: config.baseUrl,
+          body: {
+            name: flags.save,
+            job_type: 'custom.run',
+            config: {
+              command: command || [],
+              image: image || 'python:3.11-slim',
+              gpu: gpu || 'auto',
+              ...(flags.minVram ? { min_vram: flags.minVram } : {}),
+              gpu_count: flags.count || 1,
+              ...(flags.maxPrice ? { max_price_per_hour: flags.maxPrice } : {}),
+              ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
+            },
+            default_max_cost: maxCost || 10.0,
+            default_max_runtime_minutes: effectiveMaxRuntime,
+          },
+        });
+        console.log(chalk.cyan(`  Saved as workload: ${saved.name} (${saved.workload_id})`));
+      } catch (err) {
+        console.log(chalk.yellow(`  Could not save workload: ${err.message}`));
+      }
+    }
     console.log();
   }
 }

package/src/commands/serve.js

@@ -3,12 +3,16 @@ import { callApi, listDeployments } from '../api.js';
 import { addDeployment, addReceipt, updateReceipt, generateReceiptId } from '../store.js';
 import { normalizeTier, callWithFallback, HIGH_RATE_THRESHOLD } from '../fallback.js';
 import { formatCliError } from '../errors.js';
+import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
+
+const LLAMA_CPP_IMAGE = 'michaelmanleyx/llama-cpp:server-cuda';
 
 /**
  * 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
+ * badgr serve --runtime llama.cpp --hf-repo org/repo --hf-file model.gguf --max-cost 10
  *
  * GPU defaults to "AUTO" — backend infers from model size.
  */
@@ -35,6 +39,9 @@ export function parseServeArgs(args) {
         args[i] === '--no-expanded-search') { flags.noMarketplaceFallback = true; i++; continue; }
     if (args[i] === '--persistent')          { flags.persistent = true; i++; continue; }
     if (args[i] === '--yes' || args[i] === '-y') { flags.yes = true; i++; continue; }
+    if (args[i] === '--runtime')  { flags.runtime = args[++i]; i++; continue; }
+    if (args[i] === '--hf-repo') { flags.hfRepo = args[++i]; i++; continue; }
+    if (args[i] === '--hf-file') { flags.hfFile = args[++i]; i++; continue; }
     if (args[i] === '--env') {
       const kv = args[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -73,12 +80,34 @@ function _inferServeProfile(modelName) {
   return                      { label: 'inference (70B+ model)',    vram: '80+ GB', gpus: ['H100', 'A100'] };
 }
 
+// Mirror of backend workload_profile.py infer_profile_from_gguf.
+// Accepts the --hf-file filename; looks for param-count hints like "35B" or "8x7B".
+function _inferGgufProfile(ggufPath) {
+  const s = ggufPath.toLowerCase();
+  const moe = s.match(/(\d+)x(\d+)b/);
+  let paramsB;
+  if (moe) {
+    paramsB = parseInt(moe[1]) * parseInt(moe[2]);
+  } else {
+    const m = s.match(/(\d+)b/);
+    paramsB = m ? parseInt(m[1]) : null;
+  }
+  if (paramsB === null || paramsB <= 9) return { label: 'GGUF inference (≤9B, llama.cpp)',      vram: '8+ GB',  gpus: ['RTX 4090', 'RTX 3090', 'A6000'] };
+  if (paramsB <= 35)                   return { label: 'GGUF inference (10B–35B, llama.cpp)',   vram: '24+ GB', gpus: ['RTX 4090', 'A6000', 'L40S'] };
+  return                                      { label: 'GGUF inference (36B+, llama.cpp)',      vram: '48+ GB', gpus: ['A6000', 'L40S', 'A100'] };
+}
+
 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 (healthPath === '/health') {
+    if (elapsedSec < 60)  return 'Starting llama-server…';
+    if (elapsedSec < 180) return 'Downloading from Hugging Face…';
+    return 'Waiting for /health…';
+  }
   if (elapsedSec < 30)  return 'Starting container…';
   if (elapsedSec < 120) return 'Container starting…';
   return `Waiting for ${healthPath}…`;
@@ -86,7 +115,9 @@ function _serveStageLabel(elapsedSec, healthPath = '/models') {
 
 function _detectHealthPath(image) {
   if (!image) return null;
-  return image.toLowerCase().includes('comfyui') ? '/system_stats' : null;
+  if (image.toLowerCase().includes('comfyui')) return '/system_stats';
+  if (image.toLowerCase().includes('llama.cpp')) return '/health';
+  return null;
 }
 
 /**
@@ -161,12 +192,34 @@ const _KNOWN_SERVE_FLAGS = new Set([
   '--gpu', '--image', '--task', '--count', '--region', '--tier', '--max-price',
   '--name', '--no-wait', '--max-cost', '--health-path', '--check-nodes',
   '--no-fallback', '--strict-capacity', '--no-expanded-search', '--env',
-  '--persistent', '--yes', '-y',
+  '--persistent', '--yes', '-y', '--runtime', '--hf-repo', '--hf-file',
 ]);
 
 export async function serveCommand(config, args, chalk) {
+  // `badgr serve template <name> [flags]` — expand template defaults then re-dispatch
+  if (args[0] === 'template') {
+    const name = args[1];
+    const t = name && TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name || '(none)'}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    if (t.type !== 'endpoint') {
+      console.error(chalk.red(`\n  "${name}" is a job template — use: badgr run template ${name}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const overrides = parseTemplateOverrides(args.slice(2));
+    const expandedArgs = buildTemplateFlags(t, overrides);
+    console.log(chalk.dim(`  Template: ${t.title}  →  badgr serve ${expandedArgs.join(' ')}\n`));
+    return serveCommand(config, expandedArgs, chalk);
+  }
+
   const { model, flags } = parseServeArgs(args);
   const customImage = flags.image || null;
+  const isLlamaCpp = flags.runtime === 'llama.cpp';
 
   // Detect flags that ended up as positional args due to broken shell line continuation
   // (e.g. `\ ` with a trailing space instead of `\<newline>`).
@@ -188,10 +241,22 @@ export async function serveCommand(config, args, chalk) {
     return;
   }
 
-  if (!model && !customImage) {
+  if (isLlamaCpp && (!flags.hfRepo || !flags.hfFile)) {
+    console.error(chalk.red('\n  ✗ --runtime llama.cpp requires --hf-repo and --hf-file\n'));
+    console.error(chalk.dim('  Example:'));
+    console.error(chalk.dim('    badgr serve --runtime llama.cpp \\'));
+    console.error(chalk.dim('      --hf-repo org/model-repo \\'));
+    console.error(chalk.dim('      --hf-file model.gguf \\'));
+    console.error(chalk.dim('      --max-cost 10\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!model && !customImage && !isLlamaCpp) {
     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'));
+    console.error(chalk.red('       badgr serve --runtime llama.cpp --hf-repo org/repo --hf-file model.gguf'));
     return;
   }
 
@@ -233,7 +298,20 @@ export async function serveCommand(config, args, chalk) {
 
   const effectiveTier = normalizeTier(flags.tier);
 
-  if (customImage) {
+  if (isLlamaCpp) {
+    console.log(chalk.bold('\n⚡ Serving HF GGUF (llama.cpp)\n'));
+    console.log(`  ${chalk.bold('HF Repo:')}  ${flags.hfRepo}`);
+    console.log(`  ${chalk.bold('HF File:')}  ${flags.hfFile}`);
+    console.log(`  ${chalk.bold('Runtime:')}  llama.cpp`);
+    console.log(`  ${chalk.bold('GPU:')}      ${gpuLabel}`);
+    if (flags.env?.length) console.log(`  ${chalk.bold('Env:')}      ${flags.env.join(', ')}`);
+    if (gpu === 'AUTO') {
+      const prof = _inferGgufProfile(flags.hfFile);
+      console.log();
+      console.log(`  ${chalk.bold('Estimated workload:')}      ${prof.label}`);
+      console.log(`  ${chalk.bold('Estimated minimum VRAM:')}  ${prof.vram}`);
+    }
+  } else if (customImage) {
     console.log(chalk.bold('\n⚡ Serving custom container\n'));
     console.log(`  ${chalk.bold('Image:')}  ${customImage}`);
     console.log(`  ${chalk.bold('GPU:')}    ${gpuLabel}`);
@@ -271,7 +349,9 @@ export async function serveCommand(config, args, chalk) {
         d.workload_type === 'endpoint' &&
         (
           (model && d.model === model) ||
-          (customImage && d.image === customImage)
+          (customImage && d.image === customImage) ||
+          (isLlamaCpp && d.image === LLAMA_CPP_IMAGE &&
+           d.env?.LLAMA_ARG_HF_REPO === flags.hfRepo && d.env?.LLAMA_ARG_HF_FILE === flags.hfFile)
         )
       );
       if (duplicate) {
@@ -297,9 +377,12 @@ export async function serveCommand(config, args, chalk) {
   const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
 
   function buildBody(gpuOverride, tierOverride) {
+    const effectiveEnv = isLlamaCpp
+      ? { LLAMA_ARG_HF_REPO: flags.hfRepo, LLAMA_ARG_HF_FILE: flags.hfFile, ...envObj }
+      : envObj;
     return {
       ...(model ? { model } : {}),
-      ...(customImage ? { image: customImage } : {}),
+      ...(isLlamaCpp ? { image: LLAMA_CPP_IMAGE } : customImage ? { image: customImage } : {}),
       ...(flags.task ? { task: flags.task } : {}),
       gpu: gpuOverride || gpu,
       gpu_count: flags.count || 1,
@@ -307,7 +390,7 @@ export async function serveCommand(config, args, chalk) {
       max_price_per_hour: flags.maxPrice,
       name: flags.name,
       tier: tierOverride || effectiveTier,
-      ...(Object.keys(envObj).length > 0 ? { env: envObj } : {}),
+      ...(Object.keys(effectiveEnv).length > 0 ? { env: effectiveEnv } : {}),
       ...(flags.maxCost ? { max_cost_usd: flags.maxCost } : {}),
     };
   }
@@ -378,10 +461,12 @@ export async function serveCommand(config, args, chalk) {
   }
 
   // ── Determine health check path ───────────────────────────────────────────
-  // Priority: explicit --health-path > auto-detect comfyui > /models for vLLM > null (skip)
+  // Priority: explicit --health-path > llama.cpp → /health > vLLM → /models > auto-detect custom image > null
   let resolvedHealthPath;
   if (flags.healthPath) {
     resolvedHealthPath = flags.healthPath;
+  } else if (isLlamaCpp) {
+    resolvedHealthPath = '/health';
   } else if (!customImage) {
     resolvedHealthPath = '/models';
   } else {
@@ -462,7 +547,11 @@ export async function serveCommand(config, args, chalk) {
   const serveRate = dep.cost_per_hour || 0;
 
   console.log(`  ${chalk.bold('Base URL:')}     ${chalk.cyan(endpointUrl)}`);
-  if (dep.model || model) console.log(`  ${chalk.bold('Model:')}        ${dep.model || model}`);
+  if (isLlamaCpp) {
+    console.log(`  ${chalk.bold('HF Repo:')}      ${flags.hfRepo}`);
+    console.log(`  ${chalk.bold('HF File:')}      ${flags.hfFile}`);
+  }
+  else 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`);
@@ -480,10 +569,11 @@ export async function serveCommand(config, args, chalk) {
 
   if (endpointReady && !customImage) {
     const keySnip = config.apiKey?.slice(0, 4) || 'sk-...';
+    const sdkModel = isLlamaCpp ? 'default' : (dep.model || model);
     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}...")`));
-    console.log(chalk.dim(`    resp = client.chat.completions.create(model="${dep.model || model}", messages=[...])`));
+    console.log(chalk.dim(`    resp = client.chat.completions.create(model="${sdkModel}", messages=[...])`));
     console.log();
   }
 }

package/src/commands/template.js

@@ -0,0 +1,119 @@
+/**
+ * badgr template list
+ * badgr template info <name>
+ *
+ * Provider-neutral workload templates for common ML frameworks.
+ * Launching routes through `badgr serve template <name>` / `badgr run template <name>`.
+ */
+import { TEMPLATES, TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
+import { serveCommand } from './serve.js';
+import { runCommand }   from './run.js';
+
+// Re-export for tests
+export { TEMPLATES };
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function col(s, w) {
+  return String(s ?? '').padEnd(w).slice(0, w);
+}
+
+function printList(chalk) {
+  console.log(chalk.bold('\nAvailable templates\n'));
+  console.log(`  ${'NAME'.padEnd(18)}  ${'TYPE'.padEnd(8)}  ${'GPU'.padEnd(10)}  DESCRIPTION`);
+  console.log(`  ${'─'.repeat(18)}  ${'─'.repeat(8)}  ${'─'.repeat(10)}  ${'─'.repeat(44)}`);
+  for (const t of TEMPLATES) {
+    const type = t.type === 'endpoint' ? chalk.cyan(col(t.type, 8)) : chalk.yellow(col(t.type, 8));
+    console.log(`  ${chalk.bold(col(t.name, 18))}  ${type}  ${col(t.gpu, 10)}  ${t.description}`);
+  }
+  console.log();
+  console.log(chalk.dim('  badgr template info <name>               Show full template details'));
+  console.log(chalk.dim('  badgr serve template <name> [flags]      Launch an endpoint template'));
+  console.log(chalk.dim('  badgr run   template <name> [flags]      Launch a job template'));
+  console.log();
+}
+
+function printInfo(t, chalk) {
+  console.log(chalk.bold(`\n${t.title}\n`));
+  console.log(`  ${chalk.bold('Name:')}         ${t.name}`);
+  console.log(`  ${chalk.bold('Description:')} ${t.description}`);
+  console.log(`  ${chalk.bold('Type:')}         ${t.type}`);
+  console.log(`  ${chalk.bold('Image:')}        ${t.image}`);
+  console.log(`  ${chalk.bold('GPU:')}          ${t.gpu} × ${t.gpu_count}  (${t.min_vram_gb}+ GB VRAM)`);
+  if (t.port)        console.log(`  ${chalk.bold('Port:')}         ${t.port}`);
+  if (t.health_path) console.log(`  ${chalk.bold('Health:')}       ${t.health_path}`);
+  if (t.env && Object.keys(t.env).length > 0) {
+    console.log(`  ${chalk.bold('Env defaults:')}`);
+    for (const [k, v] of Object.entries(t.env)) {
+      console.log(`    ${chalk.cyan(k)}=${chalk.dim(v)}`);
+    }
+  }
+  if (t.command) {
+    console.log(`  ${chalk.bold('Command:')}      ${t.command.join(' ')}`);
+  }
+  if (t.notes?.length) {
+    console.log(`\n  ${chalk.bold('Notes:')}`);
+    for (const n of t.notes) console.log(`    ${chalk.dim(n)}`);
+  }
+  console.log();
+  const verb = t.type === 'job' ? 'run' : 'serve';
+  console.log(`  ${chalk.bold('Launch:')}`);
+  console.log(chalk.dim(`    badgr ${verb} template ${t.name} --max-cost <N>`));
+  console.log();
+}
+
+// ── Main command ───────────────────────────────────────────────────────────────
+
+export async function templateCommand(config, args, chalk) {
+  const [sub, name, ...rest] = args;
+
+  if (!sub || sub === 'list' || sub === '--help' || sub === '-h') {
+    printList(chalk);
+    return;
+  }
+
+  if (sub === 'info') {
+    if (!name) {
+      console.error(chalk.red('  Usage: badgr template info <name>\n'));
+      printList(chalk);
+      process.exitCode = 1;
+      return;
+    }
+    const t = TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    printInfo(t, chalk);
+    return;
+  }
+
+  // `badgr template run <name>` — kept as a convenience alias
+  if (sub === 'run') {
+    if (!name) {
+      console.error(chalk.red('  Usage: badgr template run <name> [--max-cost N] [--env K=V]\n'));
+      printList(chalk);
+      process.exitCode = 1;
+      return;
+    }
+    const t = TEMPLATE_MAP[name];
+    if (!t) {
+      console.error(chalk.red(`\n  Unknown template: ${name}\n`));
+      console.error(chalk.dim('  Run `badgr template list` to see available templates.'));
+      process.exitCode = 1;
+      return;
+    }
+    const overrides = parseTemplateOverrides(rest);
+    const flags = buildTemplateFlags(t, overrides);
+    console.log(chalk.dim(`  Template: ${t.title}  →  badgr ${t.type === 'job' ? 'run' : 'serve'} ${flags.join(' ')}\n`));
+    return t.type === 'job'
+      ? runCommand(config, flags, chalk)
+      : serveCommand(config, flags, chalk);
+  }
+
+  console.error(chalk.red(`\n  Unknown subcommand: badgr template ${sub}\n`));
+  console.error(chalk.dim('  Subcommands: list, info <name>'));
+  process.exitCode = 1;
+}

package/src/commands/test-run.js

@@ -2,7 +2,7 @@ import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, generateReceiptId } from '../store.js';
 
-// max $0.80/hr × 2 min ≈ $0.027 total spend cap (smoke / Modal T4 tier)
+// max $0.80/hr × 2 min ≈ $0.027 total spend cap
 const TEST_MAX_PRICE  = 0.80;
 const TEST_MAX_RUNTIME_MS = 2 * 60 * 1000;
 const TEST_COMMAND    = ['python', '-c', "print('hello from badgr')"];
@@ -12,8 +12,8 @@ const TEST_IMAGE      = 'python:3.11-alpine';
 const EXPECTED_OUTPUT = 'hello from badgr';
 
 // --provider flag resolves to a backend tier value.
-// 'tier1' → managed routing (default), 'tier2' → marketplace routing, 'secondary' → secondary dispatch.
-const PROVIDER_TO_TIER = { tier1: '1', tier2: '2', secondary: 'modal' };
+// 'tier1' → managed routing (default), 'tier2' → marketplace routing.
+const PROVIDER_TO_TIER = { tier1: '1', tier2: '2' };
 
 export function parseTestArgs(args) {
   const flags = {};
@@ -95,7 +95,7 @@ export async function testCommand(config, args, chalk) {
     } catch {
       routes = null;
     }
-    const secondaryRoute = Array.isArray(routes) ? routes.find(r => r.name === 'modal') : null;
+    const secondaryRoute = Array.isArray(routes) ? routes.find(r => r.tier === '2') : null;
     if (secondaryRoute?.available) {
       step(chalk, true, 'Secondary provider configured');
       console.log(chalk.green('\n  ✓ Secondary dispatch provider is ready\n'));