soup-cli 0.72.0__tar.gz → 0.72.1__tar.gz

{soup_cli-0.72.0 → soup_cli-0.72.1}/CHANGELOG.md

@@ -12,8 +12,58 @@ reproducing 70+ versions of notes.
 
 ## [Unreleased]
 
+## [0.72.1] - 2026-07-27
+
+**Fixed — layer-streaming adapters were saved in an unloadable form.** If you
+trained with `stream_layers: true` on v0.72.0, the adapter that run wrote is
+**inert**: every tensor was saved under a key containing an extra `.inner.`
+segment, so `soup merge`, `soup serve`, `soup chat` and
+`PeftModel.from_pretrained` all loaded **zero** adapter tensors and silently
+returned the untuned base model. PEFT emitted only a `UserWarning`, so nothing
+failed and nothing looked wrong.
+
+The training itself was correct — the streamed run's numerics are unaffected,
+and v0.72.0's bit-exactness results still stand. Only the saved file was
+affected.
+
+**If you have a v0.72.0 streamed adapter: re-save or re-run it on v0.72.1.**
+There is no way to recover the original file's association with the base model
+beyond renaming its keys; re-running is the reliable path. A quick check —
+if `adapter_model.safetensors` contains keys with `.inner.` in them, it is
+affected:
+
+```bash
+python -c "from safetensors.torch import load_file; \
+print([k for k in load_file('adapter_model.safetensors') if '.inner.' in k][:3])"
+```
+
+Streamed adapters now save byte-for-byte in the same layout as an ordinary LoRA
+run, and are portable to any tool that has never heard of layer streaming.
+
+**Also fixed — `--hf-resume` bypassed the streaming resume refusal.** The guard
+only tested `--resume`, but `--hf-resume` reaches `resume_from` through a
+different branch. That combination previously appeared to work by accident
+(checkpoint and live model shared the same key shape); once adapters are saved
+canonically it would instead have matched *nothing* and continued with a
+freshly initialised adapter, silently. Both flags are now refused for streaming
+runs, naming v0.72.3.
+
+Also in this release: every "this lands in vX.Y.Z" refusal message was corrected
+after the v0.72.x roadmap was renumbered (NF4 streaming is now v0.72.2; the disk
+tier, wider architectures, larger batches, gradient accumulation and
+checkpoint/resume are v0.72.3; preference losses are v0.72.4).
+
+**Known limitation:** in memory the streamed model's `named_parameters()` still
+carries the wrapper segment, so loading *into* a streaming run (`--resume`)
+remains unsupported and is refused with a message naming v0.72.3.
+
 ## [0.72.0] - 2026-07-26
 
+> **Superseded by v0.72.1 — adapters saved by this version load as zero
+> tensors.** The entry below is left as published; the defect and the fix are
+> described under [0.72.1]. Version numbers named as "upcoming" below were also
+> renumbered there (NF4 is v0.72.2, not v0.72.1).
+
 **Layer streaming (BETA) — fine-tune models that don't fit in your card.** The
 frozen base lives in CPU RAM and is streamed into two pre-allocated VRAM buffers
 one decoder layer at a time, so peak VRAM is bounded by the size of *one layer*

{soup_cli-0.72.0 → soup_cli-0.72.1}/CONTRIBUTING.md

@@ -120,7 +120,7 @@ src/soup_cli/
   templates/          - 21 built-in soup.yaml templates (YAML + manifest.json) with load_template loader (v0.39.0, +bco v0.40.0, +4 compliance v0.71.35)
   ui/                 - Web UI (FastAPI + HTML/JS SPA)
 
-tests/                - Test suite (324 files, 16735 tests)
+tests/                - Test suite (325 files, 16752 tests)
 examples/             - Real-world config examples and datasets
 ```
 

{soup_cli-0.72.0 → soup_cli-0.72.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soup-cli
-Version: 0.72.0
+Version: 0.72.1
 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,27 +193,39 @@ infrastructure instead of improving models. Soup fixes that.
 
 ## What's New
 
-**v0.72.0 — Layer streaming (BETA).** Fine-tune models that don't fit in your card. The frozen
-base streams from CPU RAM one decoder layer at a time into a small pool of VRAM buffers while the
-LoRA adapters stay resident, so peak VRAM is bounded by one layer rather than the whole model.
-**Qwen2.5-3B trains in 2.15 GB on a 4 GB card, where a resident run OOMs.**
+**v0.72.1 — Fix: layer-streaming adapters were saved unloadable.** If you trained with
+`stream_layers: true` on v0.72.0, that adapter is **inert** — every tensor was written under a
+key with an extra `.inner.` segment, so `soup merge`, `soup serve`, `soup chat` and
+`PeftModel.from_pretrained` loaded **zero** tensors and silently returned the untuned base.
+Only a `UserWarning` was emitted.
+
+- **The training was correct; only the saved file was affected.** v0.72.0's bit-exactness
+  results still stand.
+- **Check an existing adapter:** if `adapter_model.safetensors` has keys containing `.inner.`,
+  it is affected — re-run or re-save it on v0.72.1.
+- Streamed adapters now save in exactly the same layout as an ordinary LoRA run.
+
+**Layer streaming (BETA), from v0.72.0.** Fine-tune models that don't fit in your card. The
+frozen base streams from CPU RAM one decoder layer at a time into a small pool of VRAM buffers
+while the LoRA adapters stay resident, so peak VRAM is bounded by one layer rather than the
+whole model. **Qwen2.5-3B trains in 2.15 GB on a 4 GB card, where a resident run OOMs.**
 
 - **`training.stream_layers: true`** — a config key, not a CLI flag. Tune with
-  `stream_source` (`ram` in v0.72.0; `disk` is v0.72.2) and `stream_buffers` (2–8, default 2).
+  `stream_source` (`ram` today; `disk` is v0.72.3) and `stream_buffers` (2–8, default 2).
 - **Measured on a 4 GB RTX 3050 Laptop** (batch 1, gradient checkpointing on): 0.5B at
   978.6 tok/s / 1.47 GB, 1.5B at 525.0 tok/s / 1.82 GB, 3B at 143.1 tok/s / 2.15 GB.
 - **Honest cost: 1.43× slower than resident**, measured at 0.5B — the only apples-to-apples
   comparison available on that box, because 1.5B and above cannot run resident there at all.
 - **Proof-of-mechanism at 3B.** Nothing above 3B was measured; no 8B/14B claim is supported.
   Scope: RAM tier, bf16, `task: sft`, Llama/Qwen, batch size 1, no gradient accumulation, no
-  `--resume`. 4-bit (NF4) streaming is **v0.72.1** and is refused with a clear message today.
+  `--resume`. 4-bit (NF4) streaming is **v0.72.2** and is refused with a clear message today.
 
 ```yaml
 # soup.yaml — then just `soup train --config soup.yaml`
 training:
   stream_layers: true      # base streams from RAM; only the adapter trains
   batch_size: 1
-  quantization: none       # NF4 streaming lands in v0.72.1
+  quantization: none       # NF4 streaming lands in v0.72.2
 ```
 
 <details>

{soup_cli-0.72.0 → soup_cli-0.72.1}/README.md

@@ -49,27 +49,39 @@ infrastructure instead of improving models. Soup fixes that.
 
 ## What's New
 
-**v0.72.0 — Layer streaming (BETA).** Fine-tune models that don't fit in your card. The frozen
-base streams from CPU RAM one decoder layer at a time into a small pool of VRAM buffers while the
-LoRA adapters stay resident, so peak VRAM is bounded by one layer rather than the whole model.
-**Qwen2.5-3B trains in 2.15 GB on a 4 GB card, where a resident run OOMs.**
+**v0.72.1 — Fix: layer-streaming adapters were saved unloadable.** If you trained with
+`stream_layers: true` on v0.72.0, that adapter is **inert** — every tensor was written under a
+key with an extra `.inner.` segment, so `soup merge`, `soup serve`, `soup chat` and
+`PeftModel.from_pretrained` loaded **zero** tensors and silently returned the untuned base.
+Only a `UserWarning` was emitted.
+
+- **The training was correct; only the saved file was affected.** v0.72.0's bit-exactness
+  results still stand.
+- **Check an existing adapter:** if `adapter_model.safetensors` has keys containing `.inner.`,
+  it is affected — re-run or re-save it on v0.72.1.
+- Streamed adapters now save in exactly the same layout as an ordinary LoRA run.
+
+**Layer streaming (BETA), from v0.72.0.** Fine-tune models that don't fit in your card. The
+frozen base streams from CPU RAM one decoder layer at a time into a small pool of VRAM buffers
+while the LoRA adapters stay resident, so peak VRAM is bounded by one layer rather than the
+whole model. **Qwen2.5-3B trains in 2.15 GB on a 4 GB card, where a resident run OOMs.**
 
 - **`training.stream_layers: true`** — a config key, not a CLI flag. Tune with
-  `stream_source` (`ram` in v0.72.0; `disk` is v0.72.2) and `stream_buffers` (2–8, default 2).
+  `stream_source` (`ram` today; `disk` is v0.72.3) and `stream_buffers` (2–8, default 2).
 - **Measured on a 4 GB RTX 3050 Laptop** (batch 1, gradient checkpointing on): 0.5B at
   978.6 tok/s / 1.47 GB, 1.5B at 525.0 tok/s / 1.82 GB, 3B at 143.1 tok/s / 2.15 GB.
 - **Honest cost: 1.43× slower than resident**, measured at 0.5B — the only apples-to-apples
   comparison available on that box, because 1.5B and above cannot run resident there at all.
 - **Proof-of-mechanism at 3B.** Nothing above 3B was measured; no 8B/14B claim is supported.
   Scope: RAM tier, bf16, `task: sft`, Llama/Qwen, batch size 1, no gradient accumulation, no
-  `--resume`. 4-bit (NF4) streaming is **v0.72.1** and is refused with a clear message today.
+  `--resume`. 4-bit (NF4) streaming is **v0.72.2** and is refused with a clear message today.
 
 ```yaml
 # soup.yaml — then just `soup train --config soup.yaml`
 training:
   stream_layers: true      # base streams from RAM; only the adapter trains
   batch_size: 1
-  quantization: none       # NF4 streaming lands in v0.72.1
+  quantization: none       # NF4 streaming lands in v0.72.2
 ```
 
 <details>

{soup_cli-0.72.0 → soup_cli-0.72.1}/docs/performance-and-quantization.md

@@ -233,7 +233,7 @@ Stream frozen base-model decoder layers ONE at a time from CPU RAM into small VR
 ```yaml
 training:
   stream_layers: true          # Enable layer streaming
-  stream_source: auto          # 'auto' (same-host RAM), 'ram', 'disk' (v0.72.2)
+  stream_source: auto          # 'auto' (same-host RAM), 'ram', 'disk' (v0.72.3)
   stream_buffers: 2            # Double-buffering; range [2, 8]
 ```
 
@@ -259,20 +259,20 @@ The tradeoff: **1.43× slower than resident training**, measured at 0.5B — the
 
 **Honest scope (v0.72.0 = proof-of-mechanism):**
 - **Models measured:** Qwen2.5-0.5B, 1.5B and 3B, plus a live `soup train` on SmolLM2-135M. **Nothing above 3B was measured, and no 8B / 14B / 70B claim is supported.**
-- **RAM tier only.** `stream_source: ram` (`auto` resolves to it). The disk overflow tier ships in **v0.72.2**.
+- **RAM tier only.** `stream_source: ram` (`auto` resolves to it). The disk overflow tier ships in **v0.72.3**.
 - **Llama / Qwen only**, `task: sft`, `backend: transformers`, `modality: text`.
-- **`batch_size: 1`**, no gradient accumulation, no `--resume` — all ship in **v0.72.2**.
-- **bf16 base; `quantization: none` is required.** 4-bit (NF4) weights carry a quantisation state and cannot be byte-copied into a plain buffer, so NF4 streaming is **v0.72.1**. A `4bit` config is refused today with a message saying exactly that.
+- **`batch_size: 1`**, no gradient accumulation, no `--resume` — all ship in **v0.72.3**.
+- **bf16 base; `quantization: none` is required.** 4-bit (NF4) weights carry a quantisation state and cannot be byte-copied into a plain buffer, so NF4 streaming is **v0.72.2**. A `4bit` config is refused today with a message saying exactly that.
 - **The 3B throughput is a LOWER BOUND.** The reference box could not page-lock the 5.55 GB base (its measured page-locked ceiling is 7.65 GB, and a CUDA context plus the model skeleton did not leave room), so that run fell back to a pageable store. Pageable memory makes the host-to-device copy synchronous, which costs overlap — visible as the GPU-utilisation drop from 96.8% (1.5B, pinned) to 79.3% (3B, pageable). Soup does this fallback automatically **and prints the cost** rather than absorbing it silently.
 - Numbers are Windows/WDDM and therefore systematically pessimistic versus Linux. `expandable_segments:True` is silently ignored on Windows; Soup detects that and does not claim it is active.
 
 **Rejected at config load (each names the release that lifts it):**
-- `stream_source: disk` → the disk tier is v0.72.2
-- `quantization` other than `none` → NF4 streaming is v0.72.1
+- `stream_source: disk` → the disk tier is v0.72.3
+- `quantization` other than `none` → NF4 streaming is v0.72.2
 - `backend: unsloth` / `backend: mlx` → streaming replaces the model-load path those backends own
-- `task` other than `sft` → preference losses are v0.72.3
-- `gradient_accumulation_steps > 1` → every micro-batch re-reads the whole base, so accumulation multiplies streaming IO linearly (v0.72.2)
-- `batch_size` other than `1` → v0.72.2
+- `task` other than `sft` → preference losses are v0.72.4
+- `gradient_accumulation_steps > 1` → every micro-batch re-reads the whole base, so accumulation multiplies streaming IO linearly (v0.72.3)
+- `batch_size` other than `1` → v0.72.3
 - `lora.use_dora` / `lora.use_vera` / `lora.init_strategy` other than `random` → these initialise from the real base weight, which is on the meta device under streaming
 - `unfrozen_parameters`, `lisa_enabled`, `packing`, `multipack`, `use_fsdp2_compile`, `train_router_only`, `expand_layers` → each independently rewrites or re-freezes the same layers
 - `stream_source` / `stream_buffers` set while `stream_layers: false` → a footgun, refused
@@ -294,12 +294,12 @@ data:
 training:
   epochs: 3
   lr: 2e-5
-  batch_size: 1           # required; larger batches in v0.72.2
-  gradient_accumulation_steps: 1   # required; accumulation in v0.72.2
-  quantization: none      # required; NF4 streaming is v0.72.1
+  batch_size: 1           # required; larger batches in v0.72.3
+  gradient_accumulation_steps: 1   # required; accumulation in v0.72.3
+  quantization: none      # required; NF4 streaming is v0.72.2
   gradient_checkpointing: true     # handled per-layer by the streamer
   stream_layers: true     # Enable layer streaming
-  stream_source: auto     # RAM-based (disk in v0.72.2)
+  stream_source: auto     # RAM-based (disk in v0.72.3)
   stream_buffers: 2       # double-buffering
   lora:
     r: 64
@@ -313,16 +313,25 @@ output: ./output
 - The 1.5B runs sit at ~97% GPU utilisation, i.e. compute-bound: with a page-locked store the layer loads hide almost completely behind compute. The 3B run's 79.3% is **not** a model-size effect — it is the cost of the pageable-store fallback on that particular box.
 - Correctness is not a tradeoff: streamed and resident forward passes were verified **bit-exact**, and a 100-step streamed loss curve matched resident exactly. Streaming substitutes the same weight bytes into the same kernels.
 
+> **v0.72.0 adapters are unloadable — re-run them on v0.72.1.** In v0.72.0 a streamed run saved every adapter tensor under a key carrying an extra `.inner.` segment, so `soup merge`, `soup serve`, `soup chat` and `PeftModel.from_pretrained` loaded **zero** tensors and silently returned the untuned base (PEFT emitted only a `UserWarning`). The training itself was correct — only the saved file was affected. Check with:
+>
+> ```bash
+> python -c "from safetensors.torch import load_file; \
+> print([k for k in load_file('adapter_model.safetensors') if '.inner.' in k][:3])"
+> ```
+>
+> If that prints anything, the adapter is affected. From v0.72.1 a streamed adapter is byte-for-byte in the same layout as an ordinary LoRA run.
+
 **Troubleshooting:**
-- **"layer streaming needs the base to fit in RAM"** — the base is larger than free RAM. Free RAM or pick a smaller base; the disk overflow tier is v0.72.2.
+- **"layer streaming needs the base to fit in RAM"** — the base is larger than free RAM. Free RAM or pick a smaller base; the disk overflow tier is v0.72.3.
 - **"could not page-lock the base … falling back to a PAGEABLE RAM store"** — expected on a busy machine. Training continues, more slowly. Close other applications to keep the pinned store.
 - **"layer streaming does not support model_type=…"** — v0.72.0 covers Llama and Qwen only.
 - **Slower than you expected** — layer streaming trades time for memory. If the model already fits resident on your card, do not enable it.
 
 **Roadmap (each refusal names its release):**
-- 4-bit (NF4) streaming — **v0.72.1**, the first genuinely useful capability jump
-- Disk overflow tier, batch size > 1, gradient accumulation, checkpoint/resume, more architectures (Mistral / Gemma / Phi) — **v0.72.2**
-- Preference losses (DPO / ORPO / SimPO / KTO) — **v0.72.3**. GRPO and PPO are explicitly **not** planned: rollouts need generation, which re-reads the model per token
+- 4-bit (NF4) streaming — **v0.72.2**, the first genuinely useful capability jump
+- Disk overflow tier, batch size > 1, gradient accumulation, checkpoint/resume, more architectures (Mistral / Gemma / Phi) — **v0.72.3**
+- Preference losses (DPO / ORPO / SimPO / KTO) — **v0.72.4**. GRPO and PPO are explicitly **not** planned: rollouts need generation, which re-reads the model per token
 - A published 14B-on-8 GB reference benchmark — hardware-blocked; it needs an 8 GB card and 32 GB of RAM, which the development box does not have
 
 **Shard cache.** The first streaming run rewrites the checkpoint into one safetensors shard per decoder layer under `~/.soup/layer-stream/` (override with `SOUP_LAYER_STREAM_CACHE_DIR`). That costs disk space roughly equal to the base. The cache is keyed to a fingerprint of the source checkpoint, so a base retrained in place re-shards instead of silently training against stale weights.

{soup_cli-0.72.0 → soup_cli-0.72.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "soup-cli"
-version = "0.72.0"
+version = "0.72.1"
 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.72.0 → soup_cli-0.72.1}/src/soup_cli/__init__.py

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

{soup_cli-0.72.0 → soup_cli-0.72.1}/src/soup_cli/commands/train.py

@@ -531,13 +531,20 @@ def train(
         raise typer.Exit(code=2) from exc
 
     # --- v0.72.0 BETA — layer streaming does not support resume yet ---
-    # Silently ignoring --resume would restart from scratch and look like it
+    # Silently ignoring a resume would restart from scratch and look like it
     # worked, so refuse before any heavy work happens.
-    if resume and cfg.training.stream_layers:
+    #
+    # v0.72.1: --hf-resume must be covered too. It sets resume_from through a
+    # different branch (see prepare_hf_resume below), so a guard on --resume
+    # alone let it through. That mattered more after the adapter-key fix: the
+    # pushed checkpoint now carries canonical keys while a live streamed model
+    # is still `.inner.`-shaped, so PEFT's strict=False load would match
+    # NOTHING and silently continue with a freshly initialised adapter.
+    if (resume or hf_resume) and cfg.training.stream_layers:
         console.print(
-            "[red]--resume is not supported with training.stream_layers in "
-            "v0.72.0[/] — checkpoint/resume for layer streaming lands in "
-            "v0.72.2. Drop --resume, or set stream_layers: false."
+            "[red]--resume / --hf-resume are not supported with "
+            "training.stream_layers[/] — checkpoint/resume for layer streaming "
+            "lands in v0.72.3. Drop the flag, or set stream_layers: false."
         )
         raise typer.Exit(code=2)
 

{soup_cli-0.72.0 → soup_cli-0.72.1}/src/soup_cli/config/schema.py

@@ -2930,7 +2930,7 @@ class TrainingConfig(BaseModel):
         default="auto",
         description=(
             "Where the streamed base lives. 'ram' (the only tier implemented in "
-            "v0.72.0) pins the base in CPU RAM; 'disk' is the v0.72.2 overflow "
+            "v0.72.0) pins the base in CPU RAM; 'disk' is the v0.72.3 overflow "
             "tier; 'auto' picks per free RAM."
         ),
     )
@@ -4662,7 +4662,7 @@ class SoupConfig(BaseModel):
             raise ValueError(
                 f"training.stream_layers requires task='sft' in v0.72.0; got "
                 f"task={self.task!r}. Preference losses (DPO/ORPO/SimPO/KTO) "
-                f"land in v0.72.3."
+                f"land in v0.72.4."
             )
         if self.backend != "transformers":
             raise ValueError(
@@ -4680,24 +4680,24 @@ class SoupConfig(BaseModel):
                 f"training.stream_layers requires quantization='none' in "
                 f"v0.72.0 (got {tcfg.quantization!r}). NF4 weights carry a "
                 f"quant_state and cannot be byte-copied into a plain buffer; "
-                f"NF4 streaming lands in v0.72.1."
+                f"NF4 streaming lands in v0.72.2."
             )
         if tcfg.stream_source == "disk":
             raise ValueError(
                 "training.stream_source='disk' is not implemented in v0.72.0 — "
-                "the disk overflow tier lands in v0.72.2. Use 'ram' or 'auto'."
+                "the disk overflow tier lands in v0.72.3. Use 'ram' or 'auto'."
             )
         if tcfg.batch_size != 1:
             raise ValueError(
                 f"training.stream_layers requires batch_size=1 in v0.72.0 (got "
-                f"{tcfg.batch_size!r}); larger batches land in v0.72.2."
+                f"{tcfg.batch_size!r}); larger batches land in v0.72.3."
             )
         if tcfg.gradient_accumulation_steps != 1:
             raise ValueError(
                 f"training.stream_layers requires gradient_accumulation_steps=1 "
                 f"(got {tcfg.gradient_accumulation_steps}); every micro-batch "
                 f"re-reads the entire base, so accumulation multiplies streaming "
-                f"IO linearly. Accumulation lands in v0.72.2."
+                f"IO linearly. Accumulation lands in v0.72.3."
             )
         if tcfg.lora.r < 1:
             raise ValueError(

{soup_cli-0.72.0 → soup_cli-0.72.1}/src/soup_cli/trainer/sft.py

@@ -1019,7 +1019,7 @@ class SFTTrainerWrapper:
                     f"layer streaming needs the base to fit in RAM: {cfg.base} is "
                     f"{source_bytes / 1e9:.1f} GB on disk and only "
                     f"{early_free_ram / 1e9:.1f} GB of RAM is free. The disk "
-                    f"overflow tier lands in v0.72.2 — free RAM or pick a "
+                    f"overflow tier lands in v0.72.3 — free RAM or pick a "
                     f"smaller base."
                 )
 
@@ -1062,7 +1062,7 @@ class SFTTrainerWrapper:
                 f"layer streaming needs the base to fit in RAM: it is "
                 f"{(layer_bytes * index.n_layers + embed_bytes) / 1e9:.1f} GB and only "
                 f"{free_ram / 1e9:.1f} GB is free. The disk overflow tier lands "
-                f"in v0.72.2 — free RAM or pick a smaller base."
+                f"in v0.72.3 — free RAM or pick a smaller base."
             )
         console.print(render_stream_panel(plan))
         console.print(

{soup_cli-0.72.0 → soup_cli-0.72.1}/src/soup_cli/utils/layer_stream.py

@@ -39,7 +39,7 @@ DEFAULT_STREAM_BUFFERS = 2
 #: the base is frozen). Streaming always checkpoints, so this is never 4.
 FLOPS_PER_PARAM_PER_TOKEN = 6
 
-#: v0.72.0 scope. Breadth (Mistral / Gemma / Phi) is v0.72.2.
+#: v0.72.0 scope. Breadth (Mistral / Gemma / Phi) is v0.72.3.
 SUPPORTED_STREAM_ARCHS = ("llama", "qwen2", "qwen3")
 
 _DTYPE_BYTES = {"bfloat16": 2, "float16": 2, "float32": 4}
@@ -84,7 +84,7 @@ def stream_arch_of(config: Any) -> str:
         raise ValueError(
             f"layer streaming does not support model_type={family!r} in "
             f"v0.72.0. Supported: {', '.join(SUPPORTED_STREAM_ARCHS)}. "
-            f"More architectures land in v0.72.2."
+            f"More architectures land in v0.72.3."
         )
     return family
 
@@ -313,7 +313,7 @@ def build_stream_plan(
     notes = []
     if tier == TIER_DISK:
         notes.append(
-            "base does not fit in RAM — the disk tier lands in v0.72.2; "
+            "base does not fit in RAM — the disk tier lands in v0.72.3; "
             "v0.72.0 supports stream_source='ram' only"
         )
     decision = decide_pinning(store_bytes, pinned_limit_bytes)

{soup_cli-0.72.0 → soup_cli-0.72.1}/src/soup_cli/utils/layer_stream_runtime.py

@@ -278,6 +278,50 @@ def _build_streamed_layer_class():
 
             return super()._apply(_skip_meta, recurse=recurse)
 
+        def state_dict(
+            self,
+            *args: Any,
+            destination: Any = None,
+            prefix: str = "",
+            keep_vars: bool = False,
+        ) -> Any:
+            # v0.72.1 — serialise as though this wrapper were not in the tree.
+            #
+            # The wrapper holds the real layer as a child named `inner`, so
+            # every adapter parameter would otherwise be written as
+            # `...layers.0.inner.self_attn.q_proj.lora_A.weight`. That file
+            # loads as ZERO tensors into any normal model — PEFT reports the
+            # keys as missing and returns the untuned base, with no exception.
+            # Every adapter artifact (the final `trainer.save_model()`, each
+            # `save_steps` checkpoint, and therefore everything downstream:
+            # `soup merge` / `serve` / `chat` / `adapters *` / the Registry)
+            # reaches disk through this method, so delegating at OUR prefix is
+            # what makes a streamed adapter indistinguishable from a normal
+            # LoRA run.
+            #
+            # Serialisation-only, deliberately: the forward path is untouched,
+            # so v0.72.0's bit-exactness gates remain valid. The cost is that
+            # `named_parameters()` still shows `.inner.`, i.e. loading INTO a
+            # streamed model stays unsupported (`--resume` is refused; the
+            # checkpoint/resume slot is v0.72.3).
+            #
+            # The wrapper owns no parameters or buffers of its own — they all
+            # live on `inner` — so nothing is lost by not serialising it. It
+            # also means bypassing nn.Module.state_dict skips only hooks
+            # registered on the WRAPPER itself, of which there are none (the
+            # prefetch hook lives on the decoder container, not here).
+            if args:
+                # torch's legacy positional form: (destination, prefix, keep_vars)
+                if destination is None:
+                    destination = args[0]
+                if len(args) > 1 and prefix == "":
+                    prefix = args[1]
+                if len(args) > 2 and keep_vars is False:
+                    keep_vars = args[2]
+            return self.inner.state_dict(
+                destination=destination, prefix=prefix, keep_vars=keep_vars
+            )
+
         def __getattr__(self, name: str) -> Any:
             # transformers reads contract attributes straight off the layer
             # object (this version reads `decoder_layer.attention_type`). The

{soup_cli-0.72.0 → soup_cli-0.72.1}/tests/test_v07200.py

@@ -50,7 +50,7 @@ class TestStreamArchAllowlist:
             stream_arch_of(_Cfg("gpt2"))
 
     def test_mistral_is_rejected_in_v0720(self):
-        """Mistral is v0.72.2 breadth — it must not silently half-work."""
+        """Mistral is v0.72.3 breadth — it must not silently half-work."""
         from soup_cli.utils.layer_stream import stream_arch_of
 
         with pytest.raises(ValueError, match="mistral"):
@@ -776,13 +776,13 @@ class TestStreamTaskAndBackendGates:
 
 
 class TestStreamScopeGates:
-    def test_quantization_rejected_and_names_v0721(self):
-        """NF4 streaming is the v0.72.1 slot — say so instead of half-working."""
-        with pytest.raises(ValueError, match="v0.72.1"):
+    def test_quantization_rejected_and_names_nf4_slot(self):
+        """NF4 streaming is the v0.72.2 slot — say so instead of half-working."""
+        with pytest.raises(ValueError, match="v0.72.2"):
             _load(_stream_yaml(training={"quantization": "4bit"}))
 
-    def test_disk_source_rejected_and_names_v0722(self):
-        with pytest.raises(ValueError, match="v0.72.2"):
+    def test_disk_source_rejected_and_names_breadth_slot(self):
+        with pytest.raises(ValueError, match="v0.72.3"):
             _load(_stream_yaml(training={"stream_source": "disk"}))
 
     def test_batch_size_above_one_rejected(self):