badgr-cli 1.0.40 → 1.0.41

package/README.md

@@ -17,11 +17,15 @@ badgr login
 # 2. Verify the stack end-to-end
 badgr test
 
-# 3. Serve an OpenAI-compatible inference endpoint
-badgr serve meta-llama/Llama-3.1-8B-Instruct
+# 3. Run a project folder on a GPU
+badgr run . --cmd "python train.py" --max-cost 5
 
-# 4. Use the endpoint with any OpenAI SDK client
-#    client = OpenAI(api_key="sk-...", base_url="https://dep-a1b2c3.aibadgr.com/v1")
+# 4. Serve an OpenAI-compatible inference endpoint
+badgr serve meta-llama/Llama-3.1-8B-Instruct --max-cost 10
+
+# 5. Use the endpoint with any OpenAI SDK client
+#    export BADGR_ENDPOINT=<URL printed by badgr serve>
+#    client = OpenAI(api_key=os.environ["BADGR_API_KEY"], base_url=os.environ["BADGR_ENDPOINT"])
 
 # 5. View cost, route, and retry receipts
 badgr receipts
@@ -92,25 +96,36 @@ badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S --region EU
 
 ## `badgr run` options
 
+Three source patterns:
+
 ```bash
-badgr run python train.py --gpu A100 --env HF_TOKEN=$HF_TOKEN --max-runtime 60
+# Flow 1 — local project folder (primary)
+badgr run . --cmd "python train.py" --max-cost 5
+
+# Flow 2 — public GitHub repo
+badgr run https://github.com/user/repo --cmd "python train.py" --max-cost 5
+
+# Flow 3 — custom Docker image (advanced)
+badgr run . --image mycompany/custom:latest --cmd "python train.py" --max-cost 5
 ```
 
+Badgr zips and uploads the folder (Flow 1) or clones the repo (Flow 2), picks a generic runner, installs deps, runs the command, stores outputs for 48 hours, and tears down the GPU. `--max-cost` is required.
+
 | Flag | Default | Description |
 |------|---------|-------------|
+| `--cmd <command>` | — | Command to run inside the uploaded project or cloned repo (required for folder/GitHub flows) |
 | `--gpu <type>` | auto | GPU type override — Badgr Auto selects if omitted |
 | `--min-vram <GB>` | — | Minimum VRAM in GB — optional constraint for Auto routing |
-| `--image <img>` | python:3.11-slim | Docker image |
+| `--image <img>` | — | Custom Docker image — bypasses the runner. Mutually exclusive with workspace auto-detection. |
 | `--env KEY=VALUE` | — | Environment variable (repeatable) |
 | `--tier 1\|2` | 1 | `1` = reliable execution (default); `2` = lower-cost burst capacity |
 | `--count <n>` | 1 | Number of GPUs |
 | `--region US\|EU\|AU` | — | Optional region preference. If omitted, Badgr chooses best available capacity. |
 | `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
-| `--max-runtime <min>` | — | Auto-stop after N minutes (recommended) |
-| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount |
+| `--max-runtime <min>` | — | Auto-stop after N minutes |
+| `--max-cost <$>` | — | Auto-stop when total spend reaches this amount (required) |
 | `--detach` | — | Launch and return immediately, don't stream logs |
 | `--save <name>` | — | Save this job as a named workload after it completes |
-| `--workspace <name\|id>` | — | Link this job to a workspace tracker (name or `ws_…` ID) |
 
 ---
 
@@ -216,7 +231,7 @@ A workload is a saved job configuration. Once saved, you can rerun it by name in
 **Save a workload** by adding `--save <name>` to any `badgr run` call:
 
 ```bash
-badgr run python train.py --gpu A100 --env HF_TOKEN=$HF_TOKEN --max-runtime 120 --save my-training-job
+badgr run . --cmd "python train.py" --gpu A100 --env HF_TOKEN=$HF_TOKEN --max-cost 10 --save my-training-job
 ```
 
 **Rerun a saved workload:**
@@ -245,11 +260,11 @@ badgr workload delete my-training-job
 
 ## Workspaces
 
-A workspace tracker groups jobs by a named context — useful for tracking cost and job history across a project or storage path.
+Workspaces are an advanced infrastructure concept — most users never need to manage them directly. When you run `badgr run .`, Badgr handles code upload, dependency caching, and artifact storage automatically. Workspaces are only needed when you want to group jobs under a named context for cost tracking, or link jobs to persistent S3/GCS storage.
 
 ```bash
 badgr workspace create my-project --storage s3://my-bucket/runs --desc "nightly evals"
-badgr run python eval.py --workspace my-project --max-cost 5
+badgr run . --cmd "python eval.py" --workspace my-project --max-cost 5
 badgr workspace info my-project     # jobs, total cost, files
 badgr workspace list
 badgr workspace delete my-project
@@ -298,11 +313,13 @@ Each receipt includes: receipt ID, GPU type, provisioning latency, price/hr, ret
 `badgr serve` provisions a vLLM endpoint that is fully OpenAI-compatible:
 
 ```python
+import os
 from openai import OpenAI
 
+# Export BADGR_ENDPOINT from the URL printed by `badgr serve`
 client = OpenAI(
-    api_key="your-badgr-api-key",
-    base_url="https://dep-a1b2c3.aibadgr.com/v1",  # from badgr serve output
+    api_key=os.environ["BADGR_API_KEY"],
+    base_url=os.environ["BADGR_ENDPOINT"],
 )
 resp = client.chat.completions.create(
     model="meta-llama/Llama-3.1-8B-Instruct",
@@ -314,7 +331,7 @@ resp = client.chat.completions.create(
 import OpenAI from "openai";
 const client = new OpenAI({
   apiKey: process.env.BADGR_API_KEY,
-  baseURL: "https://dep-a1b2c3.aibadgr.com/v1",
+  baseURL: process.env.BADGR_ENDPOINT,  // URL printed by `badgr serve`
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badgr-cli",
-  "version": "1.0.40",
+  "version": "1.0.41",
   "description": "Badgr — run or serve GPU workloads from one command",
   "type": "module",
   "bin": {
@@ -12,8 +12,8 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "chalk": "^5.3.0",
-    "@inquirer/prompts": "^8.5.2"
+    "@inquirer/prompts": "^8.5.2",
+    "chalk": "^5.3.0"
   },
   "devDependencies": {
     "vitest": "^4.1.8"

package/src/catalog.js

@@ -40,6 +40,30 @@ export const TEMPLATES = [
       'Pass HF_TOKEN via --env or BADGR_HF_TOKEN env var.',
     ],
   },
+  {
+    name:        'batch-inference',
+    title:       'Batch Inference',
+    description: 'Run a Python script against many inputs on GPU — eval, scoring, embedding, generation',
+    type:        'job',
+    image:       'pytorch/pytorch:2.3.0-cuda12.1-cudnn8-runtime',
+    gpu:         'RTX_4090',
+    gpu_count:   1,
+    min_vram_gb: 16,
+    env: {
+      HF_TOKEN:         '<your-hf-token>',
+      INPUT_FILE:       'inputs.jsonl',
+      OUTPUT_FILE:      'outputs.jsonl',
+      MODEL:            'meta-llama/Llama-3.1-8B-Instruct',
+      HF_HUB_CACHE:     '/workspace/hf-cache',
+      BADGR_OUTPUT_DIR: '/workspace/outputs',
+    },
+    notes: [
+      'Put your script and inputs.jsonl in the project folder.',
+      'Write outputs to $BADGR_OUTPUT_DIR — they are uploaded as artifacts (48h TTL).',
+      'Download results: `badgr artifacts <job-id>`',
+      'Example: `badgr run . --cmd "python batch.py" --max-cost 5 --save my-batch`',
+    ],
+  },
   {
     name:        'unsloth',
     title:       'Unsloth Fine-Tuning',

package/src/commands/run.js

@@ -1,3 +1,7 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { createWriteStream } from 'fs';
 import { requireApiKey } from '../config.js';
 import { callApi, terminateDeployment } from '../api.js';
 import { addReceipt, updateReceipt, generateReceiptId } from '../store.js';
@@ -6,10 +10,19 @@ import { formatCliError } from '../errors.js';
 import { TEMPLATE_MAP, buildTemplateFlags, parseTemplateOverrides } from '../catalog.js';
 
 /**
- * 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
- * badgr run python train.py --env HF_TOKEN=abc --env DATASET=my/data
+ * Flow 1 — local project (primary):
+ *   badgr run . --cmd "python train.py" --max-cost 5 --save my-training-job
+ *   badgr run ./my-project --cmd "python train.py" --max-cost 5
+ *
+ * Flow 2 — public GitHub repo:
+ *   badgr run https://github.com/user/repo --cmd "python train.py" --max-cost 5
+ *
+ * Flow 3 — custom image (advanced):
+ *   badgr run . --image mycompany/custom:latest --cmd "python train.py" --max-cost 5
+ *
+ * Legacy / direct command:
+ *   badgr run python train.py --gpu A100
+ *   badgr run --image my/image:latest --gpu L40S --detach
  */
 export function parseRunArgs(args) {
   const flags = {};
@@ -41,6 +54,7 @@ export function parseRunArgs(args) {
     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] === '--cmd')             { flags.cmd = flagArgs[++i]; i++; continue; }
     if (flagArgs[i] === '--env') {
       const kv = flagArgs[++i]; i++;
       if (!flags.env) flags.env = [];
@@ -342,9 +356,117 @@ 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',
+  '--dry-run', '--cmd', '--save', '--workspace',
 ]);
 
+// Directories and files always excluded from project zip uploads.
+const _ZIP_EXCLUDES = new Set([
+  '.git', 'node_modules', '__pycache__', '.venv', 'venv', '.env',
+  'dist', 'build', '.next', '.nuxt', 'coverage', '.pytest_cache',
+  '.mypy_cache', '.ruff_cache', '.DS_Store',
+]);
+
+function _shouldExclude(name) {
+  return _ZIP_EXCLUDES.has(name) || name.startsWith('.') && name !== '.gitignore';
+}
+
+function _isLocalPath(arg) {
+  // '.' or './' or relative/absolute paths that exist on disk
+  if (arg === '.') return true;
+  if (arg.startsWith('./') || arg.startsWith('../') || arg.startsWith('/')) return true;
+  return false;
+}
+
+function _isGitHubUrl(arg) {
+  return /^https?:\/\/(www\.)?github\.com\//.test(arg);
+}
+
+/**
+ * Zip a local directory into a temp file, returning the temp file path.
+ * Uses Node's built-in APIs — no external zip library required.
+ */
+async function _zipDirectory(dirPath, chalk) {
+  // Use archiver if available, otherwise fall back to a manual approach via
+  // a child process calling `zip` (available on Linux/macOS) or PowerShell on Windows.
+  const absDir = path.resolve(dirPath);
+  if (!fs.existsSync(absDir)) {
+    throw new Error(`Directory not found: ${absDir}`);
+  }
+
+  const tmpFile = path.join(os.tmpdir(), `badgr-upload-${Date.now()}.zip`);
+
+  // Attempt to use archiver (optional peer dep) first; fall back to system zip.
+  try {
+    const { default: archiver } = await import('archiver');
+    await new Promise((resolve, reject) => {
+      const output = createWriteStream(tmpFile);
+      const archive = archiver('zip', { zlib: { level: 6 } });
+      output.on('close', resolve);
+      archive.on('error', reject);
+      archive.pipe(output);
+      archive.glob('**/*', {
+        cwd: absDir,
+        dot: false,
+        ignore: [..._ZIP_EXCLUDES].map(e => `**/${e}/**`).concat([..._ZIP_EXCLUDES].map(e => e)),
+      });
+      archive.finalize();
+    });
+    return tmpFile;
+  } catch {
+    // archiver not installed — fall back to system zip command
+  }
+
+  const { spawn } = await import('child_process');
+  await new Promise((resolve, reject) => {
+    // Build exclude args — zip uses -x patterns
+    const excludeArgs = [];
+    for (const ex of _ZIP_EXCLUDES) {
+      excludeArgs.push('-x', `*/${ex}/*`, '-x', `${ex}/*`, '-x', `${ex}`);
+    }
+    const child = spawn('zip', ['-r', '-q', tmpFile, '.', ...excludeArgs], { cwd: absDir });
+    child.on('close', code => code === 0 ? resolve() : reject(new Error(`zip exited ${code}`)));
+    child.on('error', reject);
+  });
+
+  return tmpFile;
+}
+
+export async function _uploadCodeZip(config, dirPath, chalk) {
+  process.stdout.write(chalk.dim('  Packing project...'));
+  const tmpFile = await _zipDirectory(dirPath, chalk);
+  const stat = fs.statSync(tmpFile);
+  const sizeMb = (stat.size / 1024 / 1024).toFixed(1);
+  process.stdout.write(chalk.dim(` ${sizeMb} MB\n`));
+
+  process.stdout.write(chalk.dim('  Uploading project...'));
+  // POST zip directly to the Badgr backend — no S3, no presigned URLs.
+  // Built-in FormData/Blob/fetch (Node >=18) keep the CLI dependency-free for
+  // multipart uploads; fetch sets the multipart boundary header automatically.
+  const fileData = fs.readFileSync(tmpFile);
+  const form = new FormData();
+  form.append('file', new Blob([fileData], { type: 'application/zip' }), 'project.zip');
+
+  const baseUrl = config.baseUrl.replace(/\/v1\/?$/, '');
+  let uploadResp;
+  try {
+    uploadResp = await fetch(`${baseUrl}/v1/uploads`, {
+      method: 'POST',
+      body: form,
+      headers: { 'Authorization': `Bearer ${config.apiKey}` },
+    });
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+
+  if (!uploadResp.ok) {
+    const text = await uploadResp.text().catch(() => '');
+    throw new Error(`Upload failed: ${uploadResp.status} ${uploadResp.statusText}${text ? ` — ${text}` : ''}`);
+  }
+  const { code_uri: codeUri } = await uploadResp.json();
+  process.stdout.write(chalk.dim(' done\n'));
+  return codeUri;
+}
+
 export async function runCommand(config, args, chalk) {
   // `badgr run template <name> [flags]` — expand template defaults then re-dispatch
   if (args[0] === 'template') {
@@ -387,12 +509,37 @@ export async function runCommand(config, args, chalk) {
     return;
   }
 
-  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'));
+  // ── Detect source type ─────────────────────────────────────────────────────
+  // positional[0] may be:  '.'  |  './dir'  |  'https://github.com/...'  |  'python'  |  nothing
+  const firstArg = positional[0] ?? null;
+  const isLocalPath  = firstArg && _isLocalPath(firstArg);
+  const isGitHubUrl  = firstArg && _isGitHubUrl(firstArg);
+  const isCodeSource = isLocalPath || isGitHubUrl;
+
+  if (isCodeSource && !flags.cmd) {
+    console.error(chalk.red(`\n  ✗ --cmd is required when running from a ${isLocalPath ? 'local path' : 'GitHub URL'}.\n`));
+    if (isLocalPath) {
+      console.error(chalk.dim('  Example: badgr run . --cmd "python train.py" --max-cost 5\n'));
+    } else {
+      console.error(chalk.dim('  Example: badgr run https://github.com/user/repo --cmd "python train.py" --max-cost 5\n'));
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  // Legacy direct-command mode: positional args form the command
+  const isDirectCommand = !isCodeSource && (positional.length > 0 || commandArgv !== null || flags.image);
+
+  if (!isCodeSource && positional.length === 0 && commandArgv === null && !flags.image) {
+    console.error(chalk.red('\nUsage:'));
+    console.error(chalk.dim('  badgr run . --cmd "python train.py" --max-cost 5'));
+    console.error(chalk.dim('  badgr run https://github.com/user/repo --cmd "python train.py" --max-cost 5'));
+    console.error(chalk.dim('  badgr run python train.py --max-cost 5'));
+    console.error(chalk.dim('  badgr run --image my/image:latest --max-cost 5'));
+    console.error('');
     return;
   }
-  if (commandArgv !== null && commandArgv.length === 0 && !flags.image) {
+  if (commandArgv !== null && commandArgv.length === 0 && !flags.image && !isCodeSource) {
     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;
@@ -430,13 +577,17 @@ export async function runCommand(config, args, chalk) {
   }
 
   // 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';
-  const image = flags.image || (command ? inferredImage : undefined);
+  // For code-source flows (local path / GitHub), the "command" field is empty — the runner
+  // receives it via BADGR_CMD env var instead.
+  const command = isCodeSource
+    ? undefined
+    : (commandArgv !== null
+        ? (commandArgv.length > 0 ? commandArgv : undefined)
+        : (positional.length > 0 ? positional : undefined));
+  const cmdStr = isCodeSource ? (flags.cmd || '') : (command ? command.join(' ') : '');
+  const isSmoke = !isCodeSource && cmdStr.length < 80 && /print\s*\(|['"]hello/i.test(cmdStr);
+  const inferredImage = isSmoke ? 'python:3.11-alpine' : undefined; // code-source flows use runner image
+  const image = flags.image || (command && !isCodeSource ? (isSmoke ? 'python:3.11-alpine' : undefined) : undefined);
   const detach       = flags.detach || false;
 
   // Default max-runtime of 60 minutes — always applied unless overridden.
@@ -453,6 +604,9 @@ export async function runCommand(config, args, chalk) {
 
   if (flags.dryRun) {
     console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    if (isLocalPath)      console.log(`  ${chalk.bold('Source:')}       ${path.resolve(firstArg)} (local project)`);
+    if (isGitHubUrl)      console.log(`  ${chalk.bold('Source:')}       ${firstArg} (GitHub)`);
+    if (flags.cmd)        console.log(`  ${chalk.bold('Command:')}      ${flags.cmd}`);
     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')}`);
@@ -465,10 +619,13 @@ export async function runCommand(config, args, chalk) {
   }
 
   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}`);
-  if (gpu)     console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
-  else         console.log(`  ${chalk.bold('GPU:')}      ${chalk.dim('auto')}`);
+  if (isLocalPath)  console.log(`  ${chalk.bold('Source:')}   ${path.resolve(firstArg)}`);
+  if (isGitHubUrl)  console.log(`  ${chalk.bold('Source:')}   ${firstArg}`);
+  if (flags.cmd)    console.log(`  ${chalk.bold('Command:')}  ${flags.cmd}`);
+  if (command)      console.log(`  ${chalk.bold('Command:')}  ${command.join(' ')}`);
+  if (image)        console.log(`  ${chalk.bold('Image:')}    ${image}`);
+  if (gpu)          console.log(`  ${chalk.bold('GPU:')}      ${gpu}`);
+  else              console.log(`  ${chalk.bold('GPU:')}      ${chalk.dim('auto')}`);
   if (flags.minVram)  console.log(`  ${chalk.bold('Min VRAM:')}   ${flags.minVram} GB`);
   const runtimeLabel = isDefaultRuntime
     ? `${effectiveMaxRuntime}min ${chalk.dim('(default — use --max-runtime N to override)')}`
@@ -498,6 +655,18 @@ export async function runCommand(config, args, chalk) {
     }
   }
 
+  // ── Upload local project zip (Flow 1) ─────────────────────────────────────
+  let codeUri = null;
+  if (isLocalPath) {
+    try {
+      codeUri = await _uploadCodeZip(config, firstArg, chalk);
+    } catch (err) {
+      console.error(chalk.red(`\n  ✗ Failed to upload project: ${err.message}\n`));
+      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}`));
@@ -506,8 +675,8 @@ export async function runCommand(config, args, chalk) {
   function buildBody(gpuOverride, tierOverride) {
     const effectiveRegion = flags.region ? flags.region.toUpperCase() : undefined;
     return {
-      command,
-      image,
+      ...(command ? { command } : {}),
+      ...(image ? { image } : {}),
       gpu: gpuOverride || gpu || 'auto',
       ...(flags.minVram ? { min_vram: flags.minVram } : {}),
       gpu_count: flags.count || 1,
@@ -519,6 +688,10 @@ export async function runCommand(config, args, chalk) {
       max_runtime_seconds: effectiveMaxRuntime * 60,
       ...(maxCost ? { max_cost_usd: maxCost } : {}),
       ...(resolvedWorkspaceId ? { workspace_id: resolvedWorkspaceId } : {}),
+      // Code-source fields
+      ...(codeUri ? { code_uri: codeUri } : {}),
+      ...(isGitHubUrl ? { github_url: firstArg } : {}),
+      ...(flags.cmd ? { cmd: flags.cmd } : {}),
     };
   }
 
@@ -720,8 +893,12 @@ export async function runCommand(config, args, chalk) {
             name: flags.save,
             job_type: 'custom.run',
             config: {
-              command: command || [],
-              image: image || 'python:3.11-slim',
+              ...(command ? { command } : {}),
+              ...(image ? { image } : {}),
+              ...(flags.cmd ? { cmd: flags.cmd } : {}),
+              // For local-path workloads, code_uri is a snapshot — user can re-upload on next run.
+              // GitHub URL is stable and stored directly.
+              ...(isGitHubUrl ? { github_url: firstArg } : {}),
               gpu: gpu || 'auto',
               ...(flags.minVram ? { min_vram: flags.minVram } : {}),
               gpu_count: flags.count || 1,

package/src/commands/serve.js

@@ -104,8 +104,8 @@ function _serveStageLabel(elapsedSec, healthPath = '/models') {
     return 'Waiting for /v1/models…';
   }
   if (healthPath === '/health') {
-    if (elapsedSec < 60)  return 'Starting llama-server…';
-    if (elapsedSec < 180) return 'Downloading from Hugging Face…';
+    if (elapsedSec < 60)  return 'Starting server…';
+    if (elapsedSec < 180) return 'Downloading model…';
     return 'Waiting for /health…';
   }
   if (elapsedSec < 30)  return 'Starting container…';
@@ -461,14 +461,19 @@ export async function serveCommand(config, args, chalk) {
   }
 
   // ── Determine health check path ───────────────────────────────────────────
-  // Priority: explicit --health-path > llama.cpp → /health > vLLM → /models > auto-detect custom image > null
+  // Priority: explicit --health-path > llama.cpp → /health > task-specific > 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';
+    // Managed runtimes for transcribe/image expose /health; vLLM (chat, embed) uses /models
+    if (flags.task === 'transcribe' || flags.task === 'image') {
+      resolvedHealthPath = '/health';
+    } else {
+      resolvedHealthPath = '/models';
+    }
   } else {
     resolvedHealthPath = _detectHealthPath(customImage);  // '/system_stats' for comfyui, null otherwise
   }
@@ -573,7 +578,17 @@ export async function serveCommand(config, args, chalk) {
     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="${sdkModel}", messages=[...])`));
+    if (flags.task === 'transcribe') {
+      console.log(chalk.dim(`    with open("audio.mp3", "rb") as f:`));
+      console.log(chalk.dim(`        t = client.audio.transcriptions.create(model="${sdkModel}", file=f, response_format="text")`));
+    } else if (flags.task === 'image') {
+      console.log(chalk.dim(`    resp = client.images.generate(model="${sdkModel}", prompt="...", n=1, size="1024x1024")`));
+      console.log(chalk.dim(`    # resp.data[0].b64_json contains the base64-encoded PNG`));
+    } else if (flags.task === 'embed') {
+      console.log(chalk.dim(`    resp = client.embeddings.create(model="${sdkModel}", input=["hello world"])`));
+    } else {
+      console.log(chalk.dim(`    resp = client.chat.completions.create(model="${sdkModel}", messages=[{"role": "user", "content": "Hello"}])`));
+    }
     console.log();
   }
 }

package/src/fallback.js

@@ -105,12 +105,14 @@ export async function callWithFallback(endpoint, callOpts, buildBody, effectiveT
 
   const d = firstErr.errorData;
 
-  // Stale-capacity retry: PROVISIONING_FAILED means a GPU slot appeared available but
-  // couldn't launch. Retry once immediately to pick up a fresh slot before escalating.
+  // Provider retry: PROVISIONING_FAILED means the selected provider couldn't launch the slot.
+  // Retry once with prefer_different_provider so the backend routes to a different provider
+  // (e.g. RunPod failed → try Vast.ai or Hyperstack) within the same max_cost budget.
   if (d?.code === 'PROVISIONING_FAILED' || d?.code === 'PROVIDER_ADAPTER_ERROR') {
-    console.log(chalk.dim('\n  Provisioning failed — retrying with fresh capacity...\n'));
+    console.log(chalk.dim('\n  Provider unavailable — trying alternative provider...\n'));
     try {
-      return await attempt(buildBody());
+      const retryBody = { ...buildBody(), prefer_different_provider: true };
+      return await attempt(retryBody);
     } catch (retryErr) {
       if (retryErr.isPaymentRequired) throw retryErr;
       firstErr = retryErr;

package/tests/launch-readiness.test.js

@@ -355,6 +355,31 @@ describe('stale-capacity retry on PROVISIONING_FAILED', () => {
     expect(api.callApi.mock.calls.length).toBeGreaterThanOrEqual(2);
   });
 
+  it('sends prefer_different_provider=true on the PROVISIONING_FAILED retry', async () => {
+    api.callApi.mockRejectedValue(makeProvisioningFailedErr());
+
+    const bodies = [];
+    api.callApi.mockImplementation((_ep, opts) => {
+      bodies.push(opts.body);
+      return Promise.reject(makeProvisioningFailedErr());
+    });
+
+    try {
+      await callWithFallback(
+        '/run',
+        { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' },
+        () => ({ gpu: 'RTX_4090' }),
+        '2',
+        chalk,
+        { thing: 'job', cmd: 'badgr run' },
+      );
+    } catch (_) {}
+
+    // First call: no prefer_different_provider; retry call: must include it
+    expect(bodies[0]).not.toHaveProperty('prefer_different_provider');
+    expect(bodies[1]).toMatchObject({ prefer_different_provider: true });
+  });
+
   it('does NOT double-retry on non-PROVISIONING_FAILED errors', async () => {
     const err = new Error('NO_CAPACITY_MATCH');
     err.errorData = { code: 'NO_CAPACITY_MATCH' };

package/tests/serve-lifecycle.test.js

@@ -663,3 +663,117 @@ describe('llama.cpp E2E smoke — tiny GGUF (ggml-org/tiny-llamas)', () => {
     expect(process.exitCode).toBeFalsy();
   });
 });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 13. --task routing: transcribe and image use /health; embed uses /models
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--task routing for managed runtimes', () => {
+  it('--task transcribe polls /health instead of /models', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'large-v3' }))  // POST /serve
+      .mockResolvedValueOnce({ status: 'running' });                // pre-health dep check
+
+    const fetchedUrls = [];
+    global.fetch = vi.fn().mockImplementation((url) => {
+      fetchedUrls.push(url);
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    const p = serveCommand(
+      config,
+      ['large-v3', '--task', 'transcribe', '--max-cost', '5'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(true);
+    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(false);
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task transcribe sends task field to backend', async () => {
+    api.callApi.mockResolvedValueOnce(makeServeDep({ model: 'large-v3' }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const p = serveCommand(
+      config,
+      ['large-v3', '--task', 'transcribe', '--max-cost', '5', '--no-wait'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(100);
+    await p;
+
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.task).toBe('transcribe');
+    expect(body.model).toBe('large-v3');
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task image polls /health instead of /models', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'black-forest-labs/FLUX.1-schnell' }))
+      .mockResolvedValueOnce({ status: 'running' });
+
+    const fetchedUrls = [];
+    global.fetch = vi.fn().mockImplementation((url) => {
+      fetchedUrls.push(url);
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    const p = serveCommand(
+      config,
+      ['black-forest-labs/FLUX.1-schnell', '--task', 'image', '--max-cost', '10'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(true);
+    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(false);
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task image sends task field to backend', async () => {
+    api.callApi.mockResolvedValueOnce(makeServeDep({ model: 'black-forest-labs/FLUX.1-schnell' }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+
+    const p = serveCommand(
+      config,
+      ['black-forest-labs/FLUX.1-schnell', '--task', 'image', '--max-cost', '10', '--no-wait'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(100);
+    await p;
+
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.task).toBe('image');
+    expect(body.model).toBe('black-forest-labs/FLUX.1-schnell');
+    expect(process.exitCode).toBeFalsy();
+  });
+
+  it('--task embed still polls /models (vLLM path)', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'BAAI/bge-large-en-v1.5' }))
+      .mockResolvedValueOnce({ status: 'running' });
+
+    const fetchedUrls = [];
+    global.fetch = vi.fn().mockImplementation((url) => {
+      fetchedUrls.push(url);
+      return Promise.resolve({ ok: true, status: 200 });
+    });
+
+    const p = serveCommand(
+      config,
+      ['BAAI/bge-large-en-v1.5', '--task', 'embed', '--max-cost', '5'],
+      chalk,
+    );
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(true);
+    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(false);
+    expect(process.exitCode).toBeFalsy();
+  });
+});

package/tests/template.test.js

@@ -105,14 +105,14 @@ afterEach(() => {
 
 describe('TEMPLATES catalog', () => {
   const EXPECTED_NAMES = [
-    'comfyui', 'axolotl', 'unsloth', 'vllm', 'llama-cpp',
+    'comfyui', 'axolotl', 'batch-inference', 'unsloth', 'vllm', 'llama-cpp',
     'invokeai', 'kohya-ss', 'text-gen-webui', 'sglang', 'tgi',
     'auto1111', 'forge', 'nerfstudio', 'openfold', 'blender-render',
     'openmm', 'gromacs', 'lammps', 'diffusers', 'torchtune',
   ];
 
-  it('contains exactly 20 templates', () => {
-    expect(TEMPLATES).toHaveLength(20);
+  it('contains exactly 21 templates', () => {
+    expect(TEMPLATES).toHaveLength(21);
   });
 
   it('contains all expected template names', () => {
@@ -180,7 +180,7 @@ describe('TEMPLATES catalog', () => {
     for (const [k, t] of Object.entries(TEMPLATE_MAP)) {
       expect(k).toBe(t.name);
     }
-    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(20);
+    expect(Object.keys(TEMPLATE_MAP)).toHaveLength(21);
   });
 });
 

package/tests/upload.test.js

@@ -0,0 +1,79 @@
+/**
+ * badgr run — local-project upload flow (regression).
+ *
+ * Guards the bug where `_uploadCodeZip` imported `node-fetch` (an undeclared
+ * dependency) and the `form-data` package: both broke `badgr run . --cmd …`
+ * with "Cannot find package 'form-data'". The upload now uses Node's built-in
+ * FormData / Blob / fetch (Node >=18), so the CLI needs no extra HTTP deps.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { _uploadCodeZip } from '../src/commands/run.js';
+
+const chalk = { dim: (s) => s, bold: (s) => s, red: (s) => s };
+
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'badgr-upload-test-'));
+  fs.writeFileSync(path.join(tmpDir, 'hello.py'), "print('hi')\n");
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe('_uploadCodeZip (local-project flow)', () => {
+  it('uses built-in fetch + FormData and returns the backend code_uri', async () => {
+    // Built-ins must exist in the supported Node runtime — if these are
+    // undefined the upload would fall back to the missing node-fetch/form-data.
+    expect(typeof fetch).toBe('function');
+    expect(typeof FormData).toBe('function');
+    expect(typeof Blob).toBe('function');
+
+    let captured = null;
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, opts) => {
+      captured = { url, opts };
+      return { ok: true, json: async () => ({ code_uri: 'https://aibadgr.com/v1/uploads/up_x/download?token=t' }) };
+    });
+
+    const config = { apiKey: 'sk-test', baseUrl: 'https://aibadgr.com/v1' };
+    const codeUri = await _uploadCodeZip(config, tmpDir, chalk);
+
+    expect(codeUri).toBe('https://aibadgr.com/v1/uploads/up_x/download?token=t');
+    expect(fetchSpy).toHaveBeenCalledTimes(1);
+    expect(captured.url).toBe('https://aibadgr.com/v1/uploads');
+    expect(captured.opts.method).toBe('POST');
+    expect(captured.opts.body).toBeInstanceOf(FormData);
+    expect(captured.opts.body.get('file')).toBeInstanceOf(Blob);
+    expect(captured.opts.headers.Authorization).toBe('Bearer sk-test');
+    // fetch derives the multipart Content-Type/boundary from the FormData body —
+    // the CLI must NOT set it manually (that was the form-data getHeaders() path).
+    expect(captured.opts.headers['Content-Type']).toBeUndefined();
+  });
+
+  it('throws a clear error and still deletes the temp zip when upload fails', async () => {
+    const listZips = () =>
+      new Set(fs.readdirSync(os.tmpdir()).filter(f => f.startsWith('badgr-upload-') && f.endsWith('.zip')));
+    const before = listZips();
+
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+      text: async () => 'boom',
+    });
+
+    const config = { apiKey: 'sk-test', baseUrl: 'https://aibadgr.com/v1' };
+    await expect(_uploadCodeZip(config, tmpDir, chalk)).rejects.toThrow(/Upload failed: 500/);
+
+    // The temp zip created by THIS call must be cleaned up even on failure.
+    const after = listZips();
+    const newLeftovers = [...after].filter(f => !before.has(f));
+    expect(newLeftovers).toEqual([]);
+  });
+});