freesolo-flash-dev 1.2.121__tar.gz → 1.2.122__tar.gz

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.121
+Version: 1.2.122
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/docs/serving-contract.md

@@ -10,7 +10,7 @@ adapters. A different base model requires a separate deployment. Use
 Customer-owned Modal is live-qualified for `Qwen/Qwen3.5-9B`, `Qwen/Qwen3.8-27B`, and
 `Qwen/Qwen3.6-35B-A3B`. The 27B and 35B-A3B qualifications are bound to the exact certified serving
 image digest; another digest remains available for offline planning but cannot allocate Modal.
-Hosted Qwen3.8 27B remains inactive. Its customer-owned engine runs on `H100!` and serves the pinned
+Hosted Qwen3.8 27B is active on H100. Its customer-owned engine runs on `H100!` and serves the pinned
 `Qwen/Qwen3.8-27B-FP8` checkpoint while preserving `Qwen/Qwen3.8-27B` as the distinct logical base
 and tokenizer provenance. The 35B-A3B engine serves BF16 weights on one H200 with FP8 KV cache, a
 32K context, eight sequences, a 4096 batched-token cap, and six rank-64 LoRA slots.

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/flash/core/catalog.py

@@ -208,7 +208,7 @@ class ModelInfo:
 DEFAULT_MODEL = "Qwen/Qwen3.5-9B"
 
 # the checkpoint each public catalog model loads for customer-owned serving. hosted activation is
-# a separate allowlist in flash.serving.src.engine.model_config, where qwen3.8-27b remains inactive.
+# a separate allowlist in flash.serving.src.engine.model_config.
 SERVING_MODEL_REPOS: dict[str, str] = {
     "Qwen/Qwen3.5-9B": "Freesolo-Co/Qwen3.5-9B-FP8",
     "Qwen/Qwen3.8-27B": "Qwen/Qwen3.8-27B-FP8",

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/flash/serving/app/README.md

@@ -150,13 +150,12 @@ GPUs, so there's nothing to tune at deploy time:
   checkpoints are VL-preserving (each VL-unified base's vision tower + MoE router gates stay in
   original precision) and already published to the operator HF org. Native FP8 tensor cores need
   compute capability ≥ 8.9; every dense FP8 tier runs on an L4, L40S, or H100 (all native). No serving
-  tier runs on A100 now that the 35B is bf16 on H200. The pending Qwen3.8 candidate allocates no
-  hosted tier until its exact canary passes.
+  tier runs on A100 now that the 35B is bf16 on H200. The 27B serves the official native FP8
+  checkpoint on an H100.
 
 - **The real memory lever — LoRA buffers:** vLLM PRE-ALLOCATES the GPU LoRA buffers at `max_loras ×
 max_lora_rank`, regardless of how many adapters load. Both are linear levers. The qualified 9B runs
-  **16 × 128** on L40S. Qwen3.8-27B's H100 LoRA capacity remains pending exact-checkpoint
-  qualification. The 35B MoE runs **6 × 64** bf16 on H200. Adapters trained above the effective rank are rejected at load; a base regularly serving
+  **16 × 128** on L40S and the 27B runs **16 × 64** on H100. The 35B MoE runs **6 × 64** bf16 on H200. Adapters trained above the effective rank are rejected at load; a base regularly serving
   more distinct adapters than its hot limit pays a swap latency from the CPU pool unless its hot
   limit equals `MAX_CPU_LORAS`.
 
@@ -174,17 +173,19 @@ cold-boot smoke test first.
 | Base model                | Checkpoint                                   | GPU       | Hot LoRA shape | Context |
 | ------------------------- | -------------------------------------------- | --------- | -------------- | ------- |
 | Qwen3.5-9B                | owned FP8 (`Freesolo-Co/*-FP8`)              | **L40S**§ | 16 × 128       | 32768   |
-| Qwen3.8-27B candidate     | official native FP8 (`Qwen/Qwen3.8-27B-FP8`) | inactive‡ | pending        | pending |
+| Qwen3.8-27B               | official native FP8 (`Qwen/Qwen3.8-27B-FP8`) | **H100**‡ | 16 × 64        | 32768   |
 | Qwen3.6-35B-A3B (MoE, VL) | official **bf16** (`Qwen/Qwen3.6-35B-A3B`)   | **H200**† | 6 × 64         | 32768   |
 
 § 9B (L40S) runs **16 × 128** at 32k context with `max_num_seqs=8`, CUDA graphs
 (`enforce_eager=False`), and `gpu_memory_utilization=0.90`. Its rank-128 × 16 buffer OOMed an L4 and
 2×L4 in the real-GPU sweep, so it runs on the 48 GiB L40S, the cheapest Ada card that fits it at 32k.
 
-‡ Qwen3.8-27B is not in active hosted routing, registration, base-model health, or engine deployment.
-Its proposed H100 tier, hot LoRA capacity, context limit, CUDA-graph behavior, throughput, and latency
-remain pending qualification on the exact immutable official FP8 checkpoint. Qwen3.6-27B measurements
-do not qualify or predict the Qwen3.8 checkpoint.
+‡ 27B (H100, 80 GiB) runs **16 × 64** at 32k with `max_num_seqs=8`, CUDA graphs
+(`enforce_eager=False`), and `gpu_memory_utilization=0.90`, qualified by a real-GPU canary on the exact
+immutable official FP8 checkpoint: weights loaded at 44.25 GiB, leaving 23.07 GiB of KV cache
+(350,981 tokens, 10.71x concurrency at 32k) after a 0.35 GiB graph capture. Cold boot is about 20 min
+(load + 137 s torch.compile + 442 s warmup dominated by the FlashInfer GDN JIT), all cached on the
+serving volume. Qwen3.6-27B measurements do not qualify or predict the Qwen3.8 checkpoint.
 
 † 35B-A3B runs **bf16 on an H200** (141 GiB) at **6 × 64**, the one serving path that gives a flash
 adapter its full all-expert LoRA AND CUDA graphs at speed. It gets rank 64 like the 27B

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/flash/serving/app/modal_app.py

@@ -138,8 +138,12 @@ def scaledown_window_for(gpu: str) -> int:
 # gpu model engines scale to zero. inference and adapter registration remote calls start the matching
 # parameter-bound engine on demand.
 MIN_CONTAINERS = 0
-# no autoscaling cap per base-model engine; modal adds capacity as concurrency demands.
-MAX_CONTAINERS = None
+# At most 3 GPUs per base model. `base_model` is a modal.parameter(), and Modal gives each distinct
+# parameter value its own container pool with its own autoscaling accounting, so this bound applies
+# PER MODEL rather than across the catalog. Engines are TENSOR_PARALLEL_SIZE 1 on a single-card `gpu=`
+# request, so one container is exactly one GPU and 3 containers is exactly 3 GPUs. Raising this bounds
+# spend per model, not total spend: N models can still reach 3N GPUs.
+MAX_CONTAINERS = 3
 # Concurrent requests packed onto one base-model GPU before Modal autoscales a new (costly) one.
 # A real-GPU sweep (scripts/gpu_canary.py::sweep_concurrency on A10G/Qwen2.5-1.5B) showed vLLM
 # throughput scaling near-linearly with no saturation through 128 concurrent, while TTFT stayed

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/flash/serving/src/accounting/usage.py

@@ -24,16 +24,17 @@ from flash.serving.src.accounting.usage_outbox import (
 from flash.serving.src.io.schemas import AdapterRecord
 
 FREESOLO_PRICING_SOURCE = "freesolo_backend_catalog"
-FREESOLO_PRICING_VERSION = "2026-08-24.1"
+FREESOLO_PRICING_VERSION = "2026-08-27.1"
+# (prompt, completion, cached prompt) usd per million tokens, one entry per active hosted model.
+# these are the charged customer rates, set 5% below the lowest healthy comparable openrouter fp8
+# listing for each model and token category. they are NOT cost-plus: no markup is applied, and they
+# currently sit below the recorded cost basis, so do not reintroduce a multiplier here until measured
+# b200 economics establish a lower truthful cost basis.
 _FREESOLO_USD_PER_MTOK: dict[str, tuple[str, str, str]] = {
-    "Qwen/Qwen3.5-0.8B": ("0.01", "0.05", "0.002"),
-    "Qwen/Qwen3.5-2B": ("0.02", "0.10", "0.004"),
-    "Qwen/Qwen3.5-4B": ("0.03", "0.15", "0.006"),
-    "Qwen/Qwen3.5-9B": ("0.114", "0.19", "0.023"),
-    "Qwen/Qwen3.6-27B": ("0.4254", "3.055", "0.14"),
-    "Qwen/Qwen3.6-35B-A3B": ("0.198", "1.265", "0.066"),
+    "Qwen/Qwen3.5-9B": ("0.095", "0.1425", "0.0276"),
+    "Qwen/Qwen3.8-27B": ("0.3325", "2.4225", "0.03325"),
+    "Qwen/Qwen3.6-35B-A3B": ("0.095", "0.9025", "0.0475"),
 }
-_FREESOLO_MARKUP = Decimal("1.2")
 _USD_PER_MTOK_DIVISOR = Decimal("1000000")
 
 
@@ -173,7 +174,7 @@ def freesolo_price(base_model: str) -> CapturedPrice:
         raise ValueError(f"no durable serving price for base model {base_model!r}") from exc
 
     def per_token(rate: str) -> str:
-        return format(Decimal(rate) * _FREESOLO_MARKUP / _USD_PER_MTOK_DIVISOR, "f")
+        return format(Decimal(rate) / _USD_PER_MTOK_DIVISOR, "f")
 
     return CapturedPrice(
         source=FREESOLO_PRICING_SOURCE,

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/flash/serving/src/engine/model_config.py

@@ -3,9 +3,9 @@
 The serving app runs one vLLM GPU engine per base model, each on the Modal GPU class set by its
 catalog ``gpu`` (see below). Adapters and routing key off the logical ``base_model``; the engine
 loads its configured checkpoint at that checkpoint's own dtype. The active dense 9B uses Freesolo
-compressed-tensors FP8. Qwen3.8-27B retains pinned candidate metadata but is excluded from active
-lookups until its exact canary passes. The active 35B-A3B MoE serves base bf16 weights because its
-fused-MoE LoRA path will not compile on FP8, as detailed below.
+compressed-tensors FP8 and the active dense 27B uses the official Qwen FP8 checkpoint. The active
+35B-A3B MoE serves base bf16 weights because its fused-MoE LoRA path will not compile on FP8, as
+detailed below.
 """
 
 from __future__ import annotations
@@ -27,15 +27,14 @@ from flash.serving.src.engine.prequant_config import (
 # `engine` (optional): per-model vLLM engine-arg overrides (LoRA buffer shape, scheduler/memory caps,
 # language_model_only, …). The engine's LOADED checkpoint is NOT in here — it is resolved centrally by
 # ``serve_model_for`` from ``src.prequant_config`` and injected into the overrides as ``serve_model_id``.
-# active models resolve through prequant_config unless an exact validated override is present. the
-# pending 27b candidate carries its own immutable checkpoint pin without entering active resolution.
+# active models resolve through prequant_config unless an exact validated override is present.
 # ⚠ serve_model_id is pointed only at checkpoints VERIFIED to exist (a missing repo 404-crash-loops
 # the engine — the reason this mechanism was removed once); the owned repos are VL-preserving FP8
 # checkpoints published to the operator HF org.
 #
 # sizing rationale. preallocated lora buffers and loaded checkpoint weights dominate engine vram.
-# the active 9b uses 16 rank-128 slots on l40s and the active 35b moe uses 6 rank-64 slots on h200.
-# the pending 27b candidate retains its proposed h100 shape only for the exact canary.
+# the active 9b uses 16 rank-128 slots on l40s, the active 27b uses 16 rank-64 slots on h100, and the
+# active 35b moe uses 6 rank-64 slots on h200.
 #   - Qwen3.6-35B-A3B (vision-language MoE; arch ``Qwen3_5MoeForConditionalGeneration``) -> H200
 #     (141 GiB) with the base bf16 weights, 6 x 64 LoRA at 32k. bf16 (not FP8) is the one path giving
 #     full-expert LoRA + CUDA graphs because the fused-MoE LoRA path won't compile on fp8e4nv. see the
@@ -108,32 +107,35 @@ SERVING_MODELS: list[dict[str, Any]] = [
             # the complete model and LoRA load is about 108 GiB on the 141 GiB H200.
         },
     },
+    # 27B dense on an H100 (80 GiB). the real-GPU canary measured the load at 44.25 GiB -- above the
+    # FP8 weight size alone, because the vision tower and the non-quantized tensors stay bf16 -- which
+    # still leaves 23.07 GiB of KV cache (350,981 tokens, 10.71x concurrency at 32k) after the 16
+    # rank-64 LoRA buffers and a 0.35 GiB graph capture. every repository here is pinned to an
+    # immutable revision so a served engine cannot silently follow an upstream retag; note the model
+    # pin names a commit in the -FP8 repo while the tokenizer/processor pins name one in the base
+    # repo, which are separate sha namespaces.
+    {
+        "base_model": "Qwen/Qwen3.8-27B",
+        "image_input_limit": 4,
+        "gpu": "H100",
+        "engine": {
+            "model_revision": "017b9c7af6b5689d5dd426a76e0bc077eb5ca20a",
+            "tokenizer_model": "Qwen/Qwen3.8-27B",
+            "tokenizer_revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
+            "processor_revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
+            "gpu_memory_utilization": 0.90,
+            "max_loras": 16,
+            "max_lora_rank": 64,
+            "max_model_len": 32768,
+            "max_num_seqs": 8,
+            "enforce_eager": False,
+            "reasoning_parser": "qwen3",
+        },
+    },
 ]
 
 _BY_MODEL: dict[str, dict[str, Any]] = {m["base_model"]: m for m in SERVING_MODELS}
 
-# inert descriptor for the exact pending canary. activation means moving this descriptor into
-# SERVING_MODELS, not consulting a second runtime allowlist.
-_QWEN38_HOSTED_CANDIDATE: dict[str, Any] = {
-    "base_model": "Qwen/Qwen3.8-27B",
-    "image_input_limit": 4,
-    "gpu": "H100",
-    "engine": {
-        "serve_model_id": "Qwen/Qwen3.8-27B-FP8",
-        "model_revision": "017b9c7af6b5689d5dd426a76e0bc077eb5ca20a",
-        "tokenizer_model": "Qwen/Qwen3.8-27B",
-        "tokenizer_revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
-        "processor_revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
-        "gpu_memory_utilization": 0.90,
-        "max_loras": 16,
-        "max_lora_rank": 64,
-        "max_model_len": 32768,
-        "max_num_seqs": 8,
-        "enforce_eager": False,
-        "reasoning_parser": "qwen3",
-    },
-}
-
 
 def base_models() -> list[str]:
     return [model["base_model"] for model in SERVING_MODELS]

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/flash/serving/src/engine/prequant_config.py

@@ -1,9 +1,8 @@
 """Prequantized checkpoint mapping for active hosted serving.
 
-The 9B loads a Freesolo-owned compressed-tensors FP8 checkpoint. The 35B MoE mapping remains its
-official FP8 default, although the validated engine override serves the base bf16 weights so
-full-expert LoRA and CUDA graphs coexist. Pending hosted candidates keep their pins in model_config
-without entering this active mapping.
+The 9B loads a Freesolo-owned compressed-tensors FP8 checkpoint. The 27B loads its official FP8
+checkpoint. The 35B MoE mapping remains its official FP8 default, although the validated engine
+override serves the base bf16 weights so full-expert LoRA and CUDA graphs coexist.
 """
 
 from __future__ import annotations
@@ -15,6 +14,7 @@ OWNED_FP8_MODEL_REPOS: dict[str, str] = {
 
 # official qwen checkpoints active in hosted serving.
 OFFICIAL_FP8_MODEL_REPOS: dict[str, str] = {
+    "Qwen/Qwen3.8-27B": "Qwen/Qwen3.8-27B-FP8",
     "Qwen/Qwen3.6-35B-A3B": "Qwen/Qwen3.6-35B-A3B-FP8",
 }
 

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.2.121"
+version = "1.2.122"
 description ="Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
@@ -196,7 +196,7 @@ artifacts = ["flash/py.typed"]
 # auto-published by .github/workflows/publish-dev.yml: a push to `dev` whose version isn't yet on
 # PyPI publishes it; pushes that don't change it find it already published and no-op. So cutting a
 # dev-channel release = bump this (and [project].version) and merge to `dev`.
-version = "1.2.121"
+version = "1.2.122"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/tests/serving/test_model_config.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 import pytest
 
 from flash.serving.src.engine.model_config import (
-    _QWEN38_HOSTED_CANDIDATE,
     SERVING_MODELS,
     base_models,
     engine_overrides_for,
@@ -21,6 +20,7 @@ from flash.serving.src.engine.model_config import (
 def test_catalog_has_only_canary_qualified_active_models() -> None:
     assert set(base_models()) == {
         "Qwen/Qwen3.5-9B",
+        "Qwen/Qwen3.8-27B",
         "Qwen/Qwen3.6-35B-A3B",
     }
 
@@ -35,6 +35,7 @@ def test_every_catalog_model_has_an_intentional_image_classification() -> None:
     image_models = {model for model in base_models() if supports_image_input(model)}
     assert image_models == {
         "Qwen/Qwen3.5-9B",
+        "Qwen/Qwen3.8-27B",
         "Qwen/Qwen3.6-35B-A3B",
     }
     assert all(image_limit_for(model) == 4 for model in image_models)
@@ -86,6 +87,7 @@ def test_dense_models_serve_fp8_and_35b_serves_bf16_base() -> None:
     # serve_model_for() resolves it and engine_overrides_for() injects it as serve_model_id.
     expected_fp8 = {
         "Qwen/Qwen3.5-9B": "Freesolo-Co/Qwen3.5-9B-FP8",
+        "Qwen/Qwen3.8-27B": "Qwen/Qwen3.8-27B-FP8",
     }
     for base, ckpt in expected_fp8.items():
         assert serve_model_for(base) == ckpt
@@ -121,18 +123,21 @@ def test_9b_has_l40s_rank128_serving_overrides() -> None:
     )  # CUDA graphs on (~10x faster decode on this hybrid GDN model)
 
 
-def test_qwen38_27b_is_a_pinned_pending_hosted_candidate() -> None:
+def test_qwen38_27b_is_active_on_h100_with_pinned_immutable_revisions() -> None:
+    # 27B is a FULLY ACTIVE hosted tier: every active lookup resolves it, and its served checkpoint,
+    # tokenizer and processor stay pinned to immutable revisions so a served engine cannot follow an
+    # upstream retag. The rank-64 x 16 LoRA shape at 32k is what the H100 (80 GiB) was sized for.
     base_model = "Qwen/Qwen3.8-27B"
-    candidate = _QWEN38_HOSTED_CANDIDATE
-    assert candidate["base_model"] == base_model
-    ov = candidate["engine"]
-
-    assert base_model not in base_models()
-    assert is_supported_base_model(base_model) is False
-    for active_lookup in (engine_overrides_for, gpu_for, image_limit_for, serve_model_for):
-        with pytest.raises(ValueError, match="Unsupported base model"):
-            active_lookup(base_model)
+
+    assert base_model in base_models()
+    assert is_supported_base_model(base_model) is True
+    assert gpu_for(base_model) == "H100"
+    assert image_limit_for(base_model) == 4
+    assert serve_model_for(base_model) == "Qwen/Qwen3.8-27B-FP8"
+
+    ov = engine_overrides_for(base_model)
     assert ov["serve_model_id"] == "Qwen/Qwen3.8-27B-FP8"
+    assert ov["tokenizer_model"] == base_model
     assert ov["max_loras"] == 16
     assert ov["max_lora_rank"] == 64
     assert ov["max_model_len"] == 32768

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/tests/serving/test_per_model_gpu.py

@@ -410,6 +410,7 @@ def test_one_engine_class_per_distinct_engine_key(modal_app_module):
     """a loraengine class is built for each active gpu tier and concurrency key."""
     assert set(modal_app_module.ENGINE_BY_KEY) == {
         ("L40S", 16),
+        ("H100", 16),
         ("H200", 16),
     }
 
@@ -446,11 +447,12 @@ def test_9b_routes_to_l40s(modal_app_module):
     assert by_key[("L40S", 16)].__name__ == "LoraEngine_L40S_c16"
 
 
-def test_pending_qwen38_candidate_has_no_active_engine_dispatch(modal_app_module):
-    with pytest.raises(ValueError, match="Unsupported base model"):
-        gpu_for("Qwen/Qwen3.8-27B")
-    with pytest.raises(ValueError, match="Unsupported base model"):
-        modal_app_module._engine_cls_for("Qwen/Qwen3.8-27B")
+def test_27b_routes_to_h100(modal_app_module):
+    """The dense 27B runs its FP8 checkpoint on the H100 tier (8-seq -> (H100, 16))."""
+    by_key = modal_app_module.ENGINE_BY_KEY
+    assert gpu_for("Qwen/Qwen3.8-27B") == "H100"
+    assert modal_app_module._engine_cls_for("Qwen/Qwen3.8-27B") is by_key[("H100", 16)]
+    assert by_key[("H100", 16)].pinned_gpu == "H100"
 
 
 def test_35b_moe_routes_to_h200(modal_app_module):
@@ -796,14 +798,14 @@ def test_load_prequant_checkpoint_for_9b(modal_app_module, monkeypatch, tmp_path
     assert getattr(args, "max_num_batched_tokens", None) is None
 
 
-def test_qwen38_candidate_immutable_args_fail_closed_when_vllm_drops_revision_support():
+def test_qwen38_immutable_args_fail_closed_when_vllm_drops_revision_support():
     from flash.serving.src.engine import boot
-    from flash.serving.src.engine.model_config import _QWEN38_HOSTED_CANDIDATE
+    from flash.serving.src.engine.model_config import engine_overrides_for
 
     with pytest.raises(RuntimeError, match=r"cannot pin.*missing engine args"):
         boot._required_immutable_args(
             "Qwen/Qwen3.8-27B",
-            _QWEN38_HOSTED_CANDIDATE["engine"],
+            engine_overrides_for("Qwen/Qwen3.8-27B"),
             {"model"},
         )
 

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/tests/serving/test_prequant_config.py

@@ -13,7 +13,7 @@ from flash.serving.src.engine.prequant_config import (
 )
 
 OWNED_9B = "Qwen/Qwen3.5-9B"
-PENDING_27B = "Qwen/Qwen3.8-27B"
+DENSE_27B = "Qwen/Qwen3.8-27B"
 MOE_35B = "Qwen/Qwen3.6-35B-A3B"
 
 
@@ -21,20 +21,21 @@ def test_owned_fp8_contains_only_the_freesolo_9b_checkpoint() -> None:
     assert OWNED_FP8_MODEL_REPOS == {OWNED_9B: "Freesolo-Co/Qwen3.5-9B-FP8"}
 
 
-def test_official_fp8_contains_only_the_active_35b_moe_default() -> None:
+def test_official_fp8_contains_the_active_27b_and_35b_moe_defaults() -> None:
     assert OFFICIAL_FP8_MODEL_REPOS == {
+        DENSE_27B: "Qwen/Qwen3.8-27B-FP8",
         MOE_35B: "Qwen/Qwen3.6-35B-A3B-FP8",
     }
-    assert PENDING_27B not in FP8_SERVE_MODEL_REPOS
     assert set(FP8_SERVE_MODEL_REPOS) == set(base_models())
 
 
 def test_fp8_serve_model_for_resolves_every_active_base_without_translation() -> None:
     assert fp8_serve_model_for(OWNED_9B) == "Freesolo-Co/Qwen3.5-9B-FP8"
+    assert fp8_serve_model_for(DENSE_27B) == "Qwen/Qwen3.8-27B-FP8"
     assert fp8_serve_model_for(MOE_35B) == "Qwen/Qwen3.6-35B-A3B-FP8"
-    for inactive in (PENDING_27B, "Qwen/Qwen3.6-27B"):
-        with pytest.raises(ValueError, match="Allowed models"):
-            fp8_serve_model_for(inactive)
+    # the retired 3.6-27B is a DIFFERENT model from the active 3.8-27B and stays unresolvable.
+    with pytest.raises(ValueError, match="Allowed models"):
+        fp8_serve_model_for("Qwen/Qwen3.6-27B")
 
 
 def test_fp8_serve_model_for_rejects_unknown_base() -> None:

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/tests/serving/test_usage_outbox.py

@@ -34,6 +34,7 @@ from flash.serving.src.accounting.usage_outbox import (
     UsageEvent,
     UsageOutboxError,
 )
+from flash.serving.src.engine.model_config import base_models
 from flash.serving.src.http.inference_routes import _discard_prepared_stream
 from flash.serving.src.http.router import AdapterRouter, build_serving_app
 from flash.serving.src.io.schemas import AdapterRecord
@@ -184,41 +185,30 @@ class _Store(OfflineUsageStore):
 
 
 def test_freesolo_prices_match_committed_catalog_fixed_point_contract() -> None:
+    # The charged per-token rate is the launch per-Mtok price divided by 1e6 with NO markup applied,
+    # so each value below is exactly its published rate shifted six places. Retired models are absent:
+    # the table is exactly the active hosted set.
     expected = {
-        "Qwen/Qwen3.5-0.8B": {
-            "prompt_token_usd": "0.000000012",
-            "cached_prompt_token_usd": "0.0000000024",
-            "completion_token_usd": "0.00000006",
-        },
-        "Qwen/Qwen3.5-2B": {
-            "prompt_token_usd": "0.000000024",
-            "cached_prompt_token_usd": "0.0000000048",
-            "completion_token_usd": "0.00000012",
-        },
-        "Qwen/Qwen3.5-4B": {
-            "prompt_token_usd": "0.000000036",
-            "cached_prompt_token_usd": "0.0000000072",
-            "completion_token_usd": "0.00000018",
-        },
         "Qwen/Qwen3.5-9B": {
-            "prompt_token_usd": "0.0000001368",
+            "prompt_token_usd": "0.000000095",
             "cached_prompt_token_usd": "0.0000000276",
-            "completion_token_usd": "0.000000228",
+            "completion_token_usd": "0.0000001425",
         },
-        "Qwen/Qwen3.6-27B": {
-            "prompt_token_usd": "0.00000051048",
-            "cached_prompt_token_usd": "0.000000168",
-            "completion_token_usd": "0.000003666",
+        "Qwen/Qwen3.8-27B": {
+            "prompt_token_usd": "0.0000003325",
+            "cached_prompt_token_usd": "0.00000003325",
+            "completion_token_usd": "0.0000024225",
         },
         "Qwen/Qwen3.6-35B-A3B": {
-            "prompt_token_usd": "0.0000002376",
-            "cached_prompt_token_usd": "0.0000000792",
-            "completion_token_usd": "0.000001518",
+            "prompt_token_usd": "0.000000095",
+            "cached_prompt_token_usd": "0.0000000475",
+            "completion_token_usd": "0.0000009025",
         },
     }
     decimal_string = re.compile(r"^(0|[1-9][0-9]*)(\.[0-9]+)?$")
 
     assert set(_FREESOLO_USD_PER_MTOK) == set(expected)
+    assert set(_FREESOLO_USD_PER_MTOK) == set(base_models())
     for model, snapshot in expected.items():
         actual = freesolo_price(model).snapshot
         assert actual == snapshot

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/tests/serving/test_usage_reporter.py

@@ -124,6 +124,23 @@ def test_lora_engine_scales_to_zero_by_default(modal_app_module):
     assert modal_app_module.app.function.call_args.kwargs["min_containers"] == 1
 
 
+def test_every_gpu_engine_is_capped_at_three_containers(modal_app_module):
+    # At most 3 GPUs per base model. `base_model` is a modal.parameter(), so Modal gives each distinct
+    # value its own container pool with its own autoscaling accounting -- the cap therefore binds PER
+    # MODEL, not across the catalog. Engines are tensor-parallel 1 on a single-card `gpu=` request, so
+    # one container is exactly one GPU. Asserted on the kwargs modal is actually CALLED with, because a
+    # ceiling that never reaches `app.cls` does not bound anything.
+    assert modal_app_module.MAX_CONTAINERS == 3
+
+    cls_calls = [call.kwargs for call in modal_app_module.app.cls.call_args_list]
+    assert len(cls_calls) == len(modal_app_module.ENGINE_BY_KEY)
+    assert all(kwargs["max_containers"] == 3 for kwargs in cls_calls)
+
+    # The cpu router is deliberately UNCAPPED: it is the front door that triggers cold engines, and
+    # capping it would throttle every model at once rather than bounding gpu spend per model.
+    assert "max_containers" not in modal_app_module.app.function.call_args.kwargs
+
+
 def test_scaledown_window_is_per_tier_and_cheaper_tiers_release_sooner(modal_app_module):
     # The whole point of the table: an idle container bills at the full gpu rate, so a cheap
     # fast-booting tier must not hold a card as long as the 35B's ~1010s-boot H200 does.

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/tests/test_catalog_consistency.py

@@ -136,7 +136,7 @@ def test_public_rows_prune_unset_serving_capacity_fields():
     }
 
 
-def test_serving_repos_cover_public_catalog_without_hosted_activation() -> None:
+def test_serving_repos_cover_public_catalog_and_hosted_activation() -> None:
     assert SERVING_MODEL_REPOS == {
         "Qwen/Qwen3.5-9B": "Freesolo-Co/Qwen3.5-9B-FP8",
         "Qwen/Qwen3.8-27B": "Qwen/Qwen3.8-27B-FP8",
@@ -145,7 +145,7 @@ def test_serving_repos_cover_public_catalog_without_hosted_activation() -> None:
     assert MODELS["Qwen/Qwen3.8-27B"].serving is not None
     from flash.serving.src.engine.model_config import SERVING_MODELS
 
-    assert "Qwen/Qwen3.8-27B" not in {entry["base_model"] for entry in SERVING_MODELS}
+    assert "Qwen/Qwen3.8-27B" in {entry["base_model"] for entry in SERVING_MODELS}
 
 
 def test_qwen38_27b_fixture_binds_checkpoint_metadata() -> None:

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/tests/test_serve.py

@@ -245,9 +245,16 @@ def test_deploy_9b_dry_run_is_not_rejected():
     assert dep.to_dict()["state"] == "dry_run"
 
 
-def test_deploy_27b_rejects_before_rank_resolution_or_dry_run_success(monkeypatch):
+def test_deploy_inactive_model_rejects_before_rank_resolution_or_dry_run_success(monkeypatch):
+    # The hosted-activation guard must fire FIRST: before rank validation and before any artifact is
+    # shaped, so an inactive model cannot reach a dry-run success or a paid path. Uses a model absent
+    # from the hosted catalog -- 27B is active, so it is no longer a witness for this rejection.
     import flash.serve.deployment.adapter_check as adapter_check
     import flash.serve.deployment.deploy as deploy
+    from flash.serving.src.engine.model_config import is_supported_base_model
+
+    inactive_model = "Qwen/Qwen3.5-99B"
+    assert not is_supported_base_model(inactive_model)
 
     monkeypatch.setattr(
         adapter_check,
@@ -262,15 +269,44 @@ def test_deploy_27b_rejects_before_rank_resolution_or_dry_run_success(monkeypatc
 
     with pytest.raises(ValueError, match="not active in hosted serving"):
         deploy.deploy_adapter(
-            run_id="q27",
-            model="Qwen/Qwen3.8-27B",
+            run_id="q99",
+            model=inactive_model,
             hf_repo="org/repo",
-            adapter_prefix="sft/q27/seed0",
+            adapter_prefix="sft/q99/seed0",
             dry_run=True,
             lora_rank=64,
         )
 
 
+def test_deploy_27b_is_active_and_reaches_rank_validation(monkeypatch):
+    # The complement of the guard test: 27B is now an ACTIVE hosted tier, so it must pass the
+    # activation gate and proceed into rank validation rather than being rejected up front.
+    import flash.serve.deployment.adapter_check as adapter_check
+    import flash.serve.deployment.deploy as deploy
+    from flash.serving.src.engine.model_config import is_supported_base_model
+
+    assert is_supported_base_model("Qwen/Qwen3.8-27B")
+
+    reached = []
+    monkeypatch.setattr(
+        adapter_check,
+        "validate_serving_lora_rank",
+        lambda *args, **kwargs: reached.append(args[0]),
+    )
+
+    dep = deploy.deploy_adapter(
+        run_id="q27",
+        model="Qwen/Qwen3.8-27B",
+        hf_repo="org/repo",
+        adapter_prefix="sft/q27/seed0",
+        dry_run=True,
+        lora_rank=64,
+    )
+
+    assert reached == ["Qwen/Qwen3.8-27B"]
+    assert dep.to_dict()["state"] == "dry_run"
+
+
 def test_deploy_rejects_lora_rank_above_serving_cap():
     from flash.core.catalog import serving_lora_rank_cap
     from flash.serve.deployment.deploy import deploy_adapter

{freesolo_flash_dev-1.2.121 → freesolo_flash_dev-1.2.122}/uv.lock

@@ -1480,7 +1480,7 @@ wheels = [
 
 [[package]]
 name = "freesolo-flash"
-version = "1.2.121"
+version = "1.2.122"
 source = { editable = "." }
 
 [package.optional-dependencies]