freesolo-flash-dev 1.0.0__tar.gz → 1.0.1__tar.gz

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 1.0.0
+Version: 1.0.1
 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.0.0 → freesolo_flash_dev-1.0.1}/flash/catalog.py

@@ -111,6 +111,8 @@ class ModelInfo:
     # multimodal-nested config, so the curated values are what actually engage the gate.
     num_layers: int = 0
     hidden_size: int = 0
+    # vllm hybrid-mamba cache block size in tokens. 0 means the model has no catalogued mamba floor.
+    mamba_block_size: int = 0
 
     @property
     def is_moe(self) -> bool:
@@ -124,6 +126,8 @@ class ModelInfo:
 
     def to_dict(self) -> dict[str, Any]:
         data = asdict(self)
+        if not data["mamba_block_size"]:
+            del data["mamba_block_size"]
         serving = data["serving"]
         if serving is None:
             del data["serving"]
@@ -170,7 +174,7 @@ MODELS: dict[str, ModelInfo] = {
             serve_model_id=SERVING_FP8_MODEL_REPOS["openbmb/MiniCPM5-1B"],
             max_loras=16,
             max_lora_rank=128,
-            max_model_len=8192,
+            max_model_len=32768,
         ),
         thinking="hybrid",
         notes="On-device class SLM (131k ctx); standard Llama architecture.",
@@ -189,7 +193,7 @@ MODELS: dict[str, ModelInfo] = {
             serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-0.8B"],
             max_loras=16,
             max_lora_rank=128,
-            max_model_len=8192,
+            max_model_len=32768,
         ),
         thinking="hybrid",
         notes="Smallest Qwen3.5; cheap smoke/dev runs with the modern arch.",
@@ -208,7 +212,7 @@ MODELS: dict[str, ModelInfo] = {
             serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-2B"],
             max_loras=16,
             max_lora_rank=128,
-            max_model_len=8192,
+            max_model_len=32768,
         ),
         thinking="hybrid",
     ),
@@ -226,7 +230,7 @@ MODELS: dict[str, ModelInfo] = {
             serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-4B"],
             max_loras=16,
             max_lora_rank=64,
-            max_model_len=8192,
+            max_model_len=32768,
             max_num_seqs=8,
             gpu_memory_utilization=0.98,
         ),
@@ -247,11 +251,11 @@ MODELS: dict[str, ModelInfo] = {
         quant="bf16",
         recommended_gpu="A100 PCIe",
         serving=ServingCapacity(
-            gpu="L4",
+            gpu="H100",
             serve_model_id=SERVING_FP8_MODEL_REPOS["Qwen/Qwen3.5-9B"],
             max_loras=16,
             max_lora_rank=64,
-            max_model_len=8192,
+            max_model_len=32768,
             max_num_seqs=8,
             gpu_memory_utilization=0.98,
         ),
@@ -271,6 +275,10 @@ MODELS: dict[str, ModelInfo] = {
         # layers x 2048 hidden (hybrid GatedDeltaNet + full-attention, 256 experts / 8 active).
         num_layers=40,
         hidden_size=2048,
+        # vllm 0.19.1 model_executor/models/config.py derives this from the qwen config via
+        # mamba_utils.py: the 1,097,728-byte gdn state page needs 1072 fp8 attention tokens
+        # after the 16-token backend alignment applied by hybridattentionmambamodelconfig.
+        mamba_block_size=1072,
         vocab_size=248_320,
         algos=ALGORITHMS,
         min_vram_gb=141,
@@ -312,6 +320,17 @@ MODELS: dict[str, ModelInfo] = {
 }
 
 
+def opd_mamba_batched_token_floor(
+    model_id: str, seq_cap: int, max_num_seqs: int | None
+) -> int | None:
+    """return a mamba floor only when vllm's derived opd scheduler budget is too small."""
+    info = MODELS.get(model_id)
+    if info is None or info.mamba_block_size <= 0 or max_num_seqs is None:
+        return None
+    derived_budget = int(max_num_seqs) * int(seq_cap)
+    return info.mamba_block_size if derived_budget < info.mamba_block_size else None
+
+
 def list_models() -> list[ModelInfo]:
     return sorted(MODELS.values(), key=lambda m: (m.min_vram_gb, m.id))
 

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/cli/commands.py

@@ -214,6 +214,7 @@ def _cmd_train_cost(args) -> int:
     Catalog-only and deterministic. SFT cost never imports the environment; it requires a positive
     [train].max_examples row count instead of guessing or locally counting a dataset."""
     from flash.cost import estimate_cost
+    from flash.lora_rank import preflight_train_context_within_serving
 
     spec = spec_from_file(
         args.config,
@@ -221,6 +222,7 @@ def _cmd_train_cost(args) -> int:
         overrides=args.overrides,
         extra_configs=args.extra_configs,
     )
+    preflight_train_context_within_serving(spec)
     if spec.train.init_from_adapter:
         # --cost is offline/catalog-only and cannot read the source adapter, so the rank stays at the
         # local default. Warm starts train and are priced at the SOURCE adapter's authoritative rank
@@ -302,23 +304,24 @@ def cmd_train(args) -> int:
     )
     payload = spec_payload(spec, authored_train_keys=authored_train_keys)
     client = client_from_config()
+    client_train_schema = {
+        "version": __version__,
+        "fields": train_schema_metadata(),
+        "authored_keys": sorted(authored_train_keys),
+    }
+    runtime_secrets = (
+        runtime_secrets_from_local_env(args.config, keys=spec.environment.secrets) or None
+    )
     if args.dry_run:
-        # Dry-run is a faithful server-side preview: the control plane runs the SAME config
-        # validation and warm-start/serving preflights it would at real submit (serving rank/context
-        # caps, the continued warm-start rank match, cost quote) and records a state=dry_run run, but
-        # allocates no GPU and charges nothing. Local runtime secrets aren't sent — the server
-        # relaxes the required-[environment].secrets check for a preview, so `--dry-run` works before
-        # prod secrets are wired up. A rejection surfaces as the server's `error: ...` (exit 1),
-        # exactly as a real submit would.
+        # dry-run is a faithful server-side preview: it sends the same declared secrets and runs the
+        # same config, warm-start, serving, and cost preflights as a real submit, but allocates no gpu
+        # and charges nothing. a rejection surfaces as the server's error with exit status 1.
         try:
             status = client.create_run(
                 payload,
+                runtime_secrets=runtime_secrets,
                 dry_run=True,
-                client_train_schema={
-                    "version": __version__,
-                    "fields": train_schema_metadata(),
-                    "authored_keys": sorted(authored_train_keys),
-                },
+                client_train_schema=client_train_schema,
             )
         except ApiError as exc:
             detail = _legacy_train_key_rejection_detail(exc, authored_train_keys)
@@ -338,7 +341,8 @@ def cmd_train(args) -> int:
         return 0
     status = client.create_run(
         payload,
-        runtime_secrets=runtime_secrets_from_local_env(args.config, keys=spec.environment.secrets),
+        runtime_secrets=runtime_secrets,
+        client_train_schema=client_train_schema,
     )
     run_id = status["run_id"]
     logger.info(

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/client/http.py

@@ -343,8 +343,8 @@ class ApiClient:
             # Server-side preview: runs the same validation/preflights as a real submit and records a
             # state=dry_run run, but allocates no GPU and charges nothing. Returns that status.
             body["dry_run"] = True
-            if client_train_schema is not None:
-                body["client_train_schema"] = client_train_schema
+        if client_train_schema is not None:
+            body["client_train_schema"] = client_train_schema
         return self._request("POST", "/v1/runs", body=body)
 
     def list_runs(self) -> list[dict]:

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/engine/worker/opd_vllm.py

@@ -127,7 +127,8 @@ def opd_vllm_kwargs(model_id: str, knobs: Any, seq_cap: int) -> dict[str, Any]:
 
     fp8_kv = bool(cc >= (8, 9))
     kwargs["kv_cache_dtype"] = "fp8" if fp8_kv else None
-    kwargs["max_num_batched_tokens"] = max(8192, int(seq_cap)) if card_gb >= 140 else None
+    if card_gb >= 140:
+        kwargs["max_num_batched_tokens"] = max(8192, int(seq_cap))
 
     if card_gb > 0:
         try:
@@ -189,6 +190,12 @@ def opd_vllm_kwargs(model_id: str, knobs: Any, seq_cap: int) -> dict[str, Any]:
             kwargs["rollout_batch_size"] = rollout_concurrency
         except Exception as exc:
             print(f"[opd] vLLM memory-util sizing failed; using 0.10: {exc}")
+    if card_gb < 140:
+        from flash.catalog import opd_mamba_batched_token_floor
+
+        kwargs["max_num_batched_tokens"] = opd_mamba_batched_token_floor(
+            model_id, seq_cap, kwargs["max_num_seqs"]
+        )
     if startup_oom is not None:
         raise startup_oom
 

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/runner/__init__.py

@@ -691,7 +691,7 @@ def _prepare_init_from_adapter(
     owner_key_id: int | None = None,
     token: str | None = None,
 ) -> tuple[JobSpec, JobSpec, dict | None]:
-    """Preserve the public request while applying source metadata only to the worker spec."""
+    """prepare public and worker specs with source-authoritative adapter metadata."""
     _require_supported_adapter_continuation(spec)
     ref = spec.train.init_from_adapter
     if not ref:
@@ -776,7 +776,7 @@ def _prepare_init_from_adapter(
     )
     assert metadata is not None
     identity = adapter_artifact_identity(storage, config, token, revision).to_dict()
-    public_spec = spec
+    public_spec = replace(spec, train=replace(spec.train, lora_alpha=metadata.alpha))
     worker_spec = replace(
         worker_spec,
         train=replace(worker_spec.train, lora_rank=metadata.rank, lora_alpha=metadata.alpha),

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/schema/__init__.py

@@ -546,7 +546,12 @@ def _validate_grpo(spec: JobSpec) -> None:
 
 
 def _validate_opd(spec: JobSpec) -> None:
-    """validate that the opd context budget leaves room for a prompt."""
+    """validate opd-specific training constraints."""
+    if spec.train.kl_penalty_coef == 0.0:
+        raise ConfigError(
+            "[train] kl_penalty_coef must be > 0 for opd because it scales the gkd "
+            "distillation objective; omit it to use the default 1.0 or set a positive value"
+        )
     if spec.train.max_context_tokens:
         # Mirror run_opd's prompt-budget guard at PARSE time: a context budget that leaves no room
         # for any prompt after the completion budget is rejected here, BEFORE a paid worker is
@@ -564,6 +569,9 @@ def _validate_opd(spec: JobSpec) -> None:
                 f"invalid budget fails before a GPU worker is provisioned."
             )
 
+        # short hybrid-mamba contexts are safe because the worker compares vllm's derived scheduler
+        # budget with the catalogued block size and supplies an explicit floor only when required.
+
 
 # Each algorithm's spec-level contract lives in ONE validator, dispatched by name so a new algorithm
 # adds a function + a map entry rather than another scattered ``if spec.algorithm == ...`` block.

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/serve/export.py

@@ -6,9 +6,12 @@ the destination model repo, so the user never needs access to internal artifact
 
 from __future__ import annotations
 
+import contextlib
 import json
 import os
 import re
+import shutil
+import struct
 import tempfile
 from pathlib import Path
 
@@ -23,6 +26,128 @@ _STALE_ADAPTER_DELETE_PATTERNS = ["adapter_model*", "adapter_config.json"]
 _TEMP_MERGED_BASE_MODEL_RE = re.compile(
     r"(?:/[^\s\"'`,\]\){}]+)*/flash_sft_merged_[^\s\"'`,\]\){}]+"
 )
+_MAX_SAFETENSORS_HEADER_BYTES = 100 * 1024 * 1024
+
+# module-path segments outside the language model; mirrors _VL_EXCLUDE_SEGMENTS in
+# flash/engine/worker/lora.py. today's managed adapters never touch these (the worker
+# excludes them from lora), so their presence means a genuinely multimodal adapter whose
+# vision keys the text-only strip cannot represent. normalizing only the lm keys of such
+# an adapter would produce a mixed namespace that matches no transformers class, so the
+# normalization must skip the file entirely and export it as trained.
+_NON_LM_KEY_SEGMENTS = (".visual.", ".vision_tower.", ".multi_modal_projector.", ".mtp.")
+
+
+def _references_non_lm_modules(key: str) -> bool:
+    return any(segment in key for segment in _NON_LM_KEY_SEGMENTS)
+
+
+def _strip_language_model_infix(key: str) -> str:
+    # mirrors _LANGUAGE_MODEL_INFIX namespace semantics in flash/engine/worker/lora.py
+    infix = ".language_model."
+    index = key.find(infix)
+    if index == -1:
+        return key
+    return key[:index] + "." + key[index + len(infix) :]
+
+
+def _json_object_without_duplicate_keys(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    value: dict[str, object] = {}
+    for key, item in pairs:
+        if key in value:
+            raise ValueError(f"duplicate safetensors JSON key {key!r}")
+        value[key] = item
+    return value
+
+
+def _normalize_export_adapter_keys(adapter_dir: Path) -> bool:
+    path = adapter_dir / "adapter_model.safetensors"
+    if not path.is_file():
+        logger.warning("exported adapter has no safetensors weights; leaving weights unchanged")
+        return False
+
+    temp_path: Path | None = None
+    try:
+        file_size = path.stat().st_size
+        with path.open("rb") as source:
+            length_bytes = source.read(8)
+            if len(length_bytes) != 8:
+                raise ValueError("file is too small to contain a safetensors header")
+            (header_length,) = struct.unpack("<Q", length_bytes)
+            if (
+                header_length > file_size - 8
+                or header_length > _MAX_SAFETENSORS_HEADER_BYTES
+            ):
+                raise ValueError(
+                    f"declared header length {header_length} is implausible for {file_size}-byte file"
+                )
+            header_bytes = source.read(header_length)
+            if len(header_bytes) != header_length:
+                raise ValueError("safetensors header is truncated")
+            header = json.loads(
+                header_bytes,
+                object_pairs_hook=_json_object_without_duplicate_keys,
+            )
+            if not isinstance(header, dict):
+                raise ValueError("safetensors header is not a JSON object")
+
+            non_lm = [
+                key
+                for key in header
+                if key != "__metadata__" and _references_non_lm_modules(key)
+            ]
+            if non_lm:
+                logger.info(
+                    "exported adapter touches non-lm modules (e.g. %s); keeping the "
+                    "multimodal key namespace unchanged",
+                    non_lm[0],
+                )
+                return False
+
+            normalized: dict[str, object] = {}
+            remapped = 0
+            for key, value in header.items():
+                normalized_key = (
+                    key if key == "__metadata__" else _strip_language_model_infix(key)
+                )
+                if normalized_key in normalized:
+                    raise ValueError(
+                        f"key {key!r} collides after stripping the '.language_model.' infix"
+                    )
+                normalized[normalized_key] = value
+                remapped += int(normalized_key != key)
+            if remapped == 0:
+                return False
+
+            new_header = json.dumps(
+                normalized,
+                ensure_ascii=False,
+                separators=(",", ":"),
+            ).encode("utf-8")
+            new_header += b" " * (-len(new_header) % 8)
+            with tempfile.NamedTemporaryFile(
+                mode="wb",
+                dir=path.parent,
+                prefix=f".{path.name}.",
+                delete=False,
+            ) as destination:
+                temp_path = Path(destination.name)
+                destination.write(struct.pack("<Q", len(new_header)))
+                destination.write(new_header)
+                shutil.copyfileobj(source, destination)
+                destination.flush()
+                os.fsync(destination.fileno())
+        os.replace(temp_path, path)
+        temp_path = None
+    except Exception as exc:
+        logger.warning("could not normalize exported adapter keys; leaving weights unchanged: %s", exc)
+        return False
+    finally:
+        if temp_path is not None:
+            with contextlib.suppress(OSError):
+                temp_path.unlink(missing_ok=True)
+
+    logger.info("normalized %d exported adapter weight keys", remapped)
+    return True
 
 
 def _rewrite_adapter_config_base_model(
@@ -94,6 +219,23 @@ def _hf_api():
     return HfApi, snapshot_download
 
 
+def _hub_error_types() -> tuple[type[BaseException], ...]:
+    error_types: list[type[BaseException]] = []
+    try:
+        from huggingface_hub.errors import HfHubHTTPError
+    except ImportError:
+        pass
+    else:
+        error_types.append(HfHubHTTPError)
+    try:
+        from requests import RequestException
+    except ImportError:
+        pass
+    else:
+        error_types.append(RequestException)
+    return tuple(error_types)
+
+
 def export_adapter(
     *,
     source_repo: str,
@@ -125,9 +267,9 @@ def export_adapter(
                 local_dir=tmp,
                 token=read_token,
             )
-        except OSError:
-            raise
         except Exception as exc:
+            if isinstance(exc, OSError) and not isinstance(exc, _hub_error_types()):
+                raise
             raise ServingError(
                 f"could not download adapter {source_repo}:{source_subfolder}: {exc}"
             ) from exc
@@ -143,6 +285,7 @@ def export_adapter(
                 "(need adapter_config.json + an adapter_model* weight; nothing to export)"
             )
         _repair_export_metadata(adapter_dir, base_model, base_model_revision)
+        _normalize_export_adapter_keys(adapter_dir)
         api = HfApi(token=dest_token)
         try:
             # Always create private first so the repo is never transiently exposed empty/partial.
@@ -161,9 +304,9 @@ def export_adapter(
             )
             if not private:
                 api.update_repo_settings(repo_id=dest_repo, repo_type="model", private=False)
-        except OSError:
-            raise
         except Exception as exc:
+            if isinstance(exc, OSError) and not isinstance(exc, _hub_error_types()):
+                raise
             raise ServingError(f"could not upload adapter to {dest_repo}: {exc}") from exc
     logger.info(
         "exported %s:%s -> %s (%d files)", source_repo, source_subfolder, dest_repo, len(files)

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/server/_deps.py

@@ -74,9 +74,7 @@ def _parse_spec(payload: dict, run_id: str) -> JobSpec:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
 
-def _runtime_secrets(
-    payload: dict, spec: JobSpec, *, require_environment_secrets: bool
-) -> dict[str, str]:
+def _runtime_secrets(payload: dict, spec: JobSpec) -> dict[str, str]:
     # Use get()+None check, not `or {}` — falsy non-objects must still hit the type check below.
     raw = payload.get("runtime_secrets")
     if raw is None:
@@ -102,14 +100,12 @@ def _runtime_secrets(
         value = value.strip()
         if value:
             out[key] = value
-    if require_environment_secrets:
-        missing = sorted(set(spec.environment.secrets) - set(out))
-        if missing:
-            raise HTTPException(
-                status_code=400,
-                detail=(
-                    "missing runtime secret(s) required by [environment] secrets: "
-                    f"{', '.join(missing)}"
-                ),
-            )
+    missing = sorted(set(spec.environment.secrets) - set(out))
+    if missing:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"missing runtime secret(s) required by [environment] secrets: {', '.join(missing)}"
+            ),
+        )
     return out

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/server/repo_cleanup.py

@@ -59,6 +59,7 @@ plane with an operator ``HF_TOKEN`` — without it the sweep cannot delete opera
 from __future__ import annotations
 
 import os
+import threading
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass
@@ -87,6 +88,26 @@ RUN_REPO_PREFIX = "flashrun-"
 DELETE_AGE_SECONDS = 7.0 * 86400.0
 _DELETE_SLEEP_S = 0.5  # pause between deletes — HF repo-mutation rate-limit courtesy
 _SCAN_WORKERS = 8  # hf tree-listing concurrency
+# ``list_repo_tree(..., expand=True)`` is HF's most expensive listing mode (expand bypasses the
+# CDN and hits origin for a last_commit lookup per entry) -- it rate-limits well below the
+# general API quota. _scan_repo (one call per repo, fanned across _SCAN_WORKERS) and
+# _prefix_written_within (one call per delete target) both hit it; with no shared pacing, the
+# worker pool lets up to _SCAN_WORKERS calls land on HF in the same instant, which is enough on
+# its own to trip the rate limit on a sweep over more than a handful of repos. This floor paces
+# EVERY list_repo_tree call across the whole sweep (not per-thread), so concurrency no longer
+# translates into a request burst.
+_TREE_LIST_MIN_INTERVAL_S = 0.5  # cap ~2 req/s across the whole sweep, workers included
+_tree_list_lock = threading.Lock()
+_tree_list_last_call = 0.0
+
+
+def _throttle_tree_list() -> None:
+    global _tree_list_last_call
+    with _tree_list_lock:
+        wait = _tree_list_last_call + _TREE_LIST_MIN_INTERVAL_S - time.monotonic()
+        if wait > 0:
+            time.sleep(wait)
+        _tree_list_last_call = time.monotonic()
 
 # Only these top-level dirs are deletable model-artifact phases (``JobSpec.phase``: grpo -> "rl",
 # plus the VL warm-start ``recomb`` recombined adapter). Anything else — ``code/`` snapshots,
@@ -187,6 +208,7 @@ def _scan_repo(api, repo_id: str) -> tuple[dict[str, list], float | None, set[st
     ``prefixes`` maps ``"<phase>/<run_id>"`` -> ``[total_size, newest_commit_ts]`` for ARTIFACT_PHASES
     only, ``ref_recent_ts`` is the newest commit among ``referenced_by/`` markers (warm-start-source
     signal), and ``unknown_tops`` are unrecognized top-level dirs (reported, never deleted)."""
+    _throttle_tree_list()
     entries = api.list_repo_tree(
         repo_id=repo_id, repo_type="dataset", recursive=True, expand=True
     )
@@ -246,6 +268,7 @@ def _prefix_written_within(api, repo_id: str, prefix: str, now: float, max_age_s
     redeploy read-back that landed after enumeration must spare the prefix. Raises on an API error (the
     caller then skips this target to stay safe). If the listing carries no commit dates (older
     ``huggingface_hub``), returns ``False`` — the enumeration age gate already qualified it."""
+    _throttle_tree_list()
     entries = api.list_repo_tree(
         repo_id=repo_id, repo_type="dataset", path_in_repo=prefix, recursive=True, expand=True
     )

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/flash/server/routes/runs.py

@@ -102,11 +102,11 @@ def _precheck_budget_or_block(*, run_id: str, estimate_usd: float, org_id: str)
 def create_run(payload: dict, key: Annotated[dict, Depends(require_key)]):
     dry_run = _require_bool(payload, "dry_run", False)
     schema = _client_train_schema(payload)
+    submitted = payload.get("spec")
+    submitted_train = submitted.get("train") if isinstance(submitted, dict) else None
     try:
         spec = _parse_spec(payload, run_id=new_run_id())
     except HTTPException as exc:
-        submitted = payload.get("spec")
-        submitted_train = submitted.get("train") if isinstance(submitted, dict) else None
         server_fields = train_schema_metadata()
         unsupported = (
             sorted(
@@ -130,7 +130,7 @@ def create_run(payload: dict, key: Annotated[dict, Depends(require_key)]):
             )
             raise HTTPException(status_code=400, detail=detail) from exc
         raise
-    runtime_secrets = _runtime_secrets(payload, spec, require_environment_secrets=not dry_run)
+    runtime_secrets = _runtime_secrets(payload, spec)
     affordability_org_id = str(key.get("org_id") or "").strip()
     bill_on_completion = not dry_run and key.get("auth_kind") != "internal"
     billing_context = None
@@ -176,6 +176,21 @@ def create_run(payload: dict, key: Annotated[dict, Depends(require_key)]):
                     ),
                 ) from exc
             raise
+        if (
+            spec.train.init_from_adapter
+            and schema is not None
+            and "lora_alpha" in schema["authored_keys"]
+            and spec.train.lora_alpha != prepared.worker_spec.train.lora_alpha
+        ):
+            raise HTTPException(
+                status_code=400,
+                detail=(
+                    f"train.lora_alpha={spec.train.lora_alpha} does not match the "
+                    "train.init_from_adapter source adapter "
+                    f"lora_alpha={prepared.worker_spec.train.lora_alpha}; omit train.lora_alpha "
+                    "because source adapter alpha metadata is authoritative"
+                ),
+            )
         run_id = prepared.public_spec.run_id
         if bill_on_completion:
             _precheck_budget_or_block(

{freesolo_flash_dev-1.0.0 → freesolo_flash_dev-1.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.0.0"
+version = "1.0.1"
 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).
@@ -113,7 +113,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.0.0"
+version = "1.0.1"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]