freesolo-flash-dev 1.2.60__tar.gz → 1.2.61__tar.gz

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.60
+Version: 1.2.61
 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.60 → freesolo_flash_dev-1.2.61}/flash/content/multimodal.py

@@ -250,13 +250,22 @@ def record_has_images(record: dict, messages: list[dict] | None = None) -> bool:
         return True
     for message in messages or []:
         content = message.get("content") if isinstance(message, dict) else None
-        if isinstance(content, list) and any(
-            isinstance(block, dict) and block.get("type") in _IMAGE_BLOCK_TYPES for block in content
-        ):
+        if content_has_images(content):
             return True
     return False
 
 
+def content_has_images(content: object) -> bool:
+    """Whether one message's ``content`` carries an image block.
+
+    The single definition of "this message shows the model an image", so a path that cannot carry
+    media (the multi-turn GRPO bridge) recognises exactly what the paths that can do.
+    """
+    return isinstance(content, list) and any(
+        isinstance(block, dict) and block.get("type") in _IMAGE_BLOCK_TYPES for block in content
+    )
+
+
 def text_only_prompt_messages(messages: list[dict]) -> list[dict]:
     """Drop image content blocks while preserving the teacher's message order and text."""
     stripped: list[dict] = []

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/engine/worker/backend_common.py

@@ -935,6 +935,7 @@ from flash.engine.worker.verl.capabilities import (  # noqa: E402,F401
     resolve_rollout_enforce_eager,
     resolve_verl_loggers,
     resolve_verl_python,
+    rollout_mm_processor_cache_overrides,
     rollout_resident_overrides,
     rollout_sleep_unsupported,
     strict_gdn_probe_module,

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/engine/worker/train/core/child/glue.py

@@ -20,6 +20,12 @@ from uuid import uuid4
 
 _ALLOWED_MESSAGE_KEYS = frozenset({"role", "content"})
 _PROBE_PREFIX = "flash-env-glue-probe"
+# the media block types verl's own dataset parser substitutes for a placeholder, and the exact set
+# it then extracts (rl_dataset.py `_build_messages`: `<image>`/`<video>`/`<audio>` become blocks of
+# the matching type, and `_process_multi_modal_info` returns images, videos, audios). duplicated
+# here as literals rather than imported from flash.content.multimodal because this module is copied
+# into the verl child, where flash is not importable -- see the module docstring.
+_MEDIA_BLOCK_TYPES = frozenset({"image", "video", "audio"})
 
 
 def normalize_token_ids(value) -> list[int]:
@@ -39,8 +45,53 @@ def normalize_token_ids(value) -> list[int]:
     return [int(token_id.item() if hasattr(token_id, "item") else token_id) for token_id in value]
 
 
-def validate_transcript_messages(messages: list[dict], *, source: str) -> list[dict]:
-    """require the exact role/content transcript shape the child rollout loops can represent."""
+def content_block_text(content, *, source: str, position: int) -> str:
+    """flatten one openai-style content block list to the text the transcript represents.
+
+    an image-bearing prompt does NOT reach the child as a string. verl's RLHFDataset rewrites the
+    parquet's string content into blocks -- it splits on the `<image>` placeholder and replaces that
+    segment with an image block (rl_dataset.py `_build_messages`) -- so `raw_prompt` arrives as
+    [{"type": "image", ...}, {"type": "text", "text": ...}] for exactly the multimodal rows flash
+    writes. validating that shape as text-only would reject every image episode at turn one.
+
+    the media blocks are dropped rather than rendered here: they are carried separately, as decoded
+    pixels in `multi_modal_data`, and the prompt ids come from the chat template applied to the
+    ORIGINAL block list. this text view exists for the transcript and the inter-turn glue, which are
+    token-level text operations. a block whose type is neither text nor known media is an error
+    rather than a silent drop -- it would mean the model saw something this transcript cannot show.
+    """
+    parts = []
+    for block in content:
+        if not isinstance(block, dict):
+            raise ValueError(
+                f"{source} message {position} has a content block that is not an object"
+            )
+        block_type = block.get("type")
+        if block_type in _MEDIA_BLOCK_TYPES:
+            continue
+        if block_type != "text":
+            raise ValueError(
+                f"{source} message {position} has an unsupported content block type "
+                f"{block_type!r}; a multi-turn transcript can represent text and media blocks only"
+            )
+        text = block.get("text")
+        if not isinstance(text, str):
+            raise ValueError(f"{source} message {position} has a text block without text")
+        parts.append(text)
+    return "".join(parts)
+
+
+def validate_transcript_messages(
+    messages: list[dict], *, source: str, allow_content_blocks: bool = False
+) -> list[dict]:
+    """require the exact role/content transcript shape the child rollout loops can represent.
+
+    ``allow_content_blocks`` flattens openai-style block lists to their text instead of rejecting
+    them. it is OFF by default and opted into only by a caller that has already extracted the media
+    out of the ORIGINAL blocks, because dropping to text is lossless only once the pixels are held
+    somewhere else. a caller that has not done that extraction must keep raising: silently training
+    on a caption whose image was discarded is the failure this default exists to prevent.
+    """
     if not isinstance(messages, list):
         raise ValueError(f"{source} messages must be a list")
     normalized = []
@@ -62,7 +113,11 @@ def validate_transcript_messages(messages: list[dict], *, source: str) -> list[d
         content = message.get("content")
         if not isinstance(role, str) or not role.strip():
             raise ValueError(f"{source} message {position} has an invalid role")
-        if not isinstance(content, str):
+        if allow_content_blocks and isinstance(content, list):
+            # a multimodal prompt arrives as content BLOCKS, not a string; flatten to the text this
+            # transcript can represent. the media rides separately as decoded pixels.
+            content = content_block_text(content, source=source, position=position)
+        elif not isinstance(content, str):
             raise ValueError(f"{source} message {position} content must be text for multi-turn")
         normalized.append({"role": role, "content": content})
     return normalized

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/engine/worker/train/opd/overrides.py

@@ -17,6 +17,7 @@ from flash.content.structured_outputs import reasoning_parser_for
 from flash.engine.worker.backend_common import (
     agent_loop_workers,
     ray_num_cpus,
+    rollout_mm_processor_cache_overrides,
     rollout_resident_overrides,
     shim_marker_file,
     trainer_dtype_overrides,
@@ -177,32 +178,7 @@ def _actor_rollout_overrides(config: dict, *, max_tokens: int) -> list[str]:
             if config.get("mm_encoder_attn_backend")
             else []
         ),
-        # turn OFF vllm's multimodal processor cache. this is what makes image opd run at all.
-        #
-        # the cache is split across two processes. a SENDER half in the frontend replaces an image
-        # it has already seen with just its hash; a RECEIVER half in the engine core is supposed to
-        # still hold the item that hash names. correctness depends on the two halves staying
-        # mirrored, and opd's rollout lifecycle breaks that: every sleep/pause reaches
-        # `EngineCore._reset_caches()`, which clears the RECEIVER only. vllm says so in its own
-        # source -- "we don't attempt to re-sync the internal caches (P0 sender, P1 receiver)".
-        # the sender then keeps sending hash-only requests for images the receiver has dropped, and
-        # each one dies on `assert mm_item is not None, f"Expected a cached item for {mm_hash=}"`.
-        #
-        # that assertion kills the request rather than the run, so the failure surfaces nowhere near
-        # the cause: the rollouts come back EMPTY, and verl indexes [-1] into a zero-length reward
-        # tensor, so the visible error is an IndexError with no mention of images.
-        #
-        # 0 is vllm's own disable value -- it assigns exactly this internally -- and it gates BOTH
-        # halves, so no hash-only request can be constructed and there is nothing left to desync.
-        # the cost is re-preprocessing a repeated image, which is the right trade: an opd rollout
-        # batch is small and this is the difference between working and not.
-        #
-        # it stays unconditional, like `data.image_key` and `limit_images` above, because it is
-        # inert on a text job -- with no mm items there is no cache to disable.
-        #
-        # `mm_processor_cache_gb`, NOT the older `disable_mm_preprocessor_cache`: that argument was
-        # removed in vllm 0.13.0, and passing it now aborts server startup as an unknown cli flag.
-        "+actor_rollout_ref.rollout.engine_kwargs.vllm.mm_processor_cache_gb=0",
+        *rollout_mm_processor_cache_overrides(),
         # keep the rollout engine RESIDENT for models whose vLLM wake/reload HANGS (catalog
         # sleep_unsupported), exactly as the grpo path does. opd is NOT exempt: main_ppo_sync calls
         # checkpoint_manager.sleep_replicas() during init_workers and again around validation, which

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/engine/worker/train/rl/child/multiturn.py

@@ -209,19 +209,41 @@ class _EpisodePrompt:
 
 
 async def _prepare_episode_prompt(loop_self, raw_prompt) -> _EpisodePrompt:
-    """decode the prompt's media and apply the chat template, in that order."""
-    multi_modal_data = await loop_self.process_multi_modal_info(raw_prompt)
+    """extract the media and render the ids from the ORIGINAL blocks, then validate the transcript.
+
+    ORDER MATTERS, which is why all three steps live in one function rather than as statements a
+    caller could reorder or forget. an image prompt does not arrive as text: verl's RLHFDataset
+    rewrites the parquet's string content into blocks, splitting on the `<image>` placeholder and
+    substituting an image block (rl_dataset.py `_build_messages`), so `raw_prompt` is
+    [{"type": "image", ...}, {"type": "text", ...}] for exactly the rows flash writes for a
+    multimodal job. the media has to come out of those ORIGINAL blocks first, or the pixels are gone
+    by the time the rollout asks for them -- and validating first would reject the block shape
+    outright, which is how multi-turn image rollouts died before the order was pinned here.
+
+    the media extraction and the chat template both read those original blocks: the pixels live in
+    the image/video/audio blocks, and the template needs them in place to emit the placeholder
+    tokens the decoded pixels expand into.
+
+    the validation is a GATE, not a value: this loop generates from `prompt_ids`, so the flattened
+    text is discarded. it still runs, because it is what rejects a transcript this loop cannot
+    represent (unsupported blocks, tool-call metadata) before the episode is paid for. blocks are
+    permitted in that check precisely because the steps above already hold the media and the
+    block-rendered ids.
+    """
+    messages = [dict(message) for message in raw_prompt]
+    multi_modal_data = await loop_self.process_multi_modal_info(messages)
     images = multi_modal_data.get("images")
     videos = multi_modal_data.get("videos")
     audios = multi_modal_data.get("audios")
     mm_processor_kwargs = loop_self._get_mm_processor_kwargs(audios)
     prompt_ids = await loop_self.apply_chat_template(
-        raw_prompt,
+        messages,
         images=images,
         videos=videos,
         audios=audios,
         mm_processor_kwargs=mm_processor_kwargs,
     )
+    validate_transcript_messages(messages, source="initial prompt", allow_content_blocks=True)
     return _EpisodePrompt(multi_modal_data, mm_processor_kwargs, prompt_ids)
 
 
@@ -330,10 +352,7 @@ async def _grpo_run(
     agent_loop_output,
     **kwargs,
 ):
-    raw_prompt = validate_transcript_messages(
-        [dict(message) for message in kwargs["raw_prompt"]], source="initial prompt"
-    )
-    prompt = await _prepare_episode_prompt(self, raw_prompt)
+    prompt = await _prepare_episode_prompt(self, kwargs["raw_prompt"])
     prompt_ids = prompt.prompt_ids
     mm_processor_kwargs = prompt.mm_processor_kwargs
     settings = _EpisodeSettings()

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/engine/worker/train/rl/multi_turn.py

@@ -19,6 +19,7 @@ import time
 from collections.abc import Callable
 from http.server import BaseHTTPRequestHandler
 
+from flash.content.multimodal import content_has_images, message_content_text
 from flash.engine.worker.backend_common import BoundedThreadingHTTPServer
 from flash.engine.worker.score_batcher import ScoreBatcher
 from flash.engine.worker.train.rl.scoring import RolloutScoreRequest, score_rollouts
@@ -68,6 +69,17 @@ class _BadSession(_BadRequest, KeyError):
         return self.args[0] if self.args else ""
 
 
+class _BadEnvReply(_BadRequest, ValueError):
+    """A reply the environment produced that this transcript cannot carry. Also a ValueError.
+
+    The property the handler splits on is PERMANENT versus TRANSIENT, and this is permanent: the
+    environment will produce the same unrepresentable block on every retry, so it belongs with the
+    deliberate rejections rather than with the capacity faults. A bare ValueError here would fall
+    to the 503 branch and tell the reader the bridge had a resource problem, when the fix is to
+    change the environment's reply -- the same misdirection the 400/503 split exists to prevent.
+    """
+
+
 def _request_field(payload: dict, key: str):
     """Read one required payload field, or reject the request.
 
@@ -104,6 +116,66 @@ def request_session_id(payload: dict) -> str:
 # and anything else reaching the handler is this side failing to serve a well-formed request.
 _BAD_REQUEST_ERRORS = (_BadRequest,)
 
+
+def _reject_unrepresentable_reply_blocks(content: list) -> None:
+    """Refuse every reply block this transcript cannot carry, not just the image ones.
+
+    ``message_content_text`` keeps ``type == "text"`` blocks and joins them, which means any OTHER
+    block -- video, audio, a tool-use payload, a type this code has never heard of -- contributes
+    nothing and vanishes without a trace. that is the same silent corruption as the stringified
+    image: the environment intended the model to see something, the model never saw it, and every
+    metric still reports a healthy run. so the flattening below is only allowed to run once the
+    content is known to be text and nothing but text.
+    """
+    for position, block in enumerate(content):
+        if not isinstance(block, dict):
+            raise _BadEnvReply(
+                f"environment reply content block {position} must be an object, not "
+                f"{type(block).__name__}"
+            )
+        block_type = block.get("type")
+        if block_type != "text":
+            raise _BadEnvReply(
+                f"environment reply content block {position} has unsupported type {block_type!r}; "
+                "a multi-turn GRPO environment reply can carry text blocks only"
+            )
+        if not isinstance(block.get("text"), str):
+            raise _BadEnvReply(f"environment reply text block {position} is missing its text")
+
+
+def _env_reply_message(message: dict) -> dict:
+    """one environment reply message, as the role/content text the child transcript can carry.
+
+    the adapter lets an environment return arbitrary message dicts from ``step_episode``, so a reply
+    may carry openai-style content BLOCKS rather than a string. ``str()`` on a block list does not
+    fail -- it produces the python repr, and the model then reads a literal
+    ``[{'type': 'image_url', ...}]`` as its prompt text while every metric reports a healthy run.
+
+    a block the transcript cannot represent is refused outright instead. the media a rollout
+    conditions on is fixed from the initial prompt (see ``_EpisodePrompt``), so a mid-episode image
+    cannot reach the engine no matter what this returns; stringifying it would train on the repr of
+    a dropped image, and dropping it would train on a turn the environment never wrote. refusing is
+    the interim contract until per-turn media is threaded into the rollout, and it is LOUD -- the
+    bridge turns a raise into a 400 that fails the episode -- because silence is the actual defect.
+    """
+    content = message.get("content")
+    if isinstance(content, list):
+        # images get their own message ahead of the generic guard: it is the one unsupported block
+        # with an action attached, so saying which one it is beats naming the type alone.
+        if content_has_images(content):
+            raise _BadEnvReply(
+                "environment reply carries an image block; multi-turn GRPO conditions every turn on "
+                "the media from the INITIAL prompt, so an image returned by step_episode cannot "
+                "reach the model. return text, or put the image in the initial prompt"
+            )
+        _reject_unrepresentable_reply_blocks(content)
+        # text-only blocks are a shape this transcript CAN represent exactly, so flatten them
+        # through the same definition of "the text of a message" the graders and reward path use.
+        return {"role": str(message.get("role", "")), "content": message_content_text(content)}
+    # unchanged for every non-block reply, which is what every existing multi-turn env returns.
+    return {"role": str(message.get("role", "")), "content": str(message.get("content", ""))}
+
+
 # size the listen backlog for the full prompts_per_step * group_size connection burst.
 # socketserver's default of 5 resets overflowed clients, and bridge_post intentionally does not retry.
 # a fixed backlog only moves the cliff; linux may clamp this value to somaxconn.
@@ -263,12 +335,17 @@ class MultiTurnBridge:
                 return {"terminal": True, "messages": []}
             replies = self._env_call("env_reply", list(state.get("messages") or ()), state)
             terminal = bool(self._env_call("rollout_done", state, self._max_turns))
+        if terminal:
+            # nothing here is ever shown to the model: the child breaks on `terminal` BEFORE it
+            # reads `messages`. env_reply has already recorded these replies into the state that
+            # score_episodes reads, so the episode is scored on them either way. validating them
+            # for transcript representability would turn a completed episode whose env signed off
+            # with an image or a tool payload into a 400 with no reward -- refusing a turn the
+            # model was never going to see.
+            return {"terminal": True, "messages": []}
         return {
-            "terminal": terminal,
-            "messages": [
-                {"role": str(message.get("role", "")), "content": str(message.get("content", ""))}
-                for message in replies
-            ],
+            "terminal": False,
+            "messages": [_env_reply_message(message) for message in replies],
         }
 
     def _score_batch(self, requests: list) -> list:

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/engine/worker/train/rl/verl_config.py

@@ -17,6 +17,7 @@ from flash.engine.profiling.sft_workload import _multimodal_messages_with_images
 from flash.engine.worker.backend_common import (
     agent_loop_workers,
     ray_num_cpus,
+    rollout_mm_processor_cache_overrides,
     rollout_resident_overrides,
     rollout_sleep_unsupported,
     trainer_dtype_overrides,
@@ -332,6 +333,7 @@ def _rollout_overrides(cfg: dict) -> list[str]:
         ),
         # safetensors load format is required for lora rollout on vllm.
         "actor_rollout_ref.rollout.load_format=safetensors",
+        *rollout_mm_processor_cache_overrides(),
         # keep the rollout engine RESIDENT for models whose vLLM wake/reload HANGS (catalog
         # sleep_unsupported). shared with the opd driver, which runs the same verl sleep path.
         *rollout_resident_overrides(bool(cfg.get("sleep_unsupported"))),

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/engine/worker/verl/capabilities.py

@@ -758,6 +758,16 @@ def rollout_resident_overrides(sleep_unsupported: bool) -> list[str]:
     ]
 
 
+def rollout_mm_processor_cache_overrides() -> list[str]:
+    """disable vllm's split multimodal processor cache for every verl rollout.
+
+    verl sleep resets the engine-side receiver without resynchronizing the frontend sender, so a
+    repeated image can become a hash-only request for an item the receiver no longer holds. zero is
+    vllm's disable value for both halves and is inert when a rollout has no multimodal items.
+    """
+    return ["+actor_rollout_ref.rollout.engine_kwargs.vllm.mm_processor_cache_gb=0"]
+
+
 def trainer_dtype_overrides() -> list[str]:
     """verl overrides that store the frozen base in bf16 instead of verl's fp32 default.
 

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/flash/envs/adapter.py

@@ -665,13 +665,16 @@ class FreesoloEnvironment(BaseEnvironment):
         state["turn"] = int(state.get("turn", 0)) + 1
         if step.metadata:
             state.setdefault("step_metadata", []).append(step.metadata)
-        replies = [dict(message) for message in step.messages]
-        state.setdefault("messages", []).extend(replies)
-        for message in replies:
+        replies = [deepcopy(dict(message)) for message in step.messages]
+        scored_replies = deepcopy(replies)
+        state.setdefault("messages", []).extend(scored_replies)
+        for message in scored_replies:
+            # score_episode receives a structural copy of the environment's raw chat content. the
+            # parent bridge flattens only the separate child-bound reply returned below.
             state.setdefault("turns", []).append(
                 self._EnvironmentTurn(
                     role=str(message.get("role", "")),
-                    content=str(message.get("content", "")),
+                    content=deepcopy(message.get("content", "")),
                 )
             )
         return replies

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.2.60"
+version = "1.2.61"
 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).
@@ -137,7 +137,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.60"
+version = "1.2.61"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

freesolo_flash_dev-1.2.61/tests/test_catalog_only_models.py

@@ -0,0 +1,88 @@
+"""Only curated catalog models are trainable + VRAM estimator unit tests (CPU-only, no network).
+
+Adding a model means forking Flash and adding a ModelInfo entry to flash/core/catalog.py. There is no
+config key that accepts an uncataloged model: the rejection is catalog membership itself, so it
+holds identically on a managed and a self-hosted plane.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from flash.core.catalog import resolve_model
+from flash.engine.plan.vram import estimate_vram_gb
+from flash.providers.base import get_gpu_info
+from flash.schema import ConfigError, spec_from_dict
+from tests._helpers.specs import raw_spec as _raw
+
+
+def test_an_uncataloged_model_is_rejected_with_the_fork_instruction():
+    # The error is the primary documentation for the new workflow -- it is what every rejected
+    # user sees, so it must name the concrete next step, not just refuse.
+    with pytest.raises(ValueError, match="unsupported model") as ei:
+        resolve_model("some-org/some-model", "sft")
+    message = str(ei.value)
+    assert "fork" in message.lower()
+    assert "flash/core/catalog.py" in message
+
+
+def test_catalog_model_resolves_normally():
+    info = resolve_model("Qwen/Qwen3.5-4B", "grpo")
+    assert info.id == "Qwen/Qwen3.5-4B"
+
+
+def test_the_parser_rejects_an_uncataloged_model_before_submit():
+    # Rejecting client-side means a fork with a new catalog entry works without touching the
+    # plane, and a typo fails locally instead of after a network round trip.
+    with pytest.raises(ConfigError) as ei:
+        spec_from_dict(_raw(model="acme/unlisted"))
+    assert "unsupported model" in str(ei.value)
+
+
+def test_model_policy_is_no_longer_an_accepted_config_key():
+    # The key is gone, not merely ignored: a config carrying it must fail loudly rather than
+    # silently training something other than what it asked for.
+    with pytest.raises(ConfigError, match="unknown config key"):
+        spec_from_dict(_raw(model="Qwen/Qwen3.5-4B", model_policy="allow"))
+
+
+def test_a_catalog_spec_round_trips_without_a_policy_field():
+    spec = spec_from_dict(_raw(model="Qwen/Qwen3.5-4B"))
+    payload = spec.to_dict()
+    assert "model_policy" not in payload
+    assert spec_from_dict(payload).model == "Qwen/Qwen3.5-4B"
+
+
+# ---------------------------------------------------------------------------
+# Estimator sanity: calibrated against catalog anchors
+# ---------------------------------------------------------------------------
+def _headroom(params_b: float, algo: str, quant: str, gpu: str) -> str:
+    """The advisory fits/tight/too_big banding, applied straight to the sizing equations.
+
+    The bands below calibrate live sizing decisions directly against managed GPU capacities.
+    """
+    est = estimate_vram_gb(params_b, algo, quant)
+    gpu_gb = get_gpu_info(gpu).vram_gb
+    if est > gpu_gb * 1.15:
+        return "too_big"
+    return "tight" if est > gpu_gb * 0.85 else "fits"
+
+
+@pytest.mark.parametrize(
+    ("params_b", "algo", "quant", "gpu", "expected"),
+    [
+        (4.0, "grpo", "bf16", "RTX 5090", "fits"),  # Qwen3-4B colocate on 32 GB (measured)
+        (4.0, "sft", "bf16", "RTX 4090", "fits"),
+        (9.65, "sft", "bf16", "RTX 5090", "tight"),  # Qwen3.5-9B SFT real logits peak
+        (36.0, "sft", "bf16", "RTX 5090", "too_big"),  # 72 GB of weights
+        (36.0, "grpo", "bf16", "RTX 5090", "too_big"),  # 2 bf16 copies + KV >> 32 GB
+    ],
+)
+def test_estimator_anchors(params_b, algo, quant, gpu, expected):
+    # params_b is supplied directly, so this calibrates the SIZING EQUATIONS against known anchors
+    # and never resolves the id through the catalog.
+    assert _headroom(params_b, algo, quant, gpu) == expected
+
+
+def test_grpo_needs_more_than_sft():
+    assert estimate_vram_gb(4.0, "grpo") > estimate_vram_gb(4.0, "sft")

{freesolo_flash_dev-1.2.60 → freesolo_flash_dev-1.2.61}/tests/test_opd_train.py

@@ -21,7 +21,7 @@ from types import SimpleNamespace
 
 import pytest
 
-from flash.engine.worker import opd_train, rl_train, score_batcher
+from flash.engine.worker import backend_common, opd_train, rl_train, score_batcher
 from flash.engine.worker.opd_train import (
     _OPD_PARQUET_WRITE_BATCH_ROWS,
     _BridgePrompt,
@@ -6064,27 +6064,9 @@ def test_opd_pins_the_blackwell_attention_backends_like_grpo_does():
     ), on
 
 
-def test_opd_disables_the_vllm_multimodal_processor_cache():
-    """Image OPD does not run without this, and the failure it produces names neither images nor
-    the cache.
-
-    vLLM splits the mm processor cache across two processes: the frontend SENDER replaces an image
-    it has seen before with just its hash, and the engine-core RECEIVER is supposed to still hold
-    the item. OPD's rollout lifecycle clears the receiver on every sleep/pause without clearing the
-    sender, so the sender keeps sending hashes for items the receiver dropped and each request dies
-    on `assert mm_item is not None`. That kills requests, not the run, so what surfaces is empty
-    rollouts and then an IndexError on a zero-length reward tensor.
-
-    Asserted on the parsed VALUE rather than substring presence, because the two ways this
-    regresses are both silent: a nonzero size re-enables the cache, and the pre-0.13 flag name is
-    rejected by vLLM's arg parser at startup, long after the GPU is paid for.
-    """
-    emitted = build_opd_overrides(_config())
-    overrides = dict(value.split("=", 1) for value in emitted)
-    assert overrides["+actor_rollout_ref.rollout.engine_kwargs.vllm.mm_processor_cache_gb"] == "0"
-    # `disable_mm_preprocessor_cache` was REMOVED in vllm 0.13.0. it reads like the right knob and
-    # still appears in older verl examples, so pin it out rather than trusting review to catch it.
-    assert not any("disable_mm_preprocessor_cache" in override for override in emitted)
+def test_opd_unconditionally_disables_the_vllm_multimodal_processor_cache():
+    overrides = build_opd_overrides(_config())
+    assert set(backend_common.rollout_mm_processor_cache_overrides()) <= set(overrides)
 
 
 def test_both_ray_rollouts_pin_blackwell_attention_from_the_same_resolver():