badgr-cli 1.0.42 → 1.0.44

package/tests/serve-lifecycle.test.js

@@ -13,6 +13,11 @@
  *   - Custom image skips health check automatically
  *   - Tier-1 unavailable → auto-expand to tier-2
  *   - Receipt records providerRoute, tier, gpu, endpointUrl, status
+ *
+ * Readiness is driven entirely by Badgr's own deployment status
+ * (GET /deployments/{id} — endpoint_ready/health_path/readiness_reason/fix_hint).
+ * The CLI never fetches the RunPod proxy/pod endpoint directly, so these tests
+ * mock api.callApi responses rather than global.fetch.
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { serveCommand } from '../src/commands/serve.js';
@@ -72,6 +77,17 @@ function makeServeDep(overrides = {}) {
   };
 }
 
+// A GET /deployments/{id} response where the backend reports the app-level
+// endpoint is ready (endpoint_ready:true) — this is what the CLI now waits on
+// instead of fetching the pod directly.
+function readyStatus(overrides = {}) {
+  return { status: 'running', endpoint_ready: true, health_path: '/v1/models', ...overrides };
+}
+
+function notReadyStatus(overrides = {}) {
+  return { status: 'running', endpoint_ready: false, health_path: '/v1/models', readiness_reason: 'starting', ...overrides };
+}
+
 // ── Setup / teardown ──────────────────────────────────────────────────────────
 
 beforeEach(() => {
@@ -83,6 +99,9 @@ beforeEach(() => {
   vi.clearAllMocks();
   store.generateReceiptId.mockReturnValue('rcpt-serve-001');
   api.terminateDeployment.mockResolvedValue({});
+  // No test should ever hit the network directly — waitForEndpoint polls
+  // Badgr's own API only. Fail loudly if anything calls fetch.
+  global.fetch = vi.fn().mockRejectedValue(new Error('serve.js must not call fetch() directly'));
 });
 
 afterEach(() => {
@@ -99,14 +118,8 @@ describe('successful serve', () => {
   it('Llama-3.1-8B on L40S via RunPod — endpoint ready, receipt records state', async () => {
     api.callApi
       .mockResolvedValueOnce(makeServeDep())                    // POST /serve
-      .mockResolvedValueOnce({ status: 'running' });            // pre-health status check
-
-    // Mock the direct fetch call in waitForEndpoint
-    global.fetch = vi.fn().mockResolvedValue({
-      ok: true, status: 200,
-      json: async () => ({ data: [{ id: 'meta-llama/Llama-3.1-8B-Instruct' }] }),
-      text: async () => '',
-    });
+      .mockResolvedValueOnce({ status: 'running' })              // pre-health status check
+      .mockResolvedValueOnce(readyStatus());                     // waitForEndpoint poll
 
     const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--gpu', 'L40S', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
@@ -121,6 +134,7 @@ describe('successful serve', () => {
       status:      'ready',
       endpointUrl: ENDPOINT_URL,
     }));
+    expect(global.fetch).not.toHaveBeenCalled();
     expect(process.exitCode).toBeFalsy();
   });
 
@@ -128,9 +142,8 @@ describe('successful serve', () => {
     const dep = makeServeDep({ gpu_type: 'A100', provider: 'vastai', model: 'mistralai/Mistral-7B-v0.1' });
     api.callApi
       .mockResolvedValueOnce(dep)
-      .mockResolvedValueOnce({ status: 'running' });
-
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce(readyStatus());
 
     const p = serveCommand(config, ['mistralai/Mistral-7B-v0.1', '--gpu', 'A100', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
@@ -150,12 +163,10 @@ describe('successful serve', () => {
 
 describe('billing ends when deployment stops', () => {
   it('serveCommand calls terminateDeployment on SIGINT (graceful stop)', async () => {
-    // Simulate a deployment that is stopped externally (failed status returned during health check)
     api.callApi
       .mockResolvedValueOnce(makeServeDep())
-      .mockResolvedValueOnce({ status: 'running' });
-
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce(readyStatus());
 
     const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
@@ -199,9 +210,6 @@ describe('deployment fails during startup', () => {
       .mockResolvedValueOnce({ status: 'running' }) // pre-health check ok
       .mockResolvedValueOnce({ status: 'failed', error: 'CUDA error' }); // poll inside waitForEndpoint
 
-    // Health check endpoint doesn't respond (dep crashed)
-    global.fetch = vi.fn().mockRejectedValue(new Error('Connection refused'));
-
     const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     // need to advance past the 8000ms sleep in waitForEndpoint loop
     await vi.advanceTimersByTimeAsync(10000);
@@ -212,6 +220,25 @@ describe('deployment fails during startup', () => {
     }));
     expect(process.exitCode).toBe(1);
   });
+
+  it('surfaces backend fix_hint as the failure reason (pod exited / readiness timeout)', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep())
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce({
+        status: 'failed',
+        error: 'pod_exited',
+        fix_hint: 'The pod stopped running before the endpoint ever responded — likely an OOM.',
+      });
+
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
+    await vi.advanceTimersByTimeAsync(10000);
+    await p;
+
+    expect(process.exitCode).toBe(1);
+    const errLines = console.error.mock.calls.flat().join('\n');
+    expect(errLines).toContain('likely an OOM');
+  });
 });
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -219,18 +246,15 @@ describe('deployment fails during startup', () => {
 // ─────────────────────────────────────────────────────────────────────────────
 
 describe('health check timeout', () => {
-  it('records health_check_timeout if /models never responds within 5 minutes', async () => {
+  it('records health_check_timeout if endpoint_ready never becomes true within 15 minutes', async () => {
     api.callApi
       .mockResolvedValueOnce(makeServeDep()) // POST /serve
       .mockResolvedValueOnce({ status: 'running' }) // pre-health check
-      .mockResolvedValue({ status: 'running' }); // all subsequent dep polls: still running
-
-    // Health endpoint never responds
-    global.fetch = vi.fn().mockRejectedValue(new Error('ETIMEDOUT'));
+      .mockResolvedValue(notReadyStatus()); // all subsequent dep polls: still not ready
 
     const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
-    // waitForEndpoint timeout is 5 * 60 * 1000 = 300000ms
-    await vi.advanceTimersByTimeAsync(310000);
+    // waitForEndpoint timeout is VLLM_SERVE_WAIT_MS = 15 * 60 * 1000
+    await vi.advanceTimersByTimeAsync(910000);
     await p;
 
     expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({
@@ -306,15 +330,15 @@ describe('invalid model ID or no capacity', () => {
 // ─────────────────────────────────────────────────────────────────────────────
 
 describe('--no-wait flag', () => {
-  it('returns immediately without polling /models', async () => {
+  it('returns immediately without polling deployment status for readiness', async () => {
     api.callApi.mockResolvedValueOnce(makeServeDep());
-    global.fetch = vi.fn(); // should never be called
 
     const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--no-wait', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(100);
     await p;
 
-    expect(global.fetch).not.toHaveBeenCalled();
+    // Only the POST /serve call — no readiness polling at all.
+    expect(api.callApi).toHaveBeenCalledTimes(1);
     // Receipt records 'starting' (not 'ready') when --no-wait is used
     expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({
       status: 'starting',
@@ -330,7 +354,6 @@ describe('--no-wait flag', () => {
 describe('custom image health check', () => {
   it('skips health check for non-comfyui --image (no known readiness path)', async () => {
     api.callApi.mockResolvedValueOnce(makeServeDep({ model: null }));
-    global.fetch = vi.fn(); // should not be called
 
     const p = serveCommand(
       config,
@@ -340,20 +363,15 @@ describe('custom image health check', () => {
     await vi.advanceTimersByTimeAsync(100);
     await p;
 
-    expect(global.fetch).not.toHaveBeenCalled();
+    expect(api.callApi).toHaveBeenCalledTimes(1);
     expect(process.exitCode).toBeFalsy();
   });
 
-  it('auto-detects comfyui image and polls /system_stats instead of skipping', async () => {
+  it('auto-detects comfyui image and waits on backend-reported endpoint_ready', async () => {
     api.callApi
       .mockResolvedValueOnce(makeServeDep({ model: null }))  // POST /serve
-      .mockResolvedValueOnce({ status: 'running' });          // pre-health dep status check
-
-    const fetchedUrls = [];
-    global.fetch = vi.fn().mockImplementation((url) => {
-      fetchedUrls.push(url);
-      return Promise.resolve({ ok: true, status: 200 });
-    });
+      .mockResolvedValueOnce({ status: 'running' })           // pre-health dep status check
+      .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, health_path: '/system_stats' });
 
     const p = serveCommand(
       config,
@@ -363,21 +381,15 @@ describe('custom image health check', () => {
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
-    expect(fetchedUrls.some(u => u.includes('/system_stats'))).toBe(true);
-    expect(fetchedUrls.some(u => u.includes('/models'))).toBe(false);
+    expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({ status: 'ready' }));
     expect(process.exitCode).toBeFalsy();
   });
 
-  it('uses --health-path when explicitly provided, overriding defaults', async () => {
+  it('sends --health-path override to the backend when explicitly provided', async () => {
     api.callApi
       .mockResolvedValueOnce(makeServeDep({ model: null }))  // POST /serve
-      .mockResolvedValueOnce({ status: 'running' });          // pre-health dep status check
-
-    const fetchedUrls = [];
-    global.fetch = vi.fn().mockImplementation((url) => {
-      fetchedUrls.push(url);
-      return Promise.resolve({ ok: true, status: 200 });
-    });
+      .mockResolvedValueOnce({ status: 'running' })           // pre-health dep status check
+      .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, health_path: '/health' });
 
     const p = serveCommand(
       config,
@@ -387,21 +399,16 @@ describe('custom image health check', () => {
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
-    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(true);
-    expect(fetchedUrls.some(u => u.includes('/models'))).toBe(false);
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.health_path).toBe('/health');
     expect(process.exitCode).toBeFalsy();
   });
 
   it('--health-path also works for model-based serve (overrides /models default)', async () => {
     api.callApi
       .mockResolvedValueOnce(makeServeDep())                 // POST /serve
-      .mockResolvedValueOnce({ status: 'running' });         // pre-health dep status check
-
-    const fetchedUrls = [];
-    global.fetch = vi.fn().mockImplementation((url) => {
-      fetchedUrls.push(url);
-      return Promise.resolve({ ok: true, status: 200 });
-    });
+      .mockResolvedValueOnce({ status: 'running' })           // pre-health dep status check
+      .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, health_path: '/v1/health' });
 
     const p = serveCommand(
       config,
@@ -411,8 +418,8 @@ describe('custom image health check', () => {
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
-    expect(fetchedUrls.some(u => u.includes('/v1/health'))).toBe(true);
-    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(false);
+    const body = api.callApi.mock.calls[0][1].body;
+    expect(body.health_path).toBe('/v1/health');
     expect(process.exitCode).toBeFalsy();
   });
 });
@@ -430,9 +437,8 @@ describe('tier-2 fallback for serve', () => {
     api.callApi
       .mockRejectedValueOnce(capacityErr)                                               // tier-1
       .mockResolvedValueOnce(makeServeDep({ provider: 'vast', tier: '2' }))             // tier-2
-      .mockResolvedValueOnce({ status: 'running' });                                    // pre-health
-
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
+      .mockResolvedValueOnce({ status: 'running' })                                    // pre-health
+      .mockResolvedValueOnce(readyStatus());
 
     const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
@@ -499,6 +505,114 @@ describe('input validation for serve', () => {
   });
 });
 
+// ─────────────────────────────────────────────────────────────────────────────
+// --list-aliases — discoverability for blessed vLLM aliases
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('--list-aliases', () => {
+  it('prints tested model routes without requiring a model or API call', async () => {
+    await serveCommand({ apiKey: null, baseUrl: 'https://api.test/v1' }, ['--list-aliases'], chalk);
+    expect(api.callApi).not.toHaveBeenCalled();
+    expect(process.exitCode).toBeFalsy();
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('Tested model routes:');
+    expect(logged).toContain('qwen-7b');
+    expect(logged).toContain('You can also try a Hugging Face model ID:');
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Model support-level messaging — blessed route vs best-effort HF model vs
+// custom container, plus gated-model HF_TOKEN guidance shown only on failure.
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('model support-level messaging', () => {
+  it('labels a full Hugging Face model ID as best-effort, not tested', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'Qwen/Qwen2.5-7B-Instruct' }))
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce(readyStatus());
+
+    const p = serveCommand(config, ['Qwen/Qwen2.5-7B-Instruct', '--max-cost', '10'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('Route: best-effort Hugging Face model');
+    expect(logged).not.toContain('Route: tested');
+  });
+
+  it('labels a blessed alias as a tested route without extra caveats', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'Qwen/Qwen2.5-7B-Instruct' }))
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce(readyStatus());
+
+    const p = serveCommand(config, ['qwen-7b', '--max-cost', '10'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('Route: tested');
+    expect(logged).not.toContain('best-effort');
+  });
+
+  it('does not show HF_TOKEN guidance up front for a gated model that launches fine', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'meta-llama/Llama-3.1-8B-Instruct' }))
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce(readyStatus());
+
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '10'], chalk);
+    await vi.advanceTimersByTimeAsync(5000);
+    await p;
+
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).not.toContain('may require Hugging Face access');
+  });
+
+  it('shows HF_TOKEN guidance only once a gated model actually fails to start', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'meta-llama/Llama-3.1-8B-Instruct' }))
+      .mockResolvedValueOnce({ status: 'failed', error: 'gated repo — 401' });
+
+    const p = serveCommand(config, ['meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '10'], chalk);
+    await p;
+
+    const logged = console.error.mock.calls.flat().join('\n');
+    expect(logged).toContain('may require Hugging Face access');
+    expect(logged).toContain('--env HF_TOKEN=$HF_TOKEN');
+    expect(process.exitCode).toBe(1);
+  });
+
+  it('omits HF_TOKEN guidance on failure when HF_TOKEN is already provided', async () => {
+    api.callApi
+      .mockResolvedValueOnce(makeServeDep({ model: 'meta-llama/Llama-3.1-8B-Instruct' }))
+      .mockResolvedValueOnce({ status: 'failed', error: 'crashed' });
+
+    const p = serveCommand(config, [
+      'meta-llama/Llama-3.1-8B-Instruct', '--max-cost', '10', '--env', 'HF_TOKEN=hf_abc123',
+    ], chalk);
+    await p;
+
+    const logged = console.error.mock.calls.flat().join('\n');
+    expect(logged).not.toContain('may require Hugging Face access');
+  });
+
+  it('labels a custom container as "custom server", not a Hugging Face model', async () => {
+    api.callApi.mockResolvedValueOnce(makeServeDep({ model: undefined, image: 'my/custom-server:latest' }));
+
+    const p = serveCommand(config, [
+      '--image', 'my/custom-server:latest', '--max-cost', '10', '--no-wait',
+    ], chalk);
+    await p;
+
+    const logged = console.log.mock.calls.flat().join('\n');
+    expect(logged).toContain('custom server');
+    expect(logged).toContain('Your container owns the app behavior.');
+  });
+});
+
 // ─────────────────────────────────────────────────────────────────────────────
 // 11. llama.cpp runtime (--runtime llama.cpp --gguf)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -522,7 +636,6 @@ describe('--runtime llama.cpp', () => {
   it('uses llama.cpp image with LLAMA_ARG_HF_REPO and LLAMA_ARG_HF_FILE env vars', async () => {
     // --no-wait: only POST /serve called (1 mock needed)
     api.callApi.mockResolvedValueOnce(makeServeDep());
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
 
     const p = serveCommand(
       config,
@@ -540,36 +653,11 @@ describe('--runtime llama.cpp', () => {
     expect(process.exitCode).toBeFalsy();
   });
 
-  it('health-checks /health (not /models)', async () => {
-    api.callApi
-      .mockResolvedValueOnce(makeServeDep())
-      .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,
-      ['--runtime', 'llama.cpp', '--hf-repo', HF_REPO, '--hf-file', HF_FILE, '--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('records deployment and receipt as ready on success', async () => {
     api.callApi
       .mockResolvedValueOnce(makeServeDep())
-      .mockResolvedValueOnce({ status: 'running' });
-
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, health_path: '/health' });
 
     const p = serveCommand(
       config,
@@ -591,7 +679,6 @@ describe('--runtime llama.cpp', () => {
   it('merges user --env with HF env vars', async () => {
     // --no-wait: only POST /serve called (1 mock needed)
     api.callApi.mockResolvedValueOnce(makeServeDep());
-    global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200 });
 
     const p = serveCommand(
       config,
@@ -613,24 +700,20 @@ describe('--runtime llama.cpp', () => {
 // 12. E2E smoke test — tiny HF GGUF (ggml-org/tiny-llamas / stories260K.gguf)
 //
 // Uses a real, publicly-available tiny GGUF (~1 MB) to verify the full
-// request lifecycle: arg parsing → correct serve body → /health polling →
-// receipt recorded as ready → OpenAI-compatible base URL returned.
+// request lifecycle: arg parsing → correct serve body → readiness polling via
+// Badgr's own deployment status → receipt recorded as ready → OpenAI-compatible
+// base URL returned.
 // ─────────────────────────────────────────────────────────────────────────────
 
 describe('llama.cpp E2E smoke — tiny GGUF (ggml-org/tiny-llamas)', () => {
   const TINY_REPO = 'ggml-org/tiny-llamas';
   const TINY_FILE = 'stories260K.gguf';
 
-  it('full lifecycle: arg parse → serve body → /health → ready receipt', async () => {
+  it('full lifecycle: arg parse → serve body → readiness poll → ready receipt', async () => {
     api.callApi
       .mockResolvedValueOnce(makeServeDep({ model: undefined }))  // 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 });
-    });
+      .mockResolvedValueOnce({ status: 'running' })                 // pre-health dep check
+      .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, health_path: '/health' });
 
     const p = serveCommand(
       config,
@@ -650,10 +733,6 @@ describe('llama.cpp E2E smoke — tiny GGUF (ggml-org/tiny-llamas)', () => {
     expect(body.env.LLAMA_ARG_HF_FILE).toBe(TINY_FILE);
     expect(body.model).toBeUndefined();
 
-    // Readiness check hits /health, not /models
-    expect(fetchedUrls.some(u => u.includes('/health'))).toBe(true);
-    expect(fetchedUrls.some(u => u.endsWith('/models'))).toBe(false);
-
     // Receipt finalised as ready with endpoint URL
     expect(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({
       status: 'ready',
@@ -669,16 +748,11 @@ describe('llama.cpp E2E smoke — tiny GGUF (ggml-org/tiny-llamas)', () => {
 // ─────────────────────────────────────────────────────────────────────────────
 
 describe('--task routing for managed runtimes', () => {
-  it('--task transcribe polls /health instead of /models', async () => {
+  it('--task transcribe becomes ready via backend readiness (health_path=/health)', 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 });
-    });
+      .mockResolvedValueOnce({ status: 'running' })                  // pre-health dep check
+      .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, health_path: '/health' });
 
     const p = serveCommand(
       config,
@@ -688,14 +762,12 @@ describe('--task routing for managed runtimes', () => {
     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(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({ status: 'ready' }));
     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,
@@ -711,16 +783,11 @@ describe('--task routing for managed runtimes', () => {
     expect(process.exitCode).toBeFalsy();
   });
 
-  it('--task image polls /health instead of /models', async () => {
+  it('--task image becomes ready via backend readiness (health_path=/health)', 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 });
-    });
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, health_path: '/health' });
 
     const p = serveCommand(
       config,
@@ -730,14 +797,12 @@ describe('--task routing for managed runtimes', () => {
     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(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({ status: 'ready' }));
     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,
@@ -753,16 +818,11 @@ describe('--task routing for managed runtimes', () => {
     expect(process.exitCode).toBeFalsy();
   });
 
-  it('--task embed still polls /models (vLLM path)', async () => {
+  it('--task embed becomes ready via backend readiness (health_path=/v1/models)', 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 });
-    });
+      .mockResolvedValueOnce({ status: 'running' })
+      .mockResolvedValueOnce(readyStatus());
 
     const p = serveCommand(
       config,
@@ -772,8 +832,7 @@ describe('--task routing for managed runtimes', () => {
     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(store.updateReceipt).toHaveBeenCalledWith('rcpt-serve-001', expect.objectContaining({ status: 'ready' }));
     expect(process.exitCode).toBeFalsy();
   });
 });

package/tests/template.test.js

@@ -327,18 +327,21 @@ describe('parseTemplateOverrides', () => {
 // Sequence for serveCommand:
 //   callApi('/serve', ...) → dep  (via callWithFallback → callApi)
 //   callApi('/deployments/<id>', ...) → { status: 'running' }  (pre-health check)
-//   global.fetch(endpoint + health_path) → { ok: true }
+//   callApi('/deployments/<id>', ...) → { status: 'running', endpoint_ready: true }  (waitForEndpoint poll)
+//
+// Readiness comes entirely from Badgr's own deployment status — the CLI never
+// fetches the pod/RunPod-proxy endpoint directly.
 
-function setupServe(depOverrides = {}) {
+function setupServe(depOverrides = {}, readyOverrides = {}) {
   api.callApi
     .mockResolvedValueOnce(makeServeDep(depOverrides))  // POST /serve
-    .mockResolvedValueOnce({ status: 'running' });      // pre-health dep status
-  global.fetch = vi.fn().mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
+    .mockResolvedValueOnce({ status: 'running' })        // pre-health dep status
+    .mockResolvedValueOnce({ status: 'running', endpoint_ready: true, ...readyOverrides }); // waitForEndpoint poll
 }
 
 describe('badgr serve template <name>', () => {
-  it('vllm: dispatches with correct image, max_cost_usd, and health check on /v1/models', async () => {
-    setupServe();
+  it('vllm: dispatches with correct image, max_cost_usd, and readiness on /v1/models', async () => {
+    setupServe({}, { health_path: '/v1/models' });
     const p = serveCommand(config, ['template', 'vllm', '--max-cost', '5'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
@@ -347,22 +350,17 @@ describe('badgr serve template <name>', () => {
     expect(route).toBe('/serve');
     expect(opts.body.image).toBe('vllm/vllm-openai:latest');
     expect(opts.body.max_cost_usd).toBe(5);
-    // health check fetch should use the /v1/models path from the template
-    const fetchUrl = global.fetch.mock.calls[0]?.[0] ?? '';
-    expect(fetchUrl).toContain('/v1/models');
     expect(process.exitCode).toBeFalsy();
   });
 
-  it('comfyui: dispatches with ComfyUI image and health check on /system_stats', async () => {
-    setupServe();
+  it('comfyui: dispatches with ComfyUI image and readiness on /system_stats', async () => {
+    setupServe({}, { health_path: '/system_stats' });
     const p = serveCommand(config, ['template', 'comfyui', '--max-cost', '3'], chalk);
     await vi.advanceTimersByTimeAsync(5000);
     await p;
 
     const [, opts] = api.callApi.mock.calls[0];
     expect(opts.body.image).toBe('yanwk/comfyui-boot:cu126-megapak');
-    const fetchUrl = global.fetch.mock.calls[0]?.[0] ?? '';
-    expect(fetchUrl).toContain('/system_stats');
     expect(process.exitCode).toBeFalsy();
   });