badgr-cli 1.0.41 → 1.0.43

package/src/commands/train.js

@@ -21,6 +21,17 @@ const TRAINING_IMAGES = {
   generic: 'nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04',
 };
 
+// Container command per framework — must match what's actually installed in
+// TRAINING_IMAGES[framework]. A framework with no entry here has no known
+// working command and is blocked in trainCommand() rather than guessed at,
+// since a wrong guess still provisions (and bills) the GPU before failing.
+const TRAINING_COMMANDS = {
+  axolotl: 'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && axolotl train /tmp/config.yaml',
+  // huggingface/trl-source ships the `trl` CLI (trl sft|dpo|kto --config <yaml>).
+  // We default to `sft` — the common case for a plain base_model+dataset config.
+  trl:     'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && trl sft --config /tmp/config.yaml',
+};
+
 // Preferred GPUs for training: VRAM-heavy workloads.
 const TRAINING_GPUS = ['A100', 'H100', 'L40S', 'A6000'];
 
@@ -87,11 +98,188 @@ export function findLocalDatasetPaths(configContent) {
   return paths;
 }
 
+// ---------------------------------------------------------------------------
+// badgr train lora — productized LoRA training via POST /v1/jobs
+// ---------------------------------------------------------------------------
+
+export function parseTrainLoraArgs(args) {
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === '--base-model')   { flags.baseModel = args[++i]; i++; continue; }
+    if (a === '--dataset')      { flags.dataset = args[++i]; i++; continue; }
+    if (a === '--file-id')      { flags.fileId = args[++i]; i++; continue; }
+    if (a === '--preset')       { flags.preset = args[++i]; i++; continue; }
+    if (a === '--max-cost')     { flags.maxCost = parseFloat(args[++i]); i++; continue; }
+    if (a === '--max-runtime')  { flags.maxRuntime = parseFloat(args[++i]); i++; continue; }
+    if (a === '--tier')         { flags.tier = args[++i]; i++; continue; }
+    if (a === '--gpu-type')     { flags.gpuType = args[++i]; i++; continue; }
+    if (a === '--dry-run')      { flags.dryRun = true; i++; continue; }
+    i++;
+  }
+  return flags;
+}
+
+// Mirror of backend LORA_PRESETS (jobs_routes.py) — display only, server is authoritative.
+export const LORA_PRESET_INFO = {
+  small:  { gpu_type: 'RTX_4090', rank: 16, epochs: 3, description: 'Fast, low-cost — good default for most datasets' },
+  medium: { gpu_type: 'A100',     rank: 32, epochs: 5, description: 'Larger rank/more epochs — bigger datasets or higher quality' },
+};
+
+export async function trainLoraCommand(config, args, chalk) {
+  const { callApi } = await import('../api.js');
+  const { addReceipt, generateReceiptId } = await import('../store.js');
+  const flags = parseTrainLoraArgs(args);
+
+  if (!flags.baseModel) {
+    console.error(chalk.red('\n  Usage: badgr train lora --base-model <model> --dataset <file-or-url> --preset small --max-cost 20\n'));
+    console.error(chalk.dim('  Dataset sources:'));
+    console.error(chalk.dim('    --dataset ./train.jsonl        local file (uploaded first)'));
+    console.error(chalk.dim('    --dataset https://...          direct URL'));
+    console.error(chalk.dim('    --file-id up_abc123            Badgr upload ID\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!flags.maxCost && !flags.dryRun) {
+    console.error(chalk.red('\n  ✗ --max-cost is required to cap GPU spend.\n'));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (flags.dryRun) {
+    const preset = flags.preset || 'small';
+    const presetInfo = LORA_PRESET_INFO[preset];
+    console.log(chalk.bold('\n⚡ Dry run — no GPU will be provisioned\n'));
+    console.log(`  ${chalk.bold('Base model:')}   ${flags.baseModel}`);
+    console.log(`  ${chalk.bold('Dataset:')}      ${flags.fileId || flags.dataset || chalk.dim('(none given)')}`);
+    console.log(`  ${chalk.bold('Preset:')}       ${preset}${presetInfo ? '' : chalk.yellow(' (unknown — server will reject this)')}`);
+    if (presetInfo) {
+      console.log(`  ${chalk.bold('GPU:')}          ${flags.gpuType || presetInfo.gpu_type}`);
+      console.log(`  ${chalk.bold('LoRA rank:')}    ${presetInfo.rank}`);
+      console.log(`  ${chalk.bold('Epochs:')}       ${presetInfo.epochs}`);
+      console.log(`  ${chalk.dim(presetInfo.description)}`);
+    }
+    if (flags.maxCost)    console.log(`  ${chalk.bold('Max cost:')}     $${flags.maxCost}`);
+    console.log(`  ${chalk.bold('Max runtime:')}  ${flags.maxRuntime ?? 240}min`);
+    console.log(chalk.dim('\n  Remove --dry-run to submit (local file datasets are uploaded first).\n'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  // Build dataset input field
+  const input = { base_model: flags.baseModel, config_preset: flags.preset || 'small' };
+  if (flags.fileId) {
+    input.dataset_file_id = flags.fileId;
+  } else if (flags.dataset && (flags.dataset.startsWith('http://') || flags.dataset.startsWith('https://') || flags.dataset.startsWith('s3://'))) {
+    input.dataset_url = flags.dataset;
+  } else if (flags.dataset) {
+    // Local file — upload first
+    const { createReadStream, statSync } = await import('fs');
+    if (!existsSync(flags.dataset)) {
+      console.error(chalk.red(`\n  ✗ Dataset file not found: ${flags.dataset}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    console.log(chalk.dim(`\n  Uploading dataset ${flags.dataset}…`));
+    const { readFileSync: readDs } = await import('fs');
+    const fileData = readDs(flags.dataset);
+    const form = new FormData();
+    form.append('file', new Blob([fileData]), flags.dataset.split('/').pop() || 'dataset.jsonl');
+    const baseUrl = config.baseUrl.replace(/\/v1\/?$/, '');
+    const uploadRes = await fetch(`${baseUrl}/v1/uploads`, {
+      method: 'POST',
+      body: form,
+      headers: { Authorization: `Bearer ${config.apiKey}` },
+    });
+    if (!uploadRes.ok) {
+      const text = await uploadRes.text().catch(() => '');
+      console.error(chalk.red(`\n  ✗ Dataset upload failed: ${uploadRes.status}${text ? ` — ${text}` : ''}\n`));
+      process.exitCode = 1;
+      return;
+    }
+    const uploadResp = await uploadRes.json();
+    input.dataset_file_id = uploadResp.upload_id;
+    console.log(chalk.dim(`  Uploaded: ${uploadResp.upload_id}`));
+  }
+
+  if (flags.gpuType) input.gpu_type = flags.gpuType;
+
+  const rcptId = generateReceiptId();
+  const maxRuntime = flags.maxRuntime ?? 240;
+
+  console.log(chalk.bold('\n⚡ Starting LoRA training\n'));
+  console.log(`  ${chalk.bold('Base model:')} ${flags.baseModel}`);
+  console.log(`  ${chalk.bold('Preset:')}     ${input.config_preset}`);
+  console.log(`  ${chalk.bold('Max cost:')}   $${flags.maxCost}`);
+  console.log(`  ${chalk.bold('Max runtime:')} ${maxRuntime} min\n`);
+
+  let job;
+  try {
+    job = await callApi('/jobs', {
+      method: 'POST',
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+      body: {
+        type: 'train.lora',
+        input,
+        policy: { max_cost: flags.maxCost, max_runtime_minutes: maxRuntime, tier: flags.tier },
+      },
+    });
+  } catch (err) {
+    console.error(chalk.red(`\n  ✗ Failed to submit job: ${err.message}\n`));
+    process.exitCode = 1;
+    return;
+  }
+
+  addReceipt({ id: rcptId, type: 'train.lora', job_id: job.job_id, started_at: Date.now() });
+  console.log(`  ${chalk.bold('Job ID:')}  ${job.job_id}`);
+  console.log(`  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}`);
+  console.log(chalk.dim('\n  Polling for completion — Ctrl+C to detach (GPU keeps running)\n'));
+
+  // Poll until complete
+  const startMs = Date.now();
+  const maxMs = maxRuntime * 60 * 1000;
+  while (Date.now() - startMs < maxMs) {
+    await new Promise(r => setTimeout(r, 15_000));
+    let detail;
+    try {
+      detail = await callApi(`/jobs/${job.job_id}`, {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+      });
+    } catch { continue; }
+    process.stdout.write(`\r  Status: ${detail.status}  elapsed: ${Math.floor((Date.now() - startMs) / 1000)}s  `);
+    if (detail.status === 'completed') {
+      const out = detail.output || {};
+      console.log(chalk.green('\n\n  ✓ Training complete\n'));
+      if (out.adapter_url) console.log(`  ${chalk.bold('Adapter:')} ${out.adapter_url}`);
+      if (out.checkpoint_url) console.log(`  ${chalk.bold('Checkpoint:')} ${out.checkpoint_url}`);
+      console.log(`  ${chalk.bold('Receipt:')} ${chalk.dim(rcptId)}\n`);
+      return;
+    }
+    if (detail.status === 'failed') {
+      console.error(chalk.red(`\n\n  ✗ Training failed: ${detail.error_code || ''} — ${detail.error_message || ''}\n`));
+      process.exitCode = 1;
+      return;
+    }
+  }
+  console.error(chalk.yellow('\n\n  Training still running — detached. Check status:\n'));
+  console.error(chalk.dim(`    badgr status\n`));
+}
+
 export async function trainCommand(config, args, chalk) {
+  // Route subcommands
+  const sub = args[0];
+  if (sub === 'lora') return trainLoraCommand(config, args.slice(1), chalk);
+
   const { configFile, flags } = parseTrainArgs(args);
 
   if (!configFile) {
     console.error(chalk.red('\n  Usage: badgr train config.yaml\n'));
+    console.error(chalk.dim('  Productized LoRA: badgr train lora --base-model MODEL --dataset FILE --max-cost N\n'));
     console.error(chalk.dim('  Runs LoRA / fine-tuning on GPU and streams logs.\n'));
     process.exitCode = 1;
     return;
@@ -158,12 +346,27 @@ export async function trainCommand(config, args, chalk) {
   console.log(`  ${chalk.bold('Max runtime:')} ${runtimeLabel}`);
   if (maxCost) console.log(`  ${chalk.bold('Max cost:')}    $${maxCost.toFixed(2)}`);
   console.log();
+
+  // Block before provisioning: TRAINING_IMAGES[framework] and the container
+  // command must be a matched pair, or the job burns GPU time and then fails
+  // (e.g. an axolotl `train` binary that doesn't exist in the unsloth image).
+  const trainCmd = TRAINING_COMMANDS[framework];
+  if (!trainCmd) {
+    console.error(chalk.red(`  ✗ No runnable command for framework '${framework}' — refusing to provision a GPU that will fail.\n`));
+    console.error(chalk.dim(`    '${image}' does not have a known working entrypoint for this config yet.`));
+    console.error(chalk.dim(`    Options:`));
+    console.error(chalk.dim(`      --framework axolotl   force Axolotl (it has native Unsloth-optimization support via config keys)`));
+    console.error(chalk.dim(`      badgr train lora ...  use the productized LoRA path instead\n`));
+    process.exitCode = 1;
+    return;
+  }
+
   process.stdout.write(chalk.dim('  Finding suitable capacity...\n'));
 
   function buildBody(tierOverride) {
     return {
       image,
-      command: ['sh', '-c', 'echo "$TRAIN_CONFIG_B64" | base64 -d > /tmp/config.yaml && axolotl train /tmp/config.yaml'],
+      command: ['sh', '-c', trainCmd],
       gpu,
       gpu_count:          1,
       ...(flags.region ? { region: flags.region.toUpperCase() } : {}),

package/tests/productized-dry-run.test.js

@@ -0,0 +1,141 @@
+/**
+ * --dry-run for the productized runner commands (badgr train lora, badgr comfyui batch).
+ *
+ * Both must preview the request (preset/workflow, GPU, cost) without calling the API,
+ * uploading files, or requiring an API key — mirroring the existing `badgr run --dry-run`
+ * and `badgr up --dry-run` behavior.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { trainLoraCommand, parseTrainLoraArgs } from '../src/commands/train.js';
+import { comfyBatchCommand, parseComfyBatchArgs } from '../src/commands/comfyui.js';
+
+vi.mock('../src/api.js', () => ({
+  callApi: vi.fn(),
+}));
+
+vi.mock('../src/store.js', () => ({
+  addReceipt:        vi.fn(),
+  generateReceiptId: vi.fn(() => 'rcpt-dry-001'),
+}));
+
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    readFileSync: vi.fn(),
+    existsSync:   vi.fn(),
+  };
+});
+
+import * as api   from '../src/api.js';
+import * as store from '../src/store.js';
+import * as fs    from 'fs';
+
+const chalk = {
+  bold: s => s, dim: s => s, red: s => s, yellow: s => s, green: s => s, cyan: s => s,
+};
+
+const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
+
+beforeEach(() => {
+  process.exitCode = undefined;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.clearAllMocks();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  process.exitCode = undefined;
+});
+
+describe('parseTrainLoraArgs', () => {
+  it('parses --dry-run', () => {
+    const flags = parseTrainLoraArgs(['--base-model', 'x', '--dry-run']);
+    expect(flags.dryRun).toBe(true);
+  });
+});
+
+describe('trainLoraCommand --dry-run', () => {
+  it('previews the job without calling the API or requiring an API key', async () => {
+    await trainLoraCommand({ apiKey: null, baseUrl: 'https://api.test/v1' }, [
+      '--base-model', 'mistralai/Mistral-7B-v0.1',
+      '--dataset', 'https://example.com/data.jsonl',
+      '--dry-run',
+    ], chalk);
+
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(store.addReceipt).not.toHaveBeenCalled();
+    expect(process.exitCode).toBeFalsy();
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('Dry run');
+    expect(logged).toContain('mistralai/Mistral-7B-v0.1');
+    expect(logged).toContain('RTX_4090'); // default 'small' preset GPU
+  });
+
+  it('does not upload a local dataset file during --dry-run', async () => {
+    fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue('dummy');
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({ ok: true, json: async () => ({ upload_id: 'up_x' }) });
+
+    await trainLoraCommand(config, [
+      '--base-model', 'mistralai/Mistral-7B-v0.1',
+      '--dataset', './local.jsonl',
+      '--dry-run',
+    ], chalk);
+
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+
+  it('still requires --base-model even with --dry-run', async () => {
+    await trainLoraCommand(config, ['--dry-run'], chalk);
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('flags an unknown preset instead of silently accepting it', async () => {
+    await trainLoraCommand(config, [
+      '--base-model', 'mistralai/Mistral-7B-v0.1',
+      '--preset', 'huge',
+      '--dry-run',
+    ], chalk);
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('unknown');
+  });
+});
+
+describe('parseComfyBatchArgs', () => {
+  it('parses --dry-run', () => {
+    const flags = parseComfyBatchArgs(['--workflow', 'sdxl-basic', '--dry-run']);
+    expect(flags.dryRun).toBe(true);
+  });
+});
+
+describe('comfyBatchCommand --dry-run', () => {
+  it('previews the batch without calling the API or requiring an API key', async () => {
+    await comfyBatchCommand({ apiKey: null, baseUrl: 'https://api.test/v1' }, [
+      '--workflow', 'sdxl-basic',
+      '--prompt', 'a cat on a beach',
+      '--dry-run',
+    ], chalk);
+
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(store.addReceipt).not.toHaveBeenCalled();
+    expect(process.exitCode).toBeFalsy();
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('Dry run');
+    expect(logged).toContain('sdxl-basic');
+    expect(logged).toContain('RTX_4090');
+  });
+
+  it('warns when the prompt count exceeds the 20-prompt cap', async () => {
+    const flags = { workflow: 'sdxl-basic', inlinePrompts: Array(21).fill('x') };
+    await comfyBatchCommand({ apiKey: null, baseUrl: 'https://api.test/v1' }, [
+      '--workflow', 'sdxl-basic',
+      ...Array(21).fill(['--prompt', 'x']).flat(),
+      '--dry-run',
+    ], chalk);
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('exceeds the 20-prompt limit');
+  });
+});

package/tests/productized-runners.test.js

@@ -0,0 +1,230 @@
+/**
+ * Productized runner tests
+ *
+ * Covers:
+ *   - Blessed vLLM aliases expand to full model ID + correct GPU
+ *   - serveCommand sends full model ID to API when alias is given
+ *   - BLESSED_VLLM_MODELS has required fields
+ *   - BLESSED_COMFY_WORKFLOWS has required fields
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { parseServeArgs, serveCommand } from '../src/commands/serve.js';
+import { BLESSED_VLLM_MODELS, BLESSED_COMFY_WORKFLOWS } from '../src/catalog.js';
+
+// ── Module mocks ──────────────────────────────────────────────────────────────
+
+vi.mock('../src/api.js', () => ({
+  callApi:             vi.fn(),
+  terminateDeployment: vi.fn().mockResolvedValue({}),
+  listDeployments:     vi.fn().mockResolvedValue({ deployments: [], count: 0 }),
+}));
+
+vi.mock('../src/store.js', () => ({
+  addDeployment:        vi.fn(),
+  addReceipt:           vi.fn(),
+  updateReceipt:        vi.fn(),
+  generateReceiptId:    vi.fn(() => 'rcpt-prod-001'),
+  generateDeploymentId: vi.fn(() => 'dep-prod-001'),
+  listDeployments:      vi.fn(() => []),
+  listReceipts:         vi.fn(() => []),
+  findDeployment:       vi.fn(() => null),
+  updateDeployment:     vi.fn(),
+  removeDeployment:     vi.fn(),
+}));
+
+vi.mock('../src/fallback.js', () => ({
+  normalizeTier:         vi.fn(t => t || null),
+  callWithFallback:      vi.fn(),
+  HIGH_RATE_THRESHOLD:   2.0,
+}));
+
+vi.mock('../src/config.js', () => ({
+  requireApiKey: vi.fn(),
+}));
+
+vi.mock('../src/errors.js', () => ({
+  formatCliError: vi.fn((code, ctx) => `Error: ${code}`),
+}));
+
+import * as fallback from '../src/fallback.js';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+const config = { apiKey: 'sk-test', baseUrl: 'https://api.test/v1' };
+
+const chalk = {
+  bold:   s => s,
+  dim:    s => s,
+  red:    s => s,
+  yellow: s => s,
+  green:  s => s,
+  cyan:   s => s,
+};
+
+function makeServeDep(overrides = {}) {
+  return {
+    deployment_id: 'dep-prod-001',
+    status:        'running',
+    gpu_type:      'RTX_4090',
+    gpu_count:     1,
+    cost_per_hour: 1.20,
+    provider:      'runpod',
+    receipt_id:    'rcpt-prod-001',
+    tier:          '1',
+    endpoint_url:  'https://dep-prod-001.aibadgr.com/v1',
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  process.exitCode = undefined;
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(process.stdout, 'write').mockImplementation(() => {});
+});
+
+// ── Catalog shape tests ───────────────────────────────────────────────────────
+
+describe('BLESSED_VLLM_MODELS catalog', () => {
+  it('has qwen-7b, llama-8b, qwen-coder-7b', () => {
+    expect(Object.keys(BLESSED_VLLM_MODELS)).toEqual(
+      expect.arrayContaining(['qwen-7b', 'llama-8b', 'qwen-coder-7b'])
+    );
+  });
+
+  it('each entry has model_id, gpu_type, image, health_path', () => {
+    for (const [alias, spec] of Object.entries(BLESSED_VLLM_MODELS)) {
+      expect(spec.model_id, `${alias}.model_id`).toBeTruthy();
+      expect(spec.gpu_type, `${alias}.gpu_type`).toBeTruthy();
+      expect(spec.image,    `${alias}.image`).toBeTruthy();
+      expect(spec.health_path, `${alias}.health_path`).toBeTruthy();
+    }
+  });
+
+  it('qwen-7b resolves to Qwen2.5-7B-Instruct on RTX_4090', () => {
+    const spec = BLESSED_VLLM_MODELS['qwen-7b'];
+    expect(spec.model_id).toBe('Qwen/Qwen2.5-7B-Instruct');
+    expect(spec.gpu_type).toBe('RTX_4090');
+  });
+
+  it('llama-8b resolves to Llama-3.1-8B-Instruct on RTX_4090', () => {
+    const spec = BLESSED_VLLM_MODELS['llama-8b'];
+    expect(spec.model_id).toBe('meta-llama/Llama-3.1-8B-Instruct');
+    expect(spec.gpu_type).toBe('RTX_4090');
+  });
+
+  it('qwen-coder-7b resolves to Qwen2.5-Coder-7B-Instruct on RTX_4090', () => {
+    const spec = BLESSED_VLLM_MODELS['qwen-coder-7b'];
+    expect(spec.model_id).toBe('Qwen/Qwen2.5-Coder-7B-Instruct');
+    expect(spec.gpu_type).toBe('RTX_4090');
+  });
+});
+
+describe('BLESSED_COMFY_WORKFLOWS catalog', () => {
+  it('has sdxl-basic', () => {
+    expect(BLESSED_COMFY_WORKFLOWS['sdxl-basic']).toBeDefined();
+  });
+
+  it('sdxl-basic has gpu_type and output_type', () => {
+    const wf = BLESSED_COMFY_WORKFLOWS['sdxl-basic'];
+    expect(wf.gpu_type).toBe('RTX_4090');
+    expect(wf.output_type).toBe('images');
+  });
+});
+
+// ── parseServeArgs alias recognition ─────────────────────────────────────────
+
+describe('parseServeArgs — alias handling', () => {
+  it('passes alias through as positional model', () => {
+    const { model } = parseServeArgs(['qwen-7b', '--max-cost', '10']);
+    expect(model).toBe('qwen-7b');
+  });
+
+  it('alias is distinct from full model ID in parseServeArgs', () => {
+    const { model: alias } = parseServeArgs(['qwen-7b']);
+    const { model: full }  = parseServeArgs(['Qwen/Qwen2.5-7B-Instruct']);
+    expect(alias).toBe('qwen-7b');
+    expect(full).toBe('Qwen/Qwen2.5-7B-Instruct');
+  });
+});
+
+// ── serveCommand alias expansion ──────────────────────────────────────────────
+
+describe('serveCommand — alias expansion', () => {
+  it('sends full model_id to API when alias qwen-7b is used', async () => {
+    fallback.callWithFallback.mockResolvedValue(makeServeDep({
+      model: 'Qwen/Qwen2.5-7B-Instruct',
+    }));
+    // Mock fetch for health check (immediate pass)
+    global.fetch = vi.fn().mockResolvedValue({ ok: true });
+
+    await serveCommand(config, ['qwen-7b', '--max-cost', '10', '--no-wait'], chalk);
+
+    expect(fallback.callWithFallback).toHaveBeenCalled();
+    const bodyFn = fallback.callWithFallback.mock.calls[0][2];
+    const body = bodyFn(null);
+    expect(body.model).toBe('Qwen/Qwen2.5-7B-Instruct');
+    expect(body.gpu).toBe('RTX_4090');
+  });
+
+  it('sends full model_id to API when alias llama-8b is used', async () => {
+    fallback.callWithFallback.mockResolvedValue(makeServeDep({
+      model: 'meta-llama/Llama-3.1-8B-Instruct',
+    }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true });
+
+    await serveCommand(config, ['llama-8b', '--max-cost', '10', '--no-wait'], chalk);
+
+    const bodyFn = fallback.callWithFallback.mock.calls[0][2];
+    const body = bodyFn(null);
+    expect(body.model).toBe('meta-llama/Llama-3.1-8B-Instruct');
+    expect(body.gpu).toBe('RTX_4090');
+  });
+
+  it('sends full model_id to API when alias qwen-coder-7b is used', async () => {
+    fallback.callWithFallback.mockResolvedValue(makeServeDep({
+      model: 'Qwen/Qwen2.5-Coder-7B-Instruct',
+    }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true });
+
+    await serveCommand(config, ['qwen-coder-7b', '--max-cost', '5', '--no-wait'], chalk);
+
+    const bodyFn = fallback.callWithFallback.mock.calls[0][2];
+    const body = bodyFn(null);
+    expect(body.model).toBe('Qwen/Qwen2.5-Coder-7B-Instruct');
+    expect(body.gpu).toBe('RTX_4090');
+  });
+
+  it('passes full model ID unchanged (no alias lookup)', async () => {
+    fallback.callWithFallback.mockResolvedValue(makeServeDep({
+      model: 'meta-llama/Llama-3.1-70B-Instruct',
+      gpu_type: 'H100',
+    }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true });
+
+    await serveCommand(config, ['meta-llama/Llama-3.1-70B-Instruct', '--max-cost', '20', '--gpu', 'H100', '--no-wait'], chalk);
+
+    const bodyFn = fallback.callWithFallback.mock.calls[0][2];
+    const body = bodyFn(null);
+    expect(body.model).toBe('meta-llama/Llama-3.1-70B-Instruct');
+    expect(body.gpu).toBe('H100');
+  });
+
+  it('rejects --max-cost missing for alias (same as non-alias)', async () => {
+    await serveCommand(config, ['qwen-7b'], chalk);
+    expect(process.exitCode).toBe(1);
+    expect(fallback.callWithFallback).not.toHaveBeenCalled();
+  });
+
+  it('alias auto-sets RTX_4090 but --gpu flag overrides it', async () => {
+    fallback.callWithFallback.mockResolvedValue(makeServeDep({ gpu_type: 'L40S' }));
+    global.fetch = vi.fn().mockResolvedValue({ ok: true });
+
+    await serveCommand(config, ['qwen-7b', '--max-cost', '10', '--gpu', 'L40S', '--no-wait'], chalk);
+
+    const bodyFn = fallback.callWithFallback.mock.calls[0][2];
+    const body = bodyFn(null);
+    expect(body.gpu).toBe('L40S');
+  });
+});