badgr-cli 1.0.0

package/HOW_IT_WORKS.md

@@ -0,0 +1,245 @@
+# badgr-cli — How It Works
+
+The `badgr` command is the single interface for provisioning and managing GPU compute on Badgr. You run one command, it finds the cheapest available GPU across Vast.ai / RunPod / SaladCloud, deploys your workload, and hands back an OpenAI-compatible endpoint URL and a receipt.
+
+---
+
+## Setup
+
+```bash
+npm install -g badgr-cli
+badgr login
+```
+
+`badgr login` prompts for your API key and base URL, then writes them to `~/.gpu/config.json`. Every subsequent command reads that file — no env vars required.
+
+---
+
+## The 5 Core Commands
+
+### `badgr serve` — Provision
+
+The main command. Two workload modes:
+
+| Mode | What it does |
+|------|-------------|
+| `endpoint` | Deploys a vLLM inference server, returns an OpenAI-compatible base URL |
+| `job` | Runs a one-off container and exits |
+
+**Flags:**
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--endpoint` | — | Shorthand for `--type endpoint` |
+| `--job` | — | Shorthand for `--type job` |
+| `--model <id>` | `meta-llama/Llama-3.1-8B-Instruct` | LLM model for endpoint mode |
+| `--image <img>` | `vllm/vllm-openai:latest` | Docker image for job mode |
+| `--gpu <type>` | `RTX_4090` | GPU type (see GPU catalog below) |
+| `--count <n>` | `1` | Number of GPUs (1–8) |
+| `--region US\|EU\|AU` | `US` | Region preference |
+| `--max-price <$/hr>` | none | Hard cap on GPU-hour price |
+| `--name <name>` | auto-generated | Human-readable deployment name |
+| `--dry-run` | — | Preview route plan without provisioning |
+
+**Example — the target command from the spec:**
+
+```bash
+badgr serve --endpoint --model meta-llama/Llama-3.3-70B --gpu L40S
+```
+
+Output:
+```
+✓ Provisioned
+
+  Deployment:  dep-a3f1bc20
+  Name:        l40s-a3f1bc
+  Type:        endpoint
+  Model:       meta-llama/Llama-3.3-70B
+  GPU:         L40S × 1
+  Provider:    vastai
+  Endpoint:    https://api.gpu.ai/v1
+  Rate:        $1.10/hr
+
+  Receipt ID:  rcpt-8d4e2f1a90
+
+  Use with OpenAI client:
+    client = OpenAI(api_key="sk-...", base_url="https://api.gpu.ai/v1")
+    # model: "meta-llama/Llama-3.3-70B"
+```
+
+**Dry run:**
+
+```bash
+badgr serve --endpoint --model X --gpu RTX_4090 --dry-run
+```
+
+```
+🔍 Dry Run — Route Plan
+
+  Spec
+  ────────────────────────────────────────
+  type:    endpoint
+  model:   X
+  gpu:     RTX_4090 × 1
+  region:  US
+
+  Lane 1 — Own GPU Hosts
+  ────────────────────────────────────────
+  checked at runtime against live worker pool
+
+  Lane 2 — Overflow Providers  (cheapest-first)
+  ────────────────────────────────────────
+  1. vastai       RTX_4090    $0.65/hr  reliability: 94% ← primary
+  2. runpod       RTX_4090    $0.72/hr  reliability: 97%
+  3. tensordock   RTX_4090    $0.81/hr  reliability: 91%
+  4. salad        RTX_4090    $0.89/hr  reliability: 89%
+
+  Estimated range: $0.65–$0.89/hr
+  With 25% overhead (startup risk + badgr margin): ~$0.81/hr
+```
+
+---
+
+### `badgr down` — Terminate
+
+```bash
+badgr down <name|id>
+```
+
+Stops the deployment, removes it from local state, and writes a termination receipt.
+
+---
+
+### `badgr status` — Active Deployments
+
+```bash
+badgr status
+```
+
+Prints a table of everything currently provisioned: name, type, GPU, provider, status, and rate. Endpoint deployments also show their base URL.
+
+---
+
+### `badgr logs` — Logs
+
+```bash
+badgr logs <name|id> [--follow]
+```
+
+For **endpoint** deployments: shows the receipts URL (per-request cost/route/latency records from the API).
+
+For **job** deployments: directs you to `badgr receipts` for the execution record.
+
+Live log streaming (`--follow`) requires a running backend connection.
+
+---
+
+### `badgr receipts` — Cost & Route Records
+
+```bash
+badgr receipts [n]        # default: last 10
+```
+
+Shows two sets of receipts:
+
+1. **CLI action receipts** — every `badgr serve` / `badgr down` recorded locally in `~/.gpu/deployments.json`, with provider, retries, latency, and cost.
+2. **Inference receipts** — per-request records fetched from `GET /v1/receipts` on the API (requires `badgr login`).
+
+Every action — including failures — generates a receipt. Receipt IDs are printed on every command output so you can look them up later.
+
+---
+
+## How Routing Works
+
+When you run `badgr serve`, the system tries providers in lane order, cheapest-first within each lane:
+
+```
+Lane 1 — Own GPU Hosts (AI Badgr workers)
+  Checked at runtime against the live worker pool.
+  Highest margin; used first when capacity is available.
+
+Lane 2 — Overflow Providers
+  Queried in parallel: Vast.ai, RunPod, TensorDock, SaladCloud
+  Sorted by price ascending.
+  A 25% overhead is added (startup risk + failure buffer + Badgr margin).
+  Max-price cap applied if --max-price was set.
+
+Lane 3 — Enterprise Fallback
+  Lambda, CoreWeave, Crusoe — manual approval required.
+```
+
+The dry-run output shows exactly which providers will be tried and in what order before any resources are created.
+
+---
+
+## GPU Catalog
+
+| ID | Canonical | VRAM | Rate/hr | Good for |
+|----|-----------|------|---------|----------|
+| `rtx-3080` | RTX_3080 | 10 GB | $0.35 | dev, inference |
+| `rtx-4090` | RTX_4090 | 24 GB | $1.10 | inference, training |
+| `l40s` | L40S | 48 GB | $1.40 | inference, training |
+| `a6000` | A6000 | 48 GB | $1.60 | inference, training |
+| `a100-40gb` | A100 | 40 GB | $1.80 | training, inference |
+| `a100-80gb` | A100 | 80 GB | $2.50 | training, large models |
+| `h100` | H100 | 80 GB | $3.50 | training, large models |
+
+GPU type aliases are normalized automatically: `rtx-4090`, `rtx4090`, `4090`, `RTX_4090` all resolve to `RTX_4090`.
+
+---
+
+## Provider Pricing (Lane 2, cheapest-first per GPU)
+
+| GPU | vastai | runpod | tensordock | salad |
+|-----|--------|--------|------------|-------|
+| RTX_4090 | $0.65 | $0.72 | $0.81 | $0.89 |
+| L40S | $1.10 | $1.25 | — | $1.40 |
+| A6000 | $1.05 | $1.20 | — | $1.35 |
+| A100 | $1.35 | $1.20 | $1.50 | — |
+| H100 | $3.10 | $2.80 | — | — |
+
+---
+
+## Local State
+
+All CLI state lives in `~/.gpu/`:
+
+```
+~/.gpu/
+  config.json          API key + base URL
+  deployments.json     Active deployments + receipt log (last 200)
+```
+
+`deployments.json` is updated on every `badgr serve` / `badgr down`. It's what `badgr status`, `badgr logs`, and `badgr receipts` read from. The backend is the source of truth for inference receipts — local state only covers provisioning actions.
+
+---
+
+## OpenAI Compatibility
+
+Every endpoint deployment returns a base URL. Point any OpenAI-compatible client at it:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    api_key="sk-your-key",
+    base_url="https://api.gpu.ai/v1",   # from `badgr serve` output
+)
+
+response = client.chat.completions.create(
+    model="meta-llama/Llama-3.1-8B-Instruct",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+No other code changes needed — it's a drop-in base URL swap.
+
+---
+
+## Other Commands
+
+```bash
+badgr models      # List GPU options + available LLM models from the API
+badgr config      # Show current config (API key masked)
+badgr run <script>  # Quick one-off job alias
+```

package/README.md

@@ -0,0 +1,147 @@
+# badgr-cli
+
+Run or serve GPU workloads from one command.
+
+```bash
+npm install -g badgr-cli
+```
+
+---
+
+## Quick start
+
+```bash
+# 1. Authenticate once
+badgr login
+
+# 2. Serve an OpenAI-compatible inference endpoint
+badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
+
+# 3. Use the endpoint with any OpenAI SDK client
+#    client = OpenAI(api_key="sk-...", base_url="https://dep-xyz.api.badgr.ai/v1")
+
+# 4. View cost, provider, and route receipts
+badgr receipts
+
+# 5. Stop billing
+badgr down <deployment-id>
+```
+
+---
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `badgr login` | Save API key to `~/.badgr/config.json` |
+| `badgr serve <model>` | Persistent OpenAI-compatible endpoint |
+| `badgr run <command>` | One-off GPU job (container) |
+| `badgr down <id>` | Terminate a deployment — stops billing |
+| `badgr logs <id>` | Tail logs for a deployment |
+| `badgr receipts [n]` | Cost / route / retry receipts (default 10) |
+
+---
+
+## `badgr serve` options
+
+```bash
+badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S --region EU
+```
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--gpu <type>` | RTX_4090 | GPU: RTX_4090, L40S, A6000, A100, H100 |
+| `--region US\|EU\|AU` | US | Region preference |
+| `--count <n>` | 1 | Number of GPUs (1–8) |
+| `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
+| `--dry-run` | — | Preview routing without provisioning |
+
+---
+
+## `badgr run` options
+
+```bash
+badgr run python train.py --gpu A100 --env HF_TOKEN=$HF_TOKEN
+```
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--gpu <type>` | RTX_4090 | GPU type |
+| `--image <img>` | python:3.11-slim | Docker image |
+| `--env KEY=VALUE` | — | Environment variable (repeatable) |
+| `--region US\|EU\|AU` | US | Region preference |
+| `--max-price <$/hr>` | — | Hard spend cap per GPU-hour |
+| `--detach` | — | Launch and return immediately |
+
+---
+
+## Routing
+
+Badgr searches providers in order: own GPU hosts → Vast.ai → RunPod → TensorDock → SaladCloud. It picks the cheapest available instance that meets the GPU and region spec, then adds ~25% for routing margin and startup risk.
+
+Preview routing before committing:
+
+```bash
+badgr serve mistral-7b --gpu RTX_4090 --dry-run
+```
+
+---
+
+## Receipts
+
+Every `badgr serve` and `badgr run` action generates a receipt:
+
+```bash
+badgr receipts        # last 10
+badgr receipts 50     # last 50
+```
+
+Each receipt includes: receipt ID, provider, GPU, provisioning latency, rate/hr, and retry count.
+
+---
+
+## OpenAI compatibility
+
+`badgr serve` provisions a vLLM endpoint that is fully OpenAI-compatible:
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    api_key="your-badgr-api-key",
+    base_url="https://dep-xyz.api.badgr.ai/v1",  # from badgr serve output
+)
+resp = client.chat.completions.create(
+    model="meta-llama/Llama-3.1-8B-Instruct",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+```
+
+```js
+import OpenAI from "openai";
+const client = new OpenAI({
+  apiKey: process.env.BADGR_API_KEY,
+  baseURL: "https://dep-xyz.api.badgr.ai/v1",
+});
+```
+
+---
+
+## GPU options
+
+| Flag value | GPU | VRAM | Est. rate/hr |
+|-----------|-----|------|-------------|
+| RTX_4090 | NVIDIA RTX 4090 | 24 GB | $0.65–0.89 |
+| L40S | NVIDIA L40S | 48 GB | $1.10–1.40 |
+| A6000 | NVIDIA RTX A6000 | 48 GB | $1.05–1.35 |
+| A100 | NVIDIA A100 | 80 GB | $1.20–1.50 |
+| H100 | NVIDIA H100 | 80 GB | $2.80–3.10 |
+
+Rates are provider-level. Badgr adds ~25% for routing and startup risk.
+
+---
+
+## Requirements
+
+- Node.js 18+
+- A Badgr account — sign up at [badgr.ai](https://badgr.ai)

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "badgr-cli",
+  "version": "1.0.0",
+  "description": "Badgr — run or serve GPU workloads from one command",
+  "type": "module",
+  "bin": {
+    "badgr": "./src/badgr.js"
+  },
+  "scripts": {
+    "start": "node src/badgr.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^5.1.0",
+    "chalk": "^5.3.0"
+  },
+  "devDependencies": {
+    "vitest": "^1.6.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": ["gpu", "cli", "ai", "compute", "modal", "gateway", "openai"],
+  "license": "MIT"
+}

package/src/api.js

@@ -0,0 +1,120 @@
+export async function callApi(path, { method = 'GET', apiKey, baseUrl, body } = {}) {
+  const url = `${baseUrl}${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`${method} ${path} → ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+
+// ---- Core: run & serve (POST /v1/run, POST /v1/serve) ----------------------
+
+export function runJob(config, body) {
+  return callApi('/run', {
+    method: 'POST',
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    body,
+  });
+}
+
+export function serveModel(config, body) {
+  return callApi('/serve', {
+    method: 'POST',
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    body,
+  });
+}
+
+// ---- Deployments (POST/GET/DELETE /v1/deployments) --------------------------
+
+export function createDeployment(config, spec) {
+  return callApi('/deployments', {
+    method: 'POST',
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    body: spec,
+  });
+}
+
+export function listDeployments(config) {
+  return callApi('/deployments', { apiKey: config.apiKey, baseUrl: config.baseUrl });
+}
+
+export function getDeployment(config, deploymentId) {
+  return callApi(`/deployments/${deploymentId}`, { apiKey: config.apiKey, baseUrl: config.baseUrl });
+}
+
+export function terminateDeployment(config, deploymentId) {
+  return callApi(`/deployments/${deploymentId}`, {
+    method: 'DELETE',
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+  });
+}
+
+export function getDeploymentLogs(config, deploymentId) {
+  return callApi(`/deployments/${deploymentId}/logs`, { apiKey: config.apiKey, baseUrl: config.baseUrl });
+}
+
+// ---- Receipts ---------------------------------------------------------------
+
+export function listReceipts(config, { limit = 20, status, fromTs, toTs } = {}) {
+  const params = new URLSearchParams();
+  if (limit)  params.set('limit', String(limit));
+  if (status) params.set('status', status);
+  if (fromTs) params.set('from_timestamp', String(fromTs));
+  if (toTs)   params.set('to_timestamp', String(toTs));
+  const qs = params.toString();
+  return callApi(`/receipts${qs ? `?${qs}` : ''}`, {
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+  });
+}
+
+export function getReceipt(config, receiptId) {
+  return callApi(`/receipts/${receiptId}`, {
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+  });
+}
+
+// ---- Inference --------------------------------------------------------------
+
+export function listModels(config) {
+  return callApi('/models', { apiKey: config.apiKey, baseUrl: config.baseUrl });
+}
+
+export function chatCompletion(config, messages, options = {}) {
+  const { model, stream = false } = options;
+  return callApi('/chat/completions', {
+    method: 'POST',
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    body: { model: model ?? config.defaultModel, messages, stream },
+  });
+}
+
+// ---- Legacy job routes (kept for backward compat) ---------------------------
+
+export function submitJob(config, job) {
+  return callApi('/jobs', {
+    method: 'POST',
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    body: job,
+  });
+}
+
+export function getJobStatus(config, jobId) {
+  return callApi(`/jobs/${jobId}`, { apiKey: config.apiKey, baseUrl: config.baseUrl });
+}

package/src/badgr.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from './config.js';
+import { loginCommand }    from './commands/login.js';
+import { upCommand }       from './commands/up.js';
+import { downCommand }     from './commands/down.js';
+import { statusCommand }   from './commands/status.js';
+import { logsCommand }     from './commands/logs.js';
+import { receiptsCommand } from './commands/receipts.js';
+import { runCommand }      from './commands/run.js';
+import { serveCommand }    from './commands/serve.js';
+import { modelsCommand }   from './commands/models.js';
+
+const HELP = `
+${chalk.bold('badgr')} — run or serve GPU workloads from one command
+
+${chalk.bold('CORE COMMANDS')}
+  ${chalk.cyan('badgr login')}                         Authenticate (save API key to ~/.badgr/config.json)
+  ${chalk.cyan('badgr run <cmd...> --gpu <type>')}     Run a one-off GPU job
+  ${chalk.cyan('badgr serve <model> --gpu <type>')}    Serve a model (OpenAI-compatible endpoint)
+  ${chalk.cyan('badgr status')}                        Show active deployments + endpoint URLs
+  ${chalk.cyan('badgr logs <id>')}                     Stream logs for a deployment
+  ${chalk.cyan('badgr down <id>')}                     Terminate a deployment (stop billing)
+  ${chalk.cyan('badgr receipts [<id>|<n>]')}           Show receipts — pass ID for single, number for list
+
+${chalk.bold('badgr run OPTIONS')}
+  --gpu <type>        GPU: RTX_4090, A100, L40S, H100  (default: RTX_4090)
+  --image <image>     Docker image (default: python:3.11-slim)
+  --count <n>         GPU count (default: 1)
+  --region US|EU|AU   Region preference (default: US)
+  --max-price <$/hr>  Hard spend cap per GPU-hour
+  --name <name>       Job name (auto-generated if omitted)
+
+${chalk.bold('badgr serve OPTIONS')}
+  --gpu <type>        GPU: L40S, A100, H100, RTX_4090  (default: L40S)
+  --count <n>         GPU count (default: 1)
+  --region US|EU|AU   Region preference (default: US)
+  --max-price <$/hr>  Hard spend cap per GPU-hour
+  --name <name>       Deployment name (auto-generated if omitted)
+
+${chalk.bold('EXAMPLES')}
+  badgr login
+  badgr run python train.py --gpu A100
+  badgr run --image my/image:latest --gpu L40S
+  badgr serve meta-llama/Llama-3.1-8B-Instruct --gpu L40S
+  badgr serve mistralai/Mistral-7B-v0.1 --gpu RTX_4090
+  badgr status
+  badgr logs dep_abc123
+  badgr down dep_abc123
+  badgr receipts
+  badgr receipts dep_abc123
+
+${chalk.bold('OPENAI-COMPATIBLE SERVING')}
+  ${chalk.dim('After `badgr serve`, point any OpenAI client at the returned URL:')}
+  ${chalk.dim('  client = OpenAI(api_key="sk-...", base_url="https://api.badgr.ai/v1")')}
+  ${chalk.dim('  client.chat.completions.create(model="dep_xxx", messages=[...])')}
+
+${chalk.bold('PROVIDER ROUTING')}
+  ${chalk.dim('own GPUs → Vast.ai / Salad / RunPod overflow → manual enterprise fallback')}
+`;
+
+async function main() {
+  const [,, cmd, ...rest] = process.argv;
+  const config = loadConfig();
+
+  if (!cmd || cmd === '--help' || cmd === '-h') {
+    console.log(HELP);
+    return;
+  }
+
+  switch (cmd) {
+    case 'login':    return loginCommand(chalk, saveConfig);
+    case 'run':      return runCommand(config, rest, chalk);
+    case 'serve':    return serveCommand(config, rest, chalk);
+    case 'status':   return statusCommand(config, rest, chalk);
+    case 'logs':     return logsCommand(config, rest, chalk);
+    case 'down':     return downCommand(config, rest, chalk);
+    case 'receipts': return receiptsCommand(config, rest, chalk);
+    case 'models':   return modelsCommand(config, chalk);
+    // legacy aliases kept for compatibility
+    case 'up':       return upCommand(config, rest, chalk);
+    case 'config': {
+      const { apiKey, ...safe } = config;
+      const display = { ...safe, apiKey: apiKey ? `${apiKey.slice(0, 8)}...` : '(not set)' };
+      console.log('\nCurrent config:\n');
+      console.log(JSON.stringify(display, null, 2));
+      console.log();
+      return;
+    }
+    default:
+      console.error(chalk.red(`Unknown command: ${cmd}\n`));
+      console.log(`Run ${chalk.cyan('badgr --help')} for usage.`);
+      process.exit(1);
+  }
+}
+
+main().catch(err => {
+  console.error(chalk.red('Fatal:'), err.message);
+  process.exit(1);
+});

package/src/commands/deploy.js

@@ -0,0 +1,47 @@
+import { randomUUID } from 'crypto';
+import { findCheapest, findById } from '../router.js';
+import { requireApiKey } from '../config.js';
+
+export function parseDeployArgs(args) {
+  const nameFlag = args.indexOf('--name');
+  const name = nameFlag !== -1 ? args[nameFlag + 1] : null;
+  const gpuFlag = args.indexOf('--gpu');
+  const gpuId = gpuFlag !== -1 ? args[gpuFlag + 1] : null;
+  const cleanArgs = args.filter((a, i) => {
+    if (a === '--name' || a === '--gpu') return false;
+    if (i > 0 && (args[i - 1] === '--name' || args[i - 1] === '--gpu')) return false;
+    return true;
+  });
+  const script = cleanArgs.find(a => !a.startsWith('--')) ?? null;
+  return { script, name, gpuId };
+}
+
+export async function deployCommand(config, args, chalk) {
+  const { script, name: rawName, gpuId } = parseDeployArgs(args);
+
+  if (!script) {
+    console.error(chalk.red('Usage: gpu deploy <script.py> [--name <name>] [--gpu <type>]'));
+    return;
+  }
+
+  requireApiKey(config);
+
+  const deployId = randomUUID().split('-')[0];
+  const name = rawName ?? script.replace(/[^a-z0-9]/gi, '-').replace(/-+/g, '-').toLowerCase();
+  const gpu = gpuId ? findById(gpuId) : findCheapest({ tag: 'inference' });
+  const endpointBase = config.baseUrl.replace(/\/v1\/?$/, '');
+  const endpointUrl = `${endpointBase}/endpoints/${name}-${deployId}`;
+
+  console.log(chalk.bold('\n🚀 Deploying\n'));
+  console.log(`  ${chalk.bold('Script:')}    ${script}`);
+  console.log(`  ${chalk.bold('Name:')}      ${name}-${deployId}`);
+  if (gpu) console.log(`  ${chalk.bold('GPU:')}       ${gpu.name}  ${chalk.dim(`$${gpu.ratePerHour}/hr`)}`);
+  console.log();
+
+  // Real implementation: POST /deployments to backend
+  console.log(chalk.green('✓ Deployed!\n'));
+  console.log(`  ${chalk.bold('Endpoint:')}  ${chalk.cyan(endpointUrl)}`);
+  console.log(`  ${chalk.bold('Logs:')}      gpu logs ${name}-${deployId}`);
+  console.log(`\n  ${chalk.dim('OpenAI-compatible — point your client at this URL.')}\n`);
+  return { endpointUrl, deployId, name: `${name}-${deployId}` };
+}