freesolo-flash-dev 0.2.30__tar.gz → 0.2.32__tar.gz

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/.github/workflows/bake-kernel-cache.yml

@@ -76,16 +76,23 @@ jobs:
               gpu_type_id: "NVIDIA RTX A6000",
               allowed_cuda: "",
             }
+          # sm89 (Ada): warm on the L40S -- a DATACENTER Ada card with reliable secure-cloud capacity --
+          # instead of the consumer RTX 4090 (scarce/cold on secure cloud, where the bake pod often never
+          # finished pulling the ~20GB image before the deadline). The cache is sm-keyed, so an L40S-warmed
+          # sm89 cache is valid on every sm89 card (4090/L40/L4). NB: verify the exact RunPod gpuTypeId.
           - {
               sm: sm89,
               arch: "8.9",
-              gpu_type_id: "NVIDIA GeForce RTX 4090",
+              gpu_type_id: "NVIDIA L40S",
               allowed_cuda: "",
             }
+          # sm90 (Hopper): warm on the H200 (141GB, sm90) -- better secure-cloud capacity than the
+          # heavily-contended H100 80GB HBM3 (which cold-pull-stalled the bake). Same sm90, so the cache
+          # is valid on every H100/H200. H200 is in flash's validated GPU catalog (providers/base.py).
           - {
               sm: sm90,
               arch: "9.0",
-              gpu_type_id: "NVIDIA H100 80GB HBM3",
+              gpu_type_id: "NVIDIA H200",
               allowed_cuda: "",
             }
           # Blackwell needs CUDA-13 hosts to JIT its PTX (matches min_cuda_for in the provider). Bake

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/Dockerfile.worker

@@ -63,7 +63,7 @@ RUN pip install --no-cache-dir \
     "tilelang==0.1.11" \
     "apache-tvm-ffi==0.1.11" \
     "hf_transfer" \
-    "freesolo>=0.2.49" \
+    "freesolo>=0.2.52" \
     "runpod"
 # Gated-DeltaNet (Qwen3.5/3.6) runs on flash-linear-attention's Triton kernels. On consumer cards
 # (Ampere/Ada/Blackwell) the Triton path is correct. On Hopper (sm90) fla's GDN chunk_bwd is

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.30
+Version: 0.2.32
 Summary: Flash — managed LoRA post-training (SFT/GRPO) 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
@@ -18,19 +18,20 @@ Requires-Python: <3.13,>=3.11
 Provides-Extra: dev
 Requires-Dist: datasets>=2.19; extra == 'dev'
 Requires-Dist: fastapi; extra == 'dev'
-Requires-Dist: freesolo>=0.2.49; extra == 'dev'
+Requires-Dist: freesolo>=0.2.52; extra == 'dev'
 Requires-Dist: httpx>=0.27; extra == 'dev'
 Requires-Dist: huggingface-hub>=0.34; extra == 'dev'
 Requires-Dist: mypy>=1.13.0; extra == 'dev'
 Requires-Dist: pytest>=9.0.3; extra == 'dev'
 Requires-Dist: ruff>=0.6; extra == 'dev'
 Requires-Dist: runpod-flash; extra == 'dev'
+Requires-Dist: transformers<5.11,>=5.6; extra == 'dev'
 Requires-Dist: uvicorn; extra == 'dev'
 Provides-Extra: gpu
 Requires-Dist: accelerate>=1.4; extra == 'gpu'
 Requires-Dist: bitsandbytes>=0.49; extra == 'gpu'
 Requires-Dist: datasets>=2.19; extra == 'gpu'
-Requires-Dist: freesolo>=0.2.49; extra == 'gpu'
+Requires-Dist: freesolo>=0.2.52; extra == 'gpu'
 Requires-Dist: huggingface-hub>=0.34; extra == 'gpu'
 Requires-Dist: peft>=0.19; extra == 'gpu'
 Requires-Dist: torch==2.10.0; extra == 'gpu'
@@ -40,24 +41,26 @@ Requires-Dist: vllm==0.19.1; extra == 'gpu'
 Provides-Extra: server
 Requires-Dist: datasets>=2.19; extra == 'server'
 Requires-Dist: fastapi; extra == 'server'
-Requires-Dist: freesolo>=0.2.49; extra == 'server'
+Requires-Dist: freesolo>=0.2.52; extra == 'server'
 Requires-Dist: httpx>=0.27; extra == 'server'
 Requires-Dist: huggingface-hub>=0.34; extra == 'server'
 Requires-Dist: runpod-flash; extra == 'server'
+Requires-Dist: transformers<5.11,>=5.6; extra == 'server'
 Requires-Dist: uvicorn; extra == 'server'
 Description-Content-Type: text/markdown
 
 # Flash
 
-Managed LoRA post-training service: SFT and GRPO on managed RunPod Flash GPUs.
-The allocator picks the cheapest validated RunPod GPU class that fits the run.
+Managed LoRA post-training service: SFT and GRPO on managed Flash GPUs.
+The allocator picks the cheapest validated managed GPU class that fits the run.
 
 ## Scope
 
 - `flash train <cfg.toml>` / control-plane `POST /runs` — submit a training job;
   one dedicated GPU per run, supervised server-side (stall watchdog, bounded
   auto-retry resuming from the last streamed checkpoint, endpoint GC).
-- `flash deploy`, `flash chat` — serving for trained adapters.
+- `flash checkpoints`, `flash deploy`, `flash chat` — serving for trained adapters,
+  including deployable intermediate RL checkpoints.
 - **Freesolo SDK environments.** Every run names a Freesolo environment id.
   Scaffold `environment.py` plus `datasets/train.jsonl`, upload `.` or another
   folder with `flash env push --name <name> <folder>`, then reference the
@@ -68,21 +71,22 @@ The allocator picks the cheapest validated RunPod GPU class that fits the run.
 ## Layout
 
 - `flash/catalog.py` — curated model catalog (Qwen3 dense supported tier;
-  Qwen3.5/3.6 experimental tier) + `model_policy = "allow"` VRAM-fit check + each
-  model's `thinking` capability (opt-in reasoning mode `thinking = true`)
+  Qwen3.5/3.6 experimental tier), VRAM-fit sizing, and each model's `thinking`
+  capability (opt-in reasoning mode `thinking = true`)
 - `flash/schema.py`, `flash/spec.py` — TOML → `JobSpec`
 - `flash/runner.py` — server-side run supervisor (durable job handle,
   retries, cost guard, endpoint GC)
-- `flash/providers/` — RunPod Flash provider code (pricing, gpus, durable
+- `flash/providers/` — managed GPU substrate code (pricing, GPU classes, durable
   submit/poll, preflight) behind the `base.Provider` protocol, with an
-  `allocator.py` that picks the cheapest fitting class
+  `allocator.py` that picks the cheapest fitting managed GPU class
 - `flash/engine/` — the on-GPU worker (TRL + colocated vLLM rollouts) and the
   shared recipe; SFT targets and RL rewards route through the active environment
   (task-specific grading lives with its example, not in the engine)
 - `flash/envs/` — environment machinery: registry and the adapter that loads
   Freesolo SDK environments onto the worker's interface
 - `flash env setup` — scaffold a starter local Freesolo env, `datasets/train.jsonl`,
-  and ready-to-run configs to start from
+  ready-to-run configs, and a `TRAINING.md` playbook with common failure modes and
+  mitigations
 - `flash/serve/`, `flash/server/` — adapter serving and the FastAPI control
   plane (run operator-side via the separate `flash-server` command)
 - `Dockerfile` — the control-plane image (used by the repo docker-compose)
@@ -99,11 +103,11 @@ uv run flash --help
 uv run flash-server                      # control plane (operator-side, run once)
 ```
 
-The control plane owns provider credentials: `RUNPOD_API_KEY` is always required,
-plus the shared `HF_TOKEN`.
-The artifact repo is platform-managed and per-run (each run gets its own
-`Freesolo-Co/flashrun-<run_id>`, written by the operator `HF_TOKEN`); it is not a user
-knob and not an operator-wide env var. Clients authenticate with their freesolo API key
+The control plane owns infrastructure credentials plus the shared `HF_TOKEN`.
+The artifact repo is platform-managed and environment-scoped (runs for the same environment share
+one private `Freesolo-Co/flashrun-<environment>-<hash>` repo, written by the operator `HF_TOKEN`);
+Flash uploads code under content-addressed prefixes and only reuses completed snapshots. The repo is
+not a user knob and not an operator-wide env var. Clients authenticate with their freesolo API key
 (`flash login`).
 
 ## Release channels
@@ -173,10 +177,10 @@ Use `choices[0].message.content` for the generated text. The run id is the adapt
 for serving. If the run is not deployed yet, `/v1/runs/<run_id>/chat` returns `409`
 with a hint to deploy first.
 
-Operators can also call the Modal serving app directly after the adapter is registered.
-The default serving app is `https://clado-ai--freesolo-lora-serving.modal.run`, and
-operators can point Flash at another serving app by setting `FREESOLO_SERVING_URL`.
-Use that same base URL when calling the app directly; pass the run id as `model`:
+Operators can also call the serving backend directly after the adapter is registered.
+The default serving backend is `https://clado-ai--freesolo-lora-serving.modal.run`, and
+operators can point Flash at another backend by setting `FREESOLO_SERVING_URL`.
+Use that same base URL when calling the backend directly; pass the run id as `model`:
 
 ```bash
 export FREESOLO_SERVING_URL=https://clado-ai--freesolo-lora-serving.modal.run

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/README.md

@@ -1,14 +1,15 @@
 # Flash
 
-Managed LoRA post-training service: SFT and GRPO on managed RunPod Flash GPUs.
-The allocator picks the cheapest validated RunPod GPU class that fits the run.
+Managed LoRA post-training service: SFT and GRPO on managed Flash GPUs.
+The allocator picks the cheapest validated managed GPU class that fits the run.
 
 ## Scope
 
 - `flash train <cfg.toml>` / control-plane `POST /runs` — submit a training job;
   one dedicated GPU per run, supervised server-side (stall watchdog, bounded
   auto-retry resuming from the last streamed checkpoint, endpoint GC).
-- `flash deploy`, `flash chat` — serving for trained adapters.
+- `flash checkpoints`, `flash deploy`, `flash chat` — serving for trained adapters,
+  including deployable intermediate RL checkpoints.
 - **Freesolo SDK environments.** Every run names a Freesolo environment id.
   Scaffold `environment.py` plus `datasets/train.jsonl`, upload `.` or another
   folder with `flash env push --name <name> <folder>`, then reference the
@@ -19,21 +20,22 @@ The allocator picks the cheapest validated RunPod GPU class that fits the run.
 ## Layout
 
 - `flash/catalog.py` — curated model catalog (Qwen3 dense supported tier;
-  Qwen3.5/3.6 experimental tier) + `model_policy = "allow"` VRAM-fit check + each
-  model's `thinking` capability (opt-in reasoning mode `thinking = true`)
+  Qwen3.5/3.6 experimental tier), VRAM-fit sizing, and each model's `thinking`
+  capability (opt-in reasoning mode `thinking = true`)
 - `flash/schema.py`, `flash/spec.py` — TOML → `JobSpec`
 - `flash/runner.py` — server-side run supervisor (durable job handle,
   retries, cost guard, endpoint GC)
-- `flash/providers/` — RunPod Flash provider code (pricing, gpus, durable
+- `flash/providers/` — managed GPU substrate code (pricing, GPU classes, durable
   submit/poll, preflight) behind the `base.Provider` protocol, with an
-  `allocator.py` that picks the cheapest fitting class
+  `allocator.py` that picks the cheapest fitting managed GPU class
 - `flash/engine/` — the on-GPU worker (TRL + colocated vLLM rollouts) and the
   shared recipe; SFT targets and RL rewards route through the active environment
   (task-specific grading lives with its example, not in the engine)
 - `flash/envs/` — environment machinery: registry and the adapter that loads
   Freesolo SDK environments onto the worker's interface
 - `flash env setup` — scaffold a starter local Freesolo env, `datasets/train.jsonl`,
-  and ready-to-run configs to start from
+  ready-to-run configs, and a `TRAINING.md` playbook with common failure modes and
+  mitigations
 - `flash/serve/`, `flash/server/` — adapter serving and the FastAPI control
   plane (run operator-side via the separate `flash-server` command)
 - `Dockerfile` — the control-plane image (used by the repo docker-compose)
@@ -50,11 +52,11 @@ uv run flash --help
 uv run flash-server                      # control plane (operator-side, run once)
 ```
 
-The control plane owns provider credentials: `RUNPOD_API_KEY` is always required,
-plus the shared `HF_TOKEN`.
-The artifact repo is platform-managed and per-run (each run gets its own
-`Freesolo-Co/flashrun-<run_id>`, written by the operator `HF_TOKEN`); it is not a user
-knob and not an operator-wide env var. Clients authenticate with their freesolo API key
+The control plane owns infrastructure credentials plus the shared `HF_TOKEN`.
+The artifact repo is platform-managed and environment-scoped (runs for the same environment share
+one private `Freesolo-Co/flashrun-<environment>-<hash>` repo, written by the operator `HF_TOKEN`);
+Flash uploads code under content-addressed prefixes and only reuses completed snapshots. The repo is
+not a user knob and not an operator-wide env var. Clients authenticate with their freesolo API key
 (`flash login`).
 
 ## Release channels
@@ -124,10 +126,10 @@ Use `choices[0].message.content` for the generated text. The run id is the adapt
 for serving. If the run is not deployed yet, `/v1/runs/<run_id>/chat` returns `409`
 with a hint to deploy first.
 
-Operators can also call the Modal serving app directly after the adapter is registered.
-The default serving app is `https://clado-ai--freesolo-lora-serving.modal.run`, and
-operators can point Flash at another serving app by setting `FREESOLO_SERVING_URL`.
-Use that same base URL when calling the app directly; pass the run id as `model`:
+Operators can also call the serving backend directly after the adapter is registered.
+The default serving backend is `https://clado-ai--freesolo-lora-serving.modal.run`, and
+operators can point Flash at another backend by setting `FREESOLO_SERVING_URL`.
+Use that same base URL when calling the backend directly; pass the run id as `model`:
 
 ```bash
 export FREESOLO_SERVING_URL=https://clado-ai--freesolo-lora-serving.modal.run

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/docker/bake_kernel_cache.py

@@ -66,15 +66,19 @@ def main() -> int:
     ap = argparse.ArgumentParser(description="offload the kernel-cache warmup to a RunPod GPU")
     ap.add_argument("--arch", required=True, help="TORCH_CUDA_ARCH_LIST target, e.g. 9.0")
     ap.add_argument("--sm", required=True, help="sm tag, e.g. sm90 (must match the produced cache)")
-    ap.add_argument("--gpu-type-id", required=True, help="RunPod gpuTypeId, e.g. 'NVIDIA H100 80GB HBM3'")
+    ap.add_argument(
+        "--gpu-type-id", required=True, help="RunPod gpuTypeId, e.g. 'NVIDIA H100 80GB HBM3'"
+    )
     ap.add_argument("--image", default="ghcr.io/freesolo-co/flash-worker:cu128")
     ap.add_argument("--out", default="build/kernel_cache")
     # the warm pod only pulls the ~20GB image + writes the cache (no model download), so keep this
     # modest -- an over-large ask shrinks the eligible host pool and trips "machine does not have the
     # resources" on scarce classes (e.g. Blackwell sm120 on secure cloud).
     ap.add_argument("--container-disk-gb", type=int, default=60)
-    ap.add_argument("--deadline-min", type=int, default=45)
-    ap.add_argument("--run-id", default="", help="unique suffix for the temp repo (default: time+uuid)")
+    ap.add_argument("--deadline-min", type=int, default=90)
+    ap.add_argument(
+        "--run-id", default="", help="unique suffix for the temp repo (default: time+uuid)"
+    )
     ap.add_argument(
         "--allowed-cuda",
         default="",
@@ -189,6 +193,59 @@ def main() -> int:
                 shutil.move(s, d)
             shutil.rmtree(tmp, ignore_errors=True)
             rc = _verify(args.out, args.sm)
+        else:
+            # Non-success (timeout / pod_died): the pod-side out/ (STARTED marker, warmup.log) lives in
+            # the temp dataset the `finally` below deletes, so pull + print it FIRST. out/STARTED present
+            # = the warmup entrypoint ran (a timeout then means it hung / was slow); STARTED absent is
+            # AMBIGUOUS -- either the pod ran the wrong entrypoint, or the best-effort STARTED upload
+            # failed while the warmup is still running (the pod log disambiguates). warmup.log is only
+            # uploaded AFTER the warmup process returns, so it's present only if the warmup
+            # finished/was killed, not on a pure mid-run hang.
+            log(f"outcome={outcome}: pulling pod-side out/ for diagnostics before cleanup")
+            try:
+                dbg = os.path.join(args.out, ".dbg")
+                snapshot_download(
+                    repo_id=repo,
+                    repo_type="dataset",
+                    allow_patterns=["out/**"],
+                    local_dir=dbg,
+                    token=token,
+                )
+                src = os.path.join(dbg, "out")
+                if os.path.isdir(src) and os.listdir(src):
+                    started = os.path.isfile(os.path.join(src, "STARTED"))
+                    log(f"warmup entrypoint ran (out/STARTED present): {started}")
+                    for root, _, files in os.walk(src):
+                        for f in sorted(files):
+                            p = os.path.join(root, f)
+                            log(f"   out/{os.path.relpath(p, src)} ({os.path.getsize(p)} b)")
+                    wl = os.path.join(src, "warmup.log")
+                    if os.path.isfile(wl):
+                        log("--- warmup.log tail (last 60 lines) ---")
+                        with open(wl, errors="replace") as wlf:
+                            for line in wlf.read().splitlines()[-60:]:
+                                log(f"   | {line}")
+                    else:
+                        log(
+                            "no warmup.log (warmup never returned -> mid-run hang or still running at deadline)"
+                        )
+                else:
+                    # Ambiguous: out/STARTED is uploaded best-effort BEFORE warmup, and the cache tree
+                    # only lands AFTER warmup returns. So an empty out/ means EITHER the entrypoint
+                    # never ran (wrong CMD / docker_args) OR the STARTED upload failed while warmup is
+                    # still mid-run. The pod retries that upload 3x, so a dropped marker is unlikely and
+                    # wrong-entrypoint is the probable cause -- but don't assert it. The only proof is
+                    # the pod's OWN console (its "[bake] uploaded out/STARTED" / WARNING lines), which
+                    # this helper can't fetch (pod terminated below) -> read it in the RunPod dashboard.
+                    log(
+                        "pod produced NO out/ -> warmup entrypoint probably never ran "
+                        "(wrong CMD / docker_args); the only other cause is a failed out/STARTED "
+                        "upload mid-run (unlikely, it retries 3x) -- confirm via the pod console "
+                        "in the RunPod dashboard (this CI log does not capture pod stdout)"
+                    )
+                shutil.rmtree(dbg, ignore_errors=True)
+            except Exception as e:
+                log(f"diagnostic fetch failed (ignore): {str(e)[:160]}")
     finally:
         if pod_id:
             try:

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/docker/bake_pod_entry.py

@@ -28,6 +28,33 @@ def main() -> int:
     arch = os.environ.get("BAKE_ARCH", "")
     api = HfApi(token=token)
 
+    # Upload a STARTED marker FIRST -- before the code download / chalk install / warmup -- so a CI-side
+    # timeout can tell whether this entrypoint even ran. Present on a timeout = the warmup started (so it
+    # hung or was slow); absent = the pod ran the wrong entrypoint, OR this upload itself failed while
+    # the warmup is still running. Retry a few times so a transient HF blip doesn't drop the marker and
+    # make the helper misread a slow run as a wrong entrypoint.
+    started_uploaded = False
+    for attempt in range(3):
+        try:
+            api.upload_file(
+                path_or_fileobj=io.BytesIO(f"started arch={arch}\n".encode()),
+                path_in_repo="out/STARTED",
+                repo_id=repo,
+                repo_type="dataset",
+            )
+            started_uploaded = True
+            print("[bake] uploaded out/STARTED", flush=True)
+            break
+        except Exception as e:
+            # keep the "out/STARTED" token in the line so it greps the same as the success/WARNING lines
+            print(f"[bake] out/STARTED upload attempt {attempt + 1}/3 failed: {e}", flush=True)
+            if attempt < 2:  # no point sleeping after the last attempt
+                time.sleep(3)
+    if not started_uploaded:
+        # The marker never landed; warn loudly so a later "no out/STARTED" is read as upload-failed,
+        # not as a wrong-entrypoint run.
+        print("[bake] WARNING: out/STARTED never uploaded; warmup still proceeds", flush=True)
+
     # the flash code the helper uploaded (upload_code -> code/flash); run the warmup from it.
     snapshot_download(
         repo_id=repo,

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/flash/catalog.py

@@ -29,6 +29,18 @@ DEFAULT_GPU = "RTX 5090"
 _DEFAULT_VOCAB_SIZE = 248_320
 
 
+@dataclass(frozen=True)
+class ServingCapacity:
+    gpu: str
+    max_loras: int
+    max_lora_rank: int
+    max_model_len: int
+    serve_model_id: str = ""
+    max_num_seqs: int = 0
+    max_num_batched_tokens: int = 0
+    gpu_memory_utilization: float = 0.0
+
+
 @dataclass(frozen=True)
 class ModelInfo:
     id: str
@@ -61,6 +73,10 @@ class ModelInfo:
     notes: str = ""
     # 0 = platform default (64 GB) suffices. Runner raises gpu.disk_gb to at least this.
     min_disk_gb: int = 0
+    # Deployment capacity of the external freesolo multi-LoRA serving app. This is separate from
+    # Flash's training GPU recommendation above; serving uses Modal/vLLM and sizes hot LoRA buffers
+    # by max_loras x max_lora_rank at engine init.
+    serving: ServingCapacity | None = None
     # "none" / "hybrid" (Qwen3-style) / "always" (can't disable) / "unknown" (open-model policy)
     thinking: str = "none"
     vocab_size: int = _DEFAULT_VOCAB_SIZE
@@ -79,7 +95,20 @@ class ModelInfo:
     hidden_size: int = 0
 
     def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
+        data = asdict(self)
+        serving = data.get("serving")
+        if serving is None:
+            data.pop("serving", None)
+        else:
+            for key in (
+                "serve_model_id",
+                "max_num_seqs",
+                "max_num_batched_tokens",
+                "gpu_memory_utilization",
+            ):
+                if serving.get(key) in ("", 0, 0.0, None):
+                    serving.pop(key, None)
+        return data
 
 
 DEFAULT_MODEL = "Qwen/Qwen3.5-4B"
@@ -94,6 +123,7 @@ MODELS: dict[str, ModelInfo] = {
         algos=("sft", "grpo"),
         min_vram_gb=12,
         recommended_gpu="RTX 4090",
+        serving=ServingCapacity(gpu="L4", max_loras=16, max_lora_rank=64, max_model_len=32768),
         thinking="hybrid",
         notes="On-device class SLM (131k ctx); standard Llama architecture.",
     ),
@@ -106,6 +136,7 @@ MODELS: dict[str, ModelInfo] = {
         algos=("sft", "grpo"),
         min_vram_gb=12,
         recommended_gpu="RTX 4090",
+        serving=ServingCapacity(gpu="L4", max_loras=16, max_lora_rank=64, max_model_len=32768),
         thinking="hybrid",
         notes="Smallest Qwen3.5; cheap smoke/dev runs with the modern arch.",
     ),
@@ -118,6 +149,7 @@ MODELS: dict[str, ModelInfo] = {
         algos=("sft", "grpo"),
         min_vram_gb=16,
         recommended_gpu="RTX 4090",
+        serving=ServingCapacity(gpu="L4", max_loras=16, max_lora_rank=64, max_model_len=32768),
         thinking="hybrid",
     ),
     "Qwen/Qwen3.5-4B": ModelInfo(
@@ -129,6 +161,15 @@ MODELS: dict[str, ModelInfo] = {
         algos=("sft", "grpo"),
         min_vram_gb=32,
         recommended_gpu="RTX 5090",
+        serving=ServingCapacity(
+            gpu="L4",
+            serve_model_id="lovedheart/Qwen3.5-4B-FP8",
+            max_loras=64,
+            max_lora_rank=32,
+            max_model_len=8192,
+            max_num_seqs=8,
+            gpu_memory_utilization=0.98,
+        ),
         thinking="hybrid",
         notes="Current-gen 4B. GRPO uses the sleep-mode memory recipe (hybrid arch needs "
         "extra engine state-cache); fused DeltaNet kernels ship in the default stack.",
@@ -145,6 +186,15 @@ MODELS: dict[str, ModelInfo] = {
         grpo_min_vram_gb=80,
         quant="bf16",
         recommended_gpu="A100 PCIe",
+        serving=ServingCapacity(
+            gpu="L4",
+            serve_model_id="lovedheart/Qwen3.5-9B-FP8",
+            max_loras=44,
+            max_lora_rank=32,
+            max_model_len=8192,
+            max_num_seqs=8,
+            gpu_memory_utilization=0.98,
+        ),
         thinking="hybrid",
         notes="bf16 LoRA. ~19 GB of weights; SFT fits a 48 GB card, while colocated GRPO "
         "(two bf16 copies + KV + the 248k-vocab fp32 logits) needs an 80 GB-class card "
@@ -174,6 +224,16 @@ MODELS: dict[str, ModelInfo] = {
         sleep_unsupported=True,
         quant="bf16",
         recommended_gpu="H200",
+        serving=ServingCapacity(
+            gpu="A100-80GB",
+            serve_model_id="Qwen/Qwen3.6-35B-A3B-FP8",
+            max_loras=12,
+            max_lora_rank=32,
+            max_model_len=8192,
+            max_num_seqs=8,
+            max_num_batched_tokens=4096,
+            gpu_memory_utilization=0.98,
+        ),
         thinking="hybrid",
         min_disk_gb=200,
         notes="MoE (35B total / ~3B active), bf16 LoRA. SFT runs on the 141 GB H200 (the ~70 GB "
@@ -199,6 +259,24 @@ def get_model(model_id: str) -> ModelInfo:
         ) from exc
 
 
+def serving_lora_rank_cap(model: str | ModelInfo | None) -> int | None:
+    """Return the model's serving LoRA rank cap, or None when Flash has no local cap.
+
+    Serving capacity is model-specific: small serving models currently allow rank 64, while larger
+    serving paths can cap at rank 32. Unknown/open-policy models intentionally return None instead
+    of inheriting a global fallback.
+    """
+    if isinstance(model, ModelInfo):
+        info = model
+    elif isinstance(model, str) and model.strip():
+        info = MODELS.get(model.strip())
+    else:
+        info = None
+    if info is None or info.serving is None:
+        return None
+    return int(info.serving.max_lora_rank)
+
+
 def vocab_size_for(model_id: str) -> int:
     """Curated vocab_size for a model, or the safe default for open-model-policy entries."""
     info = MODELS.get(model_id)

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/flash/cli/__init__.py

@@ -66,7 +66,7 @@ _HELP_GROUPS: list[tuple[str, list[tuple[str, str]]]] = [
         "catalog",
         [
             ("models", "list supported base models"),
-            ("gpus", "list managed GPU classes with live $/hr"),
+            ("gpus", "list managed GPU classes with estimated $/hr"),
         ],
     ),
     (
@@ -226,7 +226,7 @@ def _build_parser() -> argparse.ArgumentParser:
     models = sub.add_parser("models", help="list supported base models")
     models.set_defaults(func=cmd_models)
 
-    gpus = sub.add_parser("gpus", help="list managed GPU classes with live $/hr")
+    gpus = sub.add_parser("gpus", help="list managed GPU classes with estimated $/hr")
     gpus.set_defaults(func=cmd_gpus)
 
     env = sub.add_parser("env", help="manage Freesolo environments")
@@ -268,7 +268,9 @@ def _build_parser() -> argparse.ArgumentParser:
     env_pull.set_defaults(func=cmd_env_pull)
 
     env_delete = env_sub.add_parser("delete", help="delete a published Freesolo environment")
-    env_delete.add_argument("env_id", help="the Freesolo environment id to delete, e.g. you/your-env")
+    env_delete.add_argument(
+        "env_id", help="the Freesolo environment id to delete, e.g. you/your-env"
+    )
     env_delete.add_argument(
         "-y",
         "--yes",

{freesolo_flash_dev-0.2.30 → freesolo_flash_dev-0.2.32}/flash/cli/commands.py

@@ -236,8 +236,8 @@ def cmd_env_setup(args) -> int:
             "[train]\n"
             "steps = 150\n"
             "lora_rank = 32\n"
-            "# GPU and the HF artifact repo are managed automatically by the platform: the GPU is\n"
-            "# the cheapest fitting class across providers, and each run gets its own artifact repo.\n"
+            "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
+            "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
     sft = Path("configs/sft.toml")
     if not sft.exists():
@@ -248,8 +248,8 @@ def cmd_env_setup(args) -> int:
             "[train]\n"
             "epochs = 1\n"
             "lora_rank = 32\n"
-            "# GPU and the HF artifact repo are managed automatically by the platform: the GPU is\n"
-            "# the cheapest fitting class across providers, and each run gets its own artifact repo.\n"
+            "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
+            "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
     training = Path("TRAINING.md")
     if not training.exists():
@@ -280,7 +280,7 @@ def cmd_models(args) -> int:
 
 
 def cmd_gpus(args) -> int:
-    """List RunPod GPU classes, VRAM, and $/hr."""
+    """List validated managed GPU classes, VRAM, and estimated $/hr."""
     from flash.providers.base import GPU_INFO
     from flash.providers.runpod.pricing import static_rates as runpod_static_rates
 
@@ -290,7 +290,7 @@ def cmd_gpus(args) -> int:
     )
     tip = (
         "Tip: GPU class selection is fully automatic — the submit-time allocator always picks the\n"
-        "cheapest validated RunPod class that fits the model, so you don't pin a GPU type."
+        "cheapest validated managed class that fits the model, so you don't pin a GPU type."
     )
     if render.styled():
         rows = [(info.name, info.vram_gb, runpod_rates.get(info.name)) for info in infos]
@@ -300,7 +300,7 @@ def cmd_gpus(args) -> int:
     def fmt_rate(v: float | None) -> str:
         return f"{v:>10.2f}" if v else f"{'-':>10}"
 
-    print(f"{'gpu':<16}{'vram':>6}{'runpod$/hr':>11}")
+    print(f"{'gpu':<16}{'vram':>6}{'$/hr':>11}")
     for info in infos:
         runpod_rate = runpod_rates.get(info.name)
         print(f"{info.name:<16}{info.vram_gb:>5}G{fmt_rate(runpod_rate):>11}")
@@ -338,7 +338,11 @@ def cmd_env_list(args) -> int:
 
 
 def _cmd_train_cost(args) -> int:
-    """Print the pre-flight USD cost for the config and exit without submitting."""
+    """`flash train --cost`: print the pre-flight USD cost for the config and exit (no submit).
+
+    Catalog-only and deterministic; SFT uses the actual local training-token count when the env
+    and tokenizer are importable. An uncapped SFT run must be able to count the env's train split,
+    otherwise it errors instead of guessing a dataset size."""
     from flash.cost import estimate_cost
 
     spec = spec_from_file(
@@ -479,8 +483,7 @@ def cmd_runs(args) -> int:
         spec = r.get("spec") or {}
         model = spec.get("model", "")
         algorithm = str(spec.get("algorithm") or "-").upper()
-        gpu, provider = render._run_where(spec, r.get("remote") or {})
-        where = f"{gpu}@{provider}" if provider else gpu
+        where = render._run_gpu(spec, r.get("remote") or {})
         print(
             f"{r['run_id']:<32}  {r['state']:<11}  {algorithm:<5}  "
             f"{r.get('cost_usd', 0.0):>8.4f}  {where:<22}  {model}"