soup-cli 0.71.32__tar.gz → 0.71.33__tar.gz

{soup_cli-0.71.32 → soup_cli-0.71.33}/CHANGELOG.md

@@ -12,6 +12,100 @@ reproducing 70+ versions of notes.
 
 ## [Unreleased]
 
+## [0.71.33] - 2026-07-13
+
+### Added
+- **`soup draft` — train and, above all, MEASURE a speculative-decoding draft model.**
+  - `soup draft measure --target <m> --draft <d> --prompts p.jsonl` reports a draft's
+    **acceptance rate** (the fraction of the target's own greedy tokens the draft
+    would have proposed correctly) plus **real plain-vs-assisted throughput**. This is
+    the honest gate: it tells you whether speculative decoding is worth enabling
+    *before* you ship it. Exit 0 / 2 (below `--min-acceptance`, for CI) / 1.
+  - `soup draft distill --target <tuned> --draft-base <tiny> --data d.jsonl -o draft/`
+    distils your target into the tiny base (logit KD via the existing `task: distill`
+    trainer) and emits a **dense** draft model, ready to load as an `assistant_model`.
+  - `soup draft list`, plus a local draft registry (`~/.soup/drafts.json`) that
+    `soup serve --auto-spec` consults **before** the built-in pairing table — so a
+    draft you trained yourself is picked up automatically.
+  - Draft and target must share a tokenizer; a mismatched pair is refused up front
+    (speculative decoding proposes draft token ids into the target's vocabulary, so a
+    mismatch silently produces garbage rather than failing).
+
+  **Read the measured results before you use this** — see *Known limitations* below.
+  On the validated pair, distillation did **not** improve acceptance, and speculative
+  decoding was a net **slowdown**. `soup draft measure` is what tells you that.
+
+### Known limitations
+- **Distilling a draft did not improve its acceptance rate on the validated pair.**
+  Measured on `SmolLM2-360M-Instruct` (target) with a `SmolLM2-135M-Instruct` draft:
+  the *stock* draft already scored **69.3%**, and distilling it moved that to 69.7%
+  after 2 epochs and back to **69.3%** after 10 epochs — i.e. no gain beyond noise.
+  A small same-family draft is already near its capacity ceiling for agreeing with
+  the target, and logit KD cannot buy capacity it does not have. Whether distillation
+  materially raises acceptance for a genuinely diverged fine-tune, or a larger
+  target/draft pair, is **unproven** on a 4 GB box — tracked as a scale issue.
+- **Speculative decoding was a net slowdown on that pair** (measured 0.55–0.64×): the
+  draft's forward pass costs more than the tokens it saves at this size.
+  `soup draft measure` reports this truthfully rather than assuming a speedup — which
+  is precisely the point of shipping the measurement.
+- **Acceptance is teacher-forced greedy agreement**, the metric the Medusa/EAGLE
+  papers report. It is exact and deterministic, and it is the right number for
+  comparing drafts — but it is not the accepted-token count of a *sampling* run, which
+  also depends on the rejection-resample cascade.
+- **Same-tokenizer only.** Cross-tokenizer drafts (ULD-aligned + universal assisted
+  decoding) are deferred.
+
+### Changed
+- **PRM-guided GRPO scores completions in a single batched forward.**
+  `PRMScorer.__call__` now right-pads all completions into one `[B, T]` tensor
+  (+ attention mask) and runs one `output_hidden_states` pass instead of one
+  forward per completion, cutting per-step reward latency on non-tiny models.
+  Numerically identical to the per-completion path (parity + mixed-length tests).
+  Closes #298
+  ([#301](https://github.com/MakazhanAlpamys/Soup/pull/301) by [@Ekaanksh-dev](https://github.com/Ekaanksh-dev)).
+
+### Fixed
+- **The hardware-fit gate no longer refuses to train small models.**
+  `model_size_from_name` did not understand an `M` (millions) suffix, so
+  `SmolLM2-135M` fell through to the 7B default, was predicted to need ~14 GB of
+  weights, and was blocked. Every draft-sized model hit this. `1.7B` was also being
+  read as `7B` (the `7b` marker matched inside `1.7b`), while `Qwen2.5-7B-Instruct-1M`
+  correctly stays 7B (1M is the *context*, not the parameter count).
+- **`soup serve --backend vllm` no longer force-enables `trust_remote_code`.** The
+  vLLM path now goes through the same `--trust-remote-code` default-deny gate (and
+  warning panel) as the transformers backend, so serving an untrusted repo never
+  executes its code silently.
+- **Multi-adapter serving (`soup serve --adapters name=path`) now actually switches
+  adapters.** The named adapters are loaded into the model and selected per request
+  (via `POST /v1/adapters/activate/{name}` or the request `adapter` field);
+  previously every request silently ran the startup model. The base model is served
+  when no adapter is selected.
+- **Vision datasets reject out-of-directory image paths.** `llava` / `sharegpt4v`
+  rows are containment-checked against `image_dir` (mirroring the audio loader), so a
+  crafted `{"image": "/etc/passwd"}` row can no longer read arbitrary local files.
+- **`soup train --dry-run --gpus N` no longer launches a real multi-GPU run.** The
+  accelerate re-exec is skipped under `--dry-run`. The re-exec also now forwards
+  `--minillm-on-policy`, `--capture-activations`, and `--capture-prompts` (previously
+  dropped on multi-GPU runs).
+- **MLX SFT now builds a real optimizer** (`AdamW` from the configured LR) instead of
+  passing `optimizer=None`, which left the model untrained.
+- **`soup data inspect` / `preview` / `search` escape dataset- and Hub-derived text**
+  so a stray `[/]` no longer crashes the command and a crafted `[link=…]` tag can't
+  render a phishing hyperlink. `soup runs` list/show escape config-derived fields too.
+- **`soup infer --task asr` hardening** — an oversized reference no longer crashes the
+  whole batch after transcription (that row's metric is skipped); an all-skipped run
+  exits non-zero instead of reporting success; `--asr-task` is validated upfront; and
+  dataset-derived filenames are control-stripped before printing. ASR training now
+  caps transcript labels to Whisper's decoder limit, warns on >30 s audio, and picks
+  fp16 on pre-Ampere GPUs instead of hardcoding bf16.
+- **Knowledge-distillation KD term aligns with the CE term.** The token-level
+  divergence is now computed over causal-shifted positions, so the distillation signal
+  covers exactly the trained tokens (previously off by one).
+- **Miscellaneous robustness** — `load_config_from_string` raises `ValueError` (not
+  `TypeError`) on a non-mapping YAML document; the Web UI Bearer-token check is
+  constant-time; and `soup doctor --vscode` / the LR-finder report use the centralised
+  atomic, symlink-rejecting writer.
+
 ## [0.71.32] - 2026-07-07
 
 ### Added

{soup_cli-0.71.32 → soup_cli-0.71.33}/CONTRIBUTING.md

@@ -120,7 +120,7 @@ src/soup_cli/
   templates/          - 17 built-in soup.yaml templates (YAML + manifest.json) with load_template loader (v0.39.0, +bco v0.40.0)
   ui/                 - Web UI (FastAPI + HTML/JS SPA)
 
-tests/                - Test suite (309 files, 15663 tests)
+tests/                - Test suite (311 files, 15806 tests)
 examples/             - Real-world config examples and datasets
 ```
 

{soup_cli-0.71.32 → soup_cli-0.71.33}/CONTRIBUTORS.md

@@ -50,6 +50,8 @@ Listed by first contribution. PR numbers link the work.
   - Reuse the shared vocab-expansion helper in the vision + audio SFT paths ([#291](https://github.com/MakazhanAlpamys/Soup/pull/291))
   - Honor configured vocab expansion in the DPO / IPO / KTO / BCO trainers ([#293](https://github.com/MakazhanAlpamys/Soup/pull/293))
   - Honor configured vocab expansion in the ORPO / SimPO / GRPO trainers ([#295](https://github.com/MakazhanAlpamys/Soup/pull/295))
+- **Ekaanksh Patil** ([@Ekaanksh-dev](https://github.com/Ekaanksh-dev))
+  - Batch the PRM reward forward pass in `PRMScorer.__call__` (single `[B, T]` forward) ([#301](https://github.com/MakazhanAlpamys/Soup/pull/301))
 
 ---
 

{soup_cli-0.71.32 → soup_cli-0.71.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soup-cli
-Version: 0.71.32
+Version: 0.71.33
 Summary: Fine-tune and post-train LLMs in one command. No SSH, no config hell.
 Project-URL: Homepage, https://github.com/MakazhanAlpamys/Soup
 Project-URL: Repository, https://github.com/MakazhanAlpamys/Soup
@@ -193,23 +193,35 @@ infrastructure instead of improving models. Soup fixes that.
 
 ## What's New
 
-**v0.71.32 — ASR fine-tuning (Whisper).** Fine-tune Whisper on your accent or domain, locally. whisper-tiny (39M) and base (74M) train on a 4 GB GPU — a new modality that actually runs on a laptop card.
-
-- **`task='asr'`.** A new `AsrTrainerWrapper` (HF `Seq2SeqTrainer` + `WhisperProcessor`). Data rows
-  are `{"audio": <path>, "text": <transcript>}` under `data.format='asr'`; audio decodes to 16 kHz
-  mono through the hardened loader (soundfile pre-probe + symlink/size guards). Opt-in LoRA on q/v
-  via `training.asr_lora: true` (default full fine-tune); `training.asr_language` / `asr_task`
-  (`transcribe`|`translate`) set — and persist — the decoder prefix for inference.
-- **`soup infer --task asr`.** Transcribe an `{"audio"[, "text"]}` JSONL and get per-row + corpus
-  **WER / CER** when references are present. Loads a full model or a LoRA adapter dir; audio paths
-  are containment-checked (traversal / UNC rejected).
-- **Pure-python metrics.** New `soup_cli.utils.asr_metrics` (WER / CER / `word_accuracy` /
-  `corpus_wer`) — no new dependency, reusable as a higher-is-better ship metric leg.
-- **Recipes.** `whisper-tiny-asr` / `whisper-base-asr` (live-trainable), `whisper-large-v3-asr`
-  (parse-only). Catalog 138 → 142.
-- **Proof-of-mechanism, honestly.** Live-validated on an RTX 3050: a memorization task drove
-  WER 1.000 → 0.000 (loss 7.2 → 0.0005 at 0.4/4 GB). Real accent/domain gains need real audio;
-  WER/CER use a light normalizer, not the full Whisper text normalizer.
+**v0.71.33 — `soup draft`: know whether speculative decoding is actually worth it.** Everyone tells you to bolt a draft model onto your server for a free speedup. Nobody tells you to *measure* it first. Now you can.
+
+- **`soup draft measure`.** Reports a draft's **acceptance rate** — the fraction of your target's
+  own greedy tokens the draft would have proposed correctly — plus **real plain-vs-assisted
+  tok/s**. Exit 0 / 2 (below `--min-acceptance`) / 1, so CI can gate on it.
+- **`soup draft distill`.** Distils your tuned target into a tiny draft base (logit KD over the
+  existing `task: distill` trainer) and emits a **dense** model, loadable straight as an
+  `assistant_model`.
+- **Auto-wired into serving.** Drafts land in a local registry that `soup serve --auto-spec`
+  consults *before* the built-in pairing table — so a draft you trained yourself just gets used.
+- **What the measurement actually told us (honestly).** On `SmolLM2-360M-Instruct` ←
+  `SmolLM2-135M-Instruct`: the stock draft already scored **69.3%**, and distilling it changed
+  nothing (69.7% at 2 epochs, 69.3% at 10). Assisted decoding was a **net slowdown** (0.55–0.64×).
+  A small same-family draft is already at its ceiling. **That negative result is the feature
+  working** — it's the number you want *before* you ship speculative decoding, not after.
+  Whether distillation pays off on a larger or genuinely diverged pair is unproven on a 4 GB box.
+
+```bash
+soup draft measure --target ./my-tuned-model --draft HuggingFaceTB/SmolLM2-135M-Instruct \
+  --prompts prod-prompts.jsonl        # -> acceptance %, real tok/s, ship-or-not
+```
+
+<details>
+<summary>Previous release — v0.71.32, ASR fine-tuning (Whisper)</summary>
+
+Fine-tune Whisper on your accent or domain, locally: `task='asr'` (`AsrTrainerWrapper` over HF
+`Seq2SeqTrainer` + `WhisperProcessor`), `soup infer --task asr` with per-row + corpus **WER/CER**,
+pure-python metrics in `soup_cli.utils.asr_metrics`, and 4 new recipes (catalog 138 → 142).
+whisper-tiny (39M) / base (74M) train on a 4 GB GPU.
 
 ```yaml
 base: openai/whisper-tiny
@@ -222,6 +234,8 @@ training:
   asr_lora: true         # optional; default = full fine-tune
 ```
 
+</details>
+
 Full history: [CHANGELOG.md](CHANGELOG.md) &middot; [GitHub Releases](https://github.com/MakazhanAlpamys/Soup/releases).
 
 ## Quick Start

{soup_cli-0.71.32 → soup_cli-0.71.33}/README.md

@@ -49,23 +49,35 @@ infrastructure instead of improving models. Soup fixes that.
 
 ## What's New
 
-**v0.71.32 — ASR fine-tuning (Whisper).** Fine-tune Whisper on your accent or domain, locally. whisper-tiny (39M) and base (74M) train on a 4 GB GPU — a new modality that actually runs on a laptop card.
-
-- **`task='asr'`.** A new `AsrTrainerWrapper` (HF `Seq2SeqTrainer` + `WhisperProcessor`). Data rows
-  are `{"audio": <path>, "text": <transcript>}` under `data.format='asr'`; audio decodes to 16 kHz
-  mono through the hardened loader (soundfile pre-probe + symlink/size guards). Opt-in LoRA on q/v
-  via `training.asr_lora: true` (default full fine-tune); `training.asr_language` / `asr_task`
-  (`transcribe`|`translate`) set — and persist — the decoder prefix for inference.
-- **`soup infer --task asr`.** Transcribe an `{"audio"[, "text"]}` JSONL and get per-row + corpus
-  **WER / CER** when references are present. Loads a full model or a LoRA adapter dir; audio paths
-  are containment-checked (traversal / UNC rejected).
-- **Pure-python metrics.** New `soup_cli.utils.asr_metrics` (WER / CER / `word_accuracy` /
-  `corpus_wer`) — no new dependency, reusable as a higher-is-better ship metric leg.
-- **Recipes.** `whisper-tiny-asr` / `whisper-base-asr` (live-trainable), `whisper-large-v3-asr`
-  (parse-only). Catalog 138 → 142.
-- **Proof-of-mechanism, honestly.** Live-validated on an RTX 3050: a memorization task drove
-  WER 1.000 → 0.000 (loss 7.2 → 0.0005 at 0.4/4 GB). Real accent/domain gains need real audio;
-  WER/CER use a light normalizer, not the full Whisper text normalizer.
+**v0.71.33 — `soup draft`: know whether speculative decoding is actually worth it.** Everyone tells you to bolt a draft model onto your server for a free speedup. Nobody tells you to *measure* it first. Now you can.
+
+- **`soup draft measure`.** Reports a draft's **acceptance rate** — the fraction of your target's
+  own greedy tokens the draft would have proposed correctly — plus **real plain-vs-assisted
+  tok/s**. Exit 0 / 2 (below `--min-acceptance`) / 1, so CI can gate on it.
+- **`soup draft distill`.** Distils your tuned target into a tiny draft base (logit KD over the
+  existing `task: distill` trainer) and emits a **dense** model, loadable straight as an
+  `assistant_model`.
+- **Auto-wired into serving.** Drafts land in a local registry that `soup serve --auto-spec`
+  consults *before* the built-in pairing table — so a draft you trained yourself just gets used.
+- **What the measurement actually told us (honestly).** On `SmolLM2-360M-Instruct` ←
+  `SmolLM2-135M-Instruct`: the stock draft already scored **69.3%**, and distilling it changed
+  nothing (69.7% at 2 epochs, 69.3% at 10). Assisted decoding was a **net slowdown** (0.55–0.64×).
+  A small same-family draft is already at its ceiling. **That negative result is the feature
+  working** — it's the number you want *before* you ship speculative decoding, not after.
+  Whether distillation pays off on a larger or genuinely diverged pair is unproven on a 4 GB box.
+
+```bash
+soup draft measure --target ./my-tuned-model --draft HuggingFaceTB/SmolLM2-135M-Instruct \
+  --prompts prod-prompts.jsonl        # -> acceptance %, real tok/s, ship-or-not
+```
+
+<details>
+<summary>Previous release — v0.71.32, ASR fine-tuning (Whisper)</summary>
+
+Fine-tune Whisper on your accent or domain, locally: `task='asr'` (`AsrTrainerWrapper` over HF
+`Seq2SeqTrainer` + `WhisperProcessor`), `soup infer --task asr` with per-row + corpus **WER/CER**,
+pure-python metrics in `soup_cli.utils.asr_metrics`, and 4 new recipes (catalog 138 → 142).
+whisper-tiny (39M) / base (74M) train on a 4 GB GPU.
 
 ```yaml
 base: openai/whisper-tiny
@@ -78,6 +90,8 @@ training:
   asr_lora: true         # optional; default = full fine-tune
 ```
 
+</details>
+
 Full history: [CHANGELOG.md](CHANGELOG.md) &middot; [GitHub Releases](https://github.com/MakazhanAlpamys/Soup/releases).
 
 ## Quick Start

{soup_cli-0.71.32 → soup_cli-0.71.33}/docs/commands.md

@@ -134,7 +134,7 @@ soup migrate --from llamafactory config.yaml  Import config from LLaMA-Factory
 soup migrate --from axolotl config.yml        Import config from Axolotl
 soup migrate --from unsloth notebook.ipynb    Import config from Unsloth notebook
 soup migrate --from llamafactory c.yaml --dry-run  Preview without writing
-soup recipes list                             List all 138 ready-made recipes
+soup recipes list                             List all 142 ready-made recipes
 soup recipes show llama3.1-8b-sft            Print recipe YAML
 soup recipes use llama3.1-8b-sft             Copy recipe to soup.yaml
 soup recipes search "reasoning"              Search by keyword/task/size
@@ -163,6 +163,11 @@ soup mcp serve --allow-mutating               Also expose plan-only train_start
 soup shrink --model <id|path> --drop-ratio 0.25 --calib c.jsonl -o shrunk  Depth-prune least-important layer block + SHIP/DON'T-SHIP ppl verdict (exit 0/2/1) (v0.71.29)
 soup shrink ... --drop-layers N --heal h.jsonl --heal-steps 200 --device cpu  Drop N layers + distill-heal (fuse LoRA back to one dense model)
 soup shrink ... --tolerance 0.10 --plan-only [--attach-to-registry <id>]  Ppl-regression tolerance / print importance table only / registry attach
+soup draft measure --target <m> --draft <d> --prompts p.jsonl  Draft acceptance rate + real plain-vs-assisted tok/s (exit 0/2/1) (v0.71.33)
+soup draft measure ... --min-acceptance 0.6 -o report.json  Exit 2 below the floor (CI gate) / write the JSON report
+soup draft distill --target <tuned> --draft-base <tiny> --data d.jsonl -o draft/  Distil a DENSE speculative-decoding draft + register it (v0.71.33)
+soup draft distill ... --steps N --device cpu --force --plan-only  Training budget / device / overwrite -o / render the config only
+soup draft list                               List local drafts that `soup serve --auto-spec` will pick up (v0.71.33)
 soup tui                                      Full-screen Textual dashboard (requires [tui] extra)
 soup train --config soup.yaml --profile       Record torch.profiler trace to <output>/profiles/
 soup --log-level quiet|normal|verbose|debug   Global logging tier (Rich-formatted)

{soup_cli-0.71.32 → soup_cli-0.71.33}/docs/serving-and-export.md

@@ -23,6 +23,7 @@
 - [Anthropic Messages API Converter](#anthropic-messages-api-converter)
 - [Server-Side Tools](#server-side-tools)
 - [Anthropic Messages Endpoint](#anthropic-messages-endpoint)
+- [Train + measure your own draft (`soup draft`)](#train--measure-your-own-draft-soup-draft)
 - [N-gram Speculative Decoding](#n-gram-speculative-decoding)
 - [Server-Side Tool Endpoints](#server-side-tool-endpoints)
 
@@ -254,7 +255,10 @@ soup serve --model ./output --backend sglang --tensor-parallel 2
 
 ### Speculative Decoding
 
-Use a smaller draft model to speed up generation (2-3x faster):
+Use a smaller draft model to speed up generation. **Measure before you trust it** — see
+[Train + measure your own draft](#train--measure-your-own-draft-soup-draft) below. Speculative
+decoding is only a win when the draft agrees with the target often enough to pay for its own
+forward pass; on a small target it is frequently a *slowdown*.
 
 ```bash
 # Transformers backend — uses HF assisted generation
@@ -268,7 +272,46 @@ soup serve --model meta-llama/Llama-3.1-70B-Instruct --backend vllm --auto-spec
 # → auto-paired: meta-llama/Llama-3.2-1B-Instruct (target: Llama-3.1-70B-Instruct)
 ```
 
-`--auto-spec` handles Llama 3.1/3.3/4, Qwen 2.5/3, Mistral Large, Mixtral, DeepSeek V3/R1, and Gemma 2/3. Models without a known draft pairing (e.g. 8B-or-smaller targets where draft+target overhead outweighs the gain) print a yellow "no draft" note and fall back to standard decoding.
+`--auto-spec` handles Llama 3.1/3.3/4, Qwen 2.5/3, Mistral Large, Mixtral, DeepSeek V3/R1, and Gemma 2/3. Models without a known draft pairing (e.g. 8B-or-smaller targets where draft+target overhead outweighs the gain) print a yellow "no draft" note and fall back to standard decoding. A draft you trained yourself with `soup draft distill` is picked up **before** this built-in table.
+
+### Train + measure your own draft (`soup draft`)
+
+The question nobody answers before enabling speculative decoding: *would the draft actually
+propose the tokens my model is going to emit?* `soup draft measure` answers it.
+
+```bash
+# Would this draft pay off? Acceptance rate + REAL plain-vs-assisted throughput.
+soup draft measure --target ./my-tuned-model \
+  --draft HuggingFaceTB/SmolLM2-135M-Instruct \
+  --prompts prod-prompts.jsonl
+
+# Distil a draft from your own target, then serve it automatically.
+soup draft distill --target ./my-tuned-model \
+  --draft-base HuggingFaceTB/SmolLM2-135M-Instruct \
+  --data traffic.jsonl -o draft/
+soup serve --model ./my-tuned-model --auto-spec     # picks up ./draft
+soup draft list
+```
+
+**Acceptance rate** is the fraction of the target's own greedy tokens the draft would have
+proposed correctly (teacher-forced argmax agreement — the metric the Medusa/EAGLE papers report).
+Higher is better; roughly, ≥70% is where speculative decoding starts paying for the draft's
+forward pass on realistic hardware. `--min-acceptance 0.6` exits **2** below the floor, so CI can
+gate on it (exit 0 = ok, 2 = below floor, 1 = error).
+
+`distill` runs logit KD through the existing `task: distill` trainer and emits a **dense** model
+(a PEFT adapter directory cannot be loaded as an `assistant_model`). Draft and target must share a
+tokenizer — a mismatch is refused up front, because speculative decoding proposes *draft* token ids
+into the *target's* vocabulary and a mismatched pair silently produces garbage instead of failing.
+A `soup shrink` output makes a good draft base: same tokenizer by construction.
+
+**Measured reality check (be sceptical of speedup claims, including ours).** On
+`SmolLM2-360M-Instruct` with a `SmolLM2-135M-Instruct` draft, the *stock* draft already scored
+**69.3%** acceptance, distilling it changed nothing (69.7% after 2 epochs, 69.3% after 10), and
+assisted decoding came out **0.55–0.64×** — a net slowdown. A small same-family draft is already
+near its ceiling for agreeing with the target, and the draft's forward pass costs more than the
+tokens it saves. Whether distillation pays off on a larger or genuinely diverged target/draft pair
+is unproven on a 4 GB box. Run `soup draft measure` on *your* pair rather than assuming.
 
 ### Prefix Caching
 
@@ -418,7 +461,7 @@ soup ui
 
 **Pages:**
 - **Dashboard** — view all experiment runs, loss charts, system info, multi-run comparison
-- **New Training** — create configs from templates or 138 ready-made recipes, validate, start training with live SSE log streaming and progress bar
+- **New Training** — create configs from templates or 142 ready-made recipes, validate, start training with live SSE log streaming and progress bar
 - **Data Explorer** — browse and inspect datasets (JSONL, JSON, CSV, Parquet)
 - **Model Chat** — chat with streaming responses, configurable temperature/top_p/max_tokens, system prompt, adapter selection, markdown rendering, chat export
 
@@ -427,7 +470,7 @@ soup ui
 - **Enhanced Metrics** — 2x2 chart grid (loss, LR, grad_norm, throughput) + GPU memory chart, eval results table
 - **Multi-Run Compare** — overlay loss curves from up to 5 runs side-by-side
 - **Chat Upgrade** — SSE streaming via proxy, typing indicator, cancel button, markdown renderer (bold, italic, code blocks), chat export as JSON
-- **Config Builder** — recipe dropdown (138 recipes), config schema API for dynamic form generation
+- **Config Builder** — recipe dropdown (142 recipes), config schema API for dynamic form generation
 
 **Security:** The Web UI generates a random auth token at startup (printed to console). All mutating endpoints (start/stop training, delete runs, inspect data, validate config) require `Authorization: Bearer <token>` header. CORS is restricted to the served origin. Data inspection is sandboxed to the working directory.
 

{soup_cli-0.71.32 → soup_cli-0.71.33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "soup-cli"
-version = "0.71.32"
+version = "0.71.33"
 description = "Fine-tune and post-train LLMs in one command. No SSH, no config hell."
 readme = "README.md"
 license = "Apache-2.0"

{soup_cli-0.71.32 → soup_cli-0.71.33}/src/soup_cli/__init__.py

@@ -1,3 +1,3 @@
 """Soup CLI — Fine-tune and post-train LLMs in one command."""
 
-__version__ = "0.71.32"
+__version__ = "0.71.33"

{soup_cli-0.71.32 → soup_cli-0.71.33}/src/soup_cli/cli.py

@@ -538,6 +538,18 @@ app.command(
     ),
 )(_shrink_cmd.shrink)
 
+# v0.71.33 — `soup draft` train-your-own speculative-decoding draft.
+from soup_cli.commands import draft as _draft_cmd  # noqa: E402
+
+app.add_typer(
+    _draft_cmd.app,
+    name="draft",
+    help=(
+        "Train + measure a speculative-decoding draft model: distil your tuned "
+        "model into a tiny draft, then serve it with --auto-spec (v0.71.33)."
+    ),
+)
+
 
 def _rewrite_advise_argv(argv: list) -> list:
     """Inject `run` between `advise` and a non-subcommand first argument.

{soup_cli-0.71.32 → soup_cli-0.71.33}/src/soup_cli/commands/data.py

@@ -53,12 +53,20 @@ def inspect(
 
     # Print sample rows
     if rows > 0 and len(data) > 0:
+        # Escape dataset-derived cell content + column names: a stray '[/]' in
+        # ordinary data crashes Rich with MarkupError; a crafted '[link=...]'
+        # renders a phishing hyperlink. Mirrors `soup data review`.
+        from rich.markup import escape as _escape
+
         console.print(f"\n[bold]Sample rows ({min(rows, len(data))}):[/]")
         sample_table = Table(show_lines=True)
         for col in result["columns"][:5]:  # max 5 columns
-            sample_table.add_column(col, max_width=60)
+            sample_table.add_column(_escape(str(col)), max_width=60)
         for row in data[: min(rows, len(data))]:
-            values = [str(row.get(col, ""))[:60] for col in result["columns"][:5]]
+            values = [
+                _escape(str(row.get(col, ""))[:60])
+                for col in result["columns"][:5]
+            ]
             sample_table.add_row(*values)
         console.print(sample_table)
 
@@ -1102,16 +1110,20 @@ def search_datasets(
     table.add_column("Likes", justify="right")
     table.add_column("Tags", max_width=30)
 
+    # HF-hub metadata (ids, tags) is attacker-authored — escape before it
+    # reaches a Rich table (MarkupError crash / phishing-link injection).
+    from rich.markup import escape as _escape
+
     for ds_item in datasets[:limit]:
         ds_tags = getattr(ds_item, "tags", []) or []
-        tag_str = ", ".join(ds_tags[:5])
+        tag_str = ", ".join(str(t) for t in ds_tags[:5])
         if len(ds_tags) > 5:
             tag_str += "..."
         table.add_row(
-            ds_item.id,
+            _escape(str(ds_item.id)),
             _format_count(getattr(ds_item, "downloads", 0) or 0),
             _format_count(getattr(ds_item, "likes", 0) or 0),
-            tag_str,
+            _escape(tag_str),
         )
 
     console.print(table)
@@ -1137,22 +1149,26 @@ def preview_dataset(
         )
         raise typer.Exit(1)
 
-    table = Table(title=f"Dataset: {info['id']}")
+    # HF-hub metadata (id, description, tags, feature/split names) is
+    # attacker-authored — escape before it reaches a Rich table.
+    from rich.markup import escape as _escape
+
+    table = Table(title=f"Dataset: {_escape(str(info['id']))}")
     table.add_column("Field", style="bold")
     table.add_column("Value", max_width=80)
 
-    table.add_row("ID", info["id"])
+    table.add_row("ID", _escape(str(info["id"])))
     desc = info["description"]
     if len(desc) > 200:
         desc = desc[:200] + "..."
-    table.add_row("Description", desc or "[dim]No description[/]")
+    table.add_row("Description", _escape(desc) if desc else "[dim]No description[/]")
     table.add_row("Downloads", _format_count(info["downloads"]))
     table.add_row("Likes", _format_count(info["likes"]))
     table.add_row("Size", _format_size_bytes(info["size_bytes"]))
 
     if info["splits"]:
         splits_str = ", ".join(
-            f"{name} ({_format_count(count)})"
+            f"{_escape(str(name))} ({_format_count(count)})"
             for name, count in info["splits"].items()
         )
         table.add_row("Splits", splits_str)
@@ -1160,10 +1176,10 @@ def preview_dataset(
         table.add_row("Splits", "[dim]Not available (use streaming to explore)[/]")
 
     if info["features"]:
-        table.add_row("Features", ", ".join(info["features"]))
+        table.add_row("Features", ", ".join(_escape(str(f)) for f in info["features"]))
 
     if info["tags"]:
-        table.add_row("Tags", ", ".join(info["tags"][:10]))
+        table.add_row("Tags", ", ".join(_escape(str(t)) for t in info["tags"][:10]))
 
     console.print(table)