verifiers 0.1.15.dev0__tar.gz → 0.1.15.dev1__tar.gz

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 William Brown
+Copyright (c) 2026 Prime Intellect
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+SOFTWARE.

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev0
+Version: 0.1.15.dev1
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers
@@ -54,7 +54,7 @@ Requires-Dist: stagehand>=3.0.0; extra == 'browser'
 Provides-Extra: openenv
 Requires-Dist: openenv-core[core]==0.2.1; extra == 'openenv'
 Provides-Extra: renderers
-Requires-Dist: renderers>=0.1.6; extra == 'renderers'
+Requires-Dist: renderers>=0.1.8.dev0; extra == 'renderers'
 Provides-Extra: rg
 Requires-Dist: reasoning-gym; extra == 'rg'
 Provides-Extra: rl

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/pyproject.toml

@@ -73,7 +73,7 @@ dev = [
     "aiohttp>=3.9.0",
     "python-dotenv>=1.0.0",
     "nltk",
-    "renderers>=0.1.6",
+    "renderers>=0.1.8.dev0",
 ]
 
 [project.optional-dependencies]
@@ -93,7 +93,7 @@ browser = [
     "python-dotenv>=1.0.0",
 ]
 renderers = [
-    "renderers>=0.1.6",
+    "renderers>=0.1.8.dev0",
 ]
 rl = [
     "torch>=2.8.0,<2.9.0",
@@ -124,12 +124,6 @@ prime-tunnel = false
 prime-sandboxes = false
 renderers = false
 
-[tool.uv.sources]
-# Pinned to renderers main until the next PyPI release lands; drop after.
-# fe67f9f = renderers main: PR #4 squash-merge — construction-time
-# preserve_*_thinking flags on create_renderer / create_renderer_pool.
-renderers = { git = "https://github.com/PrimeIntellect-ai/renderers.git", rev = "fe67f9f" }
-
 [tool.uv.extra-build-dependencies]
 flash-attn = [{ requirement = "torch", match-runtime = true }]
 

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/tests/test_renderer_client.py

@@ -5,7 +5,7 @@ import pytest
 
 import verifiers as vf
 from renderers import RendererPool
-from renderers.base import ParsedResponse, create_renderer
+from renderers.base import ParsedResponse, RenderedTokens, create_renderer
 from verifiers.clients.renderer_client import (
     RendererClient,
     _attach_tool_call_names,
@@ -280,11 +280,13 @@ class _BridgeRenderer:
             stop_idx = len(self.bridge_base) - 1
         trailing = list(self.bridge_base[stop_idx + 1 :])
         extension = list(self.bridge_full[len(self.bridge_base) :])
-        return (
-            list(previous_prompt_ids)
-            + list(previous_completion_ids)
-            + trailing
-            + extension
+        return RenderedTokens(
+            token_ids=(
+                list(previous_prompt_ids)
+                + list(previous_completion_ids)
+                + trailing
+                + extension
+            )
         )
 
     def parse_response(self, token_ids):
@@ -345,7 +347,8 @@ async def test_get_incremental_prompt_ids_matches_tool_tail_without_rerendering_
         renderer=renderer, prompt=prompt, state=state, tools=None
     )
 
-    assert result == [1, 2, 3, 99, 30, 40]
+    assert result is not None
+    assert result.token_ids == [1, 2, 3, 99, 30, 40]
     # The bridge stitches over the completion without re-rendering it —
     # one bridge call, zero render_ids calls (older diff-based bridges
     # called render_ids twice).
@@ -387,7 +390,8 @@ async def test_get_incremental_prompt_ids_accepts_tool_then_user_tail():
         renderer=renderer, prompt=prompt, state=state, tools=None
     )
 
-    assert result == [1, 2, 3, 99, 40, 50]
+    assert result is not None
+    assert result.token_ids == [1, 2, 3, 99, 40, 50]
 
 
 @pytest.mark.asyncio
@@ -446,7 +450,8 @@ async def test_get_incremental_prompt_ids_accepts_multimodal_tool_user_tail():
         renderer=renderer, prompt=prompt, state=state, tools=None
     )
 
-    assert result == [1, 2, 3, 99, 40, 50]
+    assert result is not None
+    assert result.token_ids == [1, 2, 3, 99, 40, 50]
 
 
 # ── Parity across real renderers: truncated most-recent step ──────────
@@ -478,7 +483,7 @@ _TRUNCATED_ANCHOR_MODELS = [
         "auto",
         id="nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16",
     ),
-    pytest.param("openai/gpt-oss-20b", "gpt_oss", id="openai/gpt-oss-20b"),
+    pytest.param("openai/gpt-oss-20b", "gpt-oss", id="openai/gpt-oss-20b"),
 ]
 
 
@@ -552,11 +557,12 @@ async def test_get_incremental_prompt_ids_bridges_over_truncated_step(
 
     prefix = list(prev_prompt_ids) + list(prev_completion_ids)
     assert result is not None, f"{model_id}: bridge returned None on truncated anchor"
-    assert result[: len(prefix)] == prefix, (
+    result_ids = result.token_ids
+    assert result_ids[: len(prefix)] == prefix, (
         f"{model_id}: bridge result does not prefix-preserve "
         f"prev_prompt + prev_completion"
     )
-    assert len(result) > len(prefix), (
+    assert len(result_ids) > len(prefix), (
         f"{model_id}: bridge produced no tail tokens for the new user turn"
     )
 

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/tests/test_save_utils.py

@@ -27,6 +27,7 @@ from verifiers.utils.metric_utils import (
 )
 from verifiers.utils.save_utils import (
     GenerateOutputsBuilder,
+    _delta_intermediate_mm_data,
     extract_usage_tokens,
     load_outputs,
     make_serializable,
@@ -897,3 +898,257 @@ class TestPassAtKMetric:
         )
         pass_at_k, _ = m.compute()
         assert pass_at_k["1"] == pytest.approx(0.5)
+
+
+class TestDeltaIntermediateMmData:
+    """Verify per-step delta encoding of trajectory mm_data sidecars.
+
+    Renderer bridge_to_next_turn emits cumulative mm_data on every
+    step. The transport-layer delta strips items whose mm_hash already
+    appeared in the prior step, so the per-window TrainingSample
+    assembler can recover its window's images by unioning step-deltas.
+    """
+
+    @staticmethod
+    def _mm(*hashes: str):
+        """Build a renderers.MultiModalData with one image item per hash."""
+        from renderers.base import MultiModalData, PlaceholderRange
+
+        return MultiModalData(
+            mm_hashes={"image": list(hashes)},
+            mm_placeholders={
+                "image": [
+                    PlaceholderRange(offset=i * 10, length=4)
+                    for i in range(len(hashes))
+                ]
+            },
+            mm_items={"image": [{"pixel_values": f"px-{h}"} for h in hashes]},
+        )
+
+    def _step(self, mm):
+        return {"tokens": {"multi_modal_data": mm}}
+
+    def test_none_and_single_step_passthrough(self):
+        assert _delta_intermediate_mm_data(None) is None
+        assert _delta_intermediate_mm_data([]) == []
+        only = [self._step(self._mm("A"))]
+        assert _delta_intermediate_mm_data(only) is only
+
+    def test_linear_extension_keeps_only_new_items_per_step(self):
+        traj = [
+            self._step(self._mm("A")),
+            self._step(self._mm("A", "B")),
+            self._step(self._mm("A", "B", "C")),
+        ]
+        out = _delta_intermediate_mm_data(traj)
+
+        assert out[0]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["A"]}
+        assert out[1]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["B"]}
+        assert out[2]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["C"]}
+        # Items and placeholders are reindexed in lockstep with hashes.
+        assert out[1]["tokens"]["multi_modal_data"].mm_items["image"] == [
+            {"pixel_values": "px-B"}
+        ]
+        assert (
+            out[2]["tokens"]["multi_modal_data"].mm_placeholders["image"][0].offset
+            == 20
+        )
+
+    def test_compaction_two_training_samples_assemble_correctly(self):
+        """Rollout with one compaction event → two TrainingSamples.
+
+        Models the prime-rl compaction flow: a single rollout produces
+        multiple ``TrainingSample`` objects, one per compaction window.
+        The pre-compaction sample's images are no longer in the
+        post-compaction step's cumulative ``mm_data`` — the previous
+        "keep last" strategy would have silently dropped them. With
+        delta encoding, each per-window assembler recovers exactly the
+        images its tokens reference: no leakage in either direction.
+        """
+        from renderers.base import MultiModalData, PlaceholderRange
+
+        def step(*hashes: str, offsets: list[int]):
+            return {
+                "tokens": {
+                    "multi_modal_data": MultiModalData(
+                        mm_hashes={"image": list(hashes)},
+                        mm_placeholders={
+                            "image": [
+                                PlaceholderRange(offset=o, length=4) for o in offsets
+                            ]
+                        },
+                        mm_items={
+                            "image": [{"pixel_values": f"px-{h}"} for h in hashes]
+                        },
+                    )
+                }
+            }
+
+        # Turn 1: image A. Cumulative {A}.
+        # Turn 2: image B. Cumulative {A, B}.
+        # ── compaction event: turns 1+2 summarized in text, images dropped ──
+        # Turn 3: image C. Cumulative {C} (offsets reset against the
+        #         post-compaction prompt).
+        # Turn 4: image D. Cumulative {C, D}.
+        traj = [
+            step("A", offsets=[10]),
+            step("A", "B", offsets=[10, 50]),
+            step("C", offsets=[8]),
+            step("C", "D", offsets=[8, 40]),
+        ]
+        out = _delta_intermediate_mm_data(traj)
+
+        # Per-step deltas keep only what's new since the immediately prior step.
+        deltas = [s["tokens"]["multi_modal_data"].mm_hashes for s in out]
+        assert deltas == [
+            {"image": ["A"]},
+            {"image": ["B"]},
+            {"image": ["C"]},
+            {"image": ["D"]},
+        ]
+
+        def assemble(steps):
+            hashes: list[str] = []
+            items: list[dict] = []
+            placeholders: list[PlaceholderRange] = []
+            for s in steps:
+                mm = s["tokens"]["multi_modal_data"]
+                hashes += mm.mm_hashes.get("image", [])
+                items += mm.mm_items.get("image", [])
+                placeholders += mm.mm_placeholders.get("image", [])
+            return hashes, items, placeholders
+
+        ts1_hashes, ts1_items, ts1_phs = assemble(out[0:2])  # pre-compaction
+        ts2_hashes, ts2_items, ts2_phs = assemble(out[2:4])  # post-compaction
+
+        assert ts1_hashes == ["A", "B"]
+        assert ts2_hashes == ["C", "D"]
+        # The invariant the previous "keep last" broke: pre-compaction TS
+        # does not see post-compaction images, and vice versa.
+        assert set(ts1_hashes).isdisjoint(set(ts2_hashes))
+
+        # Items / placeholders are reindexed lock-step with hashes (no
+        # off-by-one or cross-contamination during reindex).
+        assert ts1_items == [{"pixel_values": "px-A"}, {"pixel_values": "px-B"}]
+        assert ts2_items == [{"pixel_values": "px-C"}, {"pixel_values": "px-D"}]
+
+        # Placeholder offsets travel verbatim per step; the assembler is
+        # responsible for shifting them into each window's local frame.
+        assert [p.offset for p in ts1_phs] == [10, 50]
+        assert [p.offset for p in ts2_phs] == [8, 40]
+
+    def test_same_image_rendered_in_two_turns_uses_multiset_diff(self):
+        """Same image hash appearing N times must keep the right N-prior occurrences.
+
+        The renderer doesn't dedupe by hash: ``emit_image`` appends to
+        the parallel lists every time an image content part is rendered.
+        So if image A is shown in turn 1 *and* turn 3, the cumulative
+        ``mm_hashes`` is ``["A", "A"]`` with two distinct placeholder
+        offsets, and ``mm_items`` is ``[pixA, pixA]`` (literally the
+        same payload twice). Both placeholder runs need their own item
+        — set-based diff would drop both as "already seen" and orphan
+        the second placeholder. Multiset diff drops only the first.
+        """
+        from renderers.base import MultiModalData, PlaceholderRange
+
+        def step(hashes, offsets):
+            return {
+                "tokens": {
+                    "multi_modal_data": MultiModalData(
+                        mm_hashes={"image": list(hashes)},
+                        mm_placeholders={
+                            "image": [
+                                PlaceholderRange(offset=o, length=4) for o in offsets
+                            ]
+                        },
+                        mm_items={
+                            "image": [{"pixel_values": f"px-{h}"} for h in hashes]
+                        },
+                    )
+                }
+            }
+
+        # Turn 1: image A at offset 10. Cumulative ["A"].
+        # Turn 2: no image. Cumulative unchanged ["A"].
+        # Turn 3: image A re-rendered at offset 200. Cumulative ["A", "A"].
+        traj = [
+            step(["A"], offsets=[10]),
+            step(["A"], offsets=[10]),
+            step(["A", "A"], offsets=[10, 200]),
+        ]
+        out = _delta_intermediate_mm_data(traj)
+
+        # Step 0 keeps everything (no prior).
+        assert out[0]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["A"]}
+        assert [
+            p.offset
+            for p in out[0]["tokens"]["multi_modal_data"].mm_placeholders["image"]
+        ] == [10]
+
+        # Step 1 introduced no new image (cumulative unchanged).
+        assert out[1]["tokens"]["multi_modal_data"].mm_hashes == {"image": []}
+
+        # Step 2: prior was ["A"], current is ["A", "A"]. Multiset budget
+        # consumes the first A; the *second* A (the new one at offset
+        # 200) survives the diff with its pixel_values intact. Set-based
+        # diff would have produced [].
+        step2_mm = out[2]["tokens"]["multi_modal_data"]
+        assert step2_mm.mm_hashes == {"image": ["A"]}
+        assert step2_mm.mm_items == {"image": [{"pixel_values": "px-A"}]}
+        assert [p.offset for p in step2_mm.mm_placeholders["image"]] == [200]
+
+        # End-to-end: assembling the single TrainingSample (no
+        # compaction) recovers both placeholder runs with matching
+        # pixel_values, so the trainer can satisfy both image-pad
+        # token runs in the prompt.
+        all_hashes: list[str] = []
+        all_phs: list[PlaceholderRange] = []
+        for s in out:
+            mm = s["tokens"]["multi_modal_data"]
+            all_hashes += mm.mm_hashes.get("image", [])
+            all_phs += mm.mm_placeholders.get("image", [])
+        assert all_hashes == ["A", "A"]
+        assert [p.offset for p in all_phs] == [10, 200]
+
+    def test_image_reintroduction_after_compaction(self):
+        """A hash dropped at compaction and re-rendered later is re-transmitted.
+
+        The delta is computed against the *immediately prior step's*
+        cumulative, not a global seen-set. If image A appears in turn
+        1, is compacted away (step 2's cumulative is empty), and is
+        re-rendered in turn 3, A shows up in step 0's delta *and* step
+        2's delta — necessary so the post-compaction TrainingSample
+        also receives A's bytes.
+        """
+        traj = [
+            self._step(self._mm("A")),
+            self._step(self._mm()),
+            self._step(self._mm("A")),
+        ]
+        out = _delta_intermediate_mm_data(traj)
+
+        assert out[0]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["A"]}
+        assert out[1]["tokens"]["multi_modal_data"].mm_hashes == {"image": []}
+        # A re-emerges in step 2's delta — its absence from step 1's
+        # cumulative means it counts as "new" again.
+        assert out[2]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["A"]}
+
+    def test_steps_with_no_new_items_collapse_to_empty_delta(self):
+        # Step 2's cumulative equals step 1's — no new items.
+        traj = [
+            self._step(self._mm("A", "B")),
+            self._step(self._mm("A", "B")),
+            self._step(self._mm("A", "B", "C")),
+        ]
+        out = _delta_intermediate_mm_data(traj)
+
+        assert out[1]["tokens"]["multi_modal_data"].mm_hashes == {"image": []}
+        assert out[1]["tokens"]["multi_modal_data"].mm_items == {"image": []}
+        assert out[2]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["C"]}
+
+    def test_non_mapping_steps_pass_through(self):
+        traj = [self._step(self._mm("A")), "not-a-dict", self._step(self._mm("A", "B"))]
+        out = _delta_intermediate_mm_data(traj)
+        assert out[1] == "not-a-dict"
+        # Delta of step 2 still computed against step 0 (last seen cumulative).
+        assert out[2]["tokens"]["multi_modal_data"].mm_hashes == {"image": ["B"]}

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/verifiers/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.15.dev0"
+__version__ = "0.1.15.dev1"
 
 import importlib
 import os

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/verifiers/clients/anthropic_messages_client.py

@@ -50,6 +50,13 @@ from verifiers.types import (
 from verifiers.utils.client_utils import setup_anthropic_client
 
 
+ANTHROPIC_ADAPTIVE_THINKING_MODELS = {
+    "claude-opus-4-7",
+    "claude-opus-4-6",
+    "claude-sonnet-4-6",
+}
+
+
 def _handle_anthropic_overlong_prompt(func):
     """Decorator to handle overlong prompt errors from the Anthropic API."""
 
@@ -342,6 +349,20 @@ class AnthropicMessagesClient(
     ) -> AnthropicMessage:
         def normalize_sampling_args(sampling_args: SamplingArgs) -> dict:
             sampling_args = dict(sampling_args)
+            reasoning_effort = sampling_args.pop("reasoning_effort", None)
+            if reasoning_effort is not None:
+                model_id = (
+                    model.lower().split("/")[-1].replace(".", "-").replace("_", "-")
+                )
+                output_config = dict(sampling_args.get("output_config") or {})
+                output_config["effort"] = reasoning_effort
+                sampling_args["output_config"] = output_config
+                if "thinking" not in sampling_args and any(
+                    model_id == adaptive_model
+                    or model_id.startswith(f"{adaptive_model}-")
+                    for adaptive_model in ANTHROPIC_ADAPTIVE_THINKING_MODELS
+                ):
+                    sampling_args["thinking"] = {"type": "adaptive"}
             max_tokens = sampling_args.pop("max_tokens", None)
             sampling_args.pop("n", None)
             sampling_args.pop("stop", None)

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/verifiers/clients/openai_chat_completions_client.py

@@ -252,6 +252,31 @@ class OpenAIChatCompletionsClient(
     ) -> OpenAIChatResponse:
         def normalize_sampling_args(sampling_args: SamplingArgs):
             sampling_args = dict(sampling_args)
+            api_base_url = None
+            if hasattr(self.client, "base_url"):
+                api_base_url = str(self.client.base_url)
+            elif self._config is not None:
+                api_base_url = self._config.api_base_url
+            reasoning_effort = sampling_args.pop("reasoning_effort", None)
+            model_id = model.lower().split("/")[-1].replace(".", "-").replace("_", "-")
+            is_anthropic_route = (
+                "openrouter.ai" in (api_base_url or "").lower()
+                or "pinference.ai" in (api_base_url or "").lower()
+            )
+            if (
+                reasoning_effort is not None
+                and model_id.startswith("claude-")
+                and is_anthropic_route
+            ):
+                # OpenRouter/Pinference route Anthropic reasoning_effort through extra_body.
+                extra_body = dict(sampling_args.get("extra_body") or {})
+                extra_body["verbosity"] = reasoning_effort
+                reasoning = dict(extra_body.get("reasoning") or {})
+                reasoning.setdefault("enabled", True)
+                extra_body["reasoning"] = reasoning
+                sampling_args["extra_body"] = extra_body
+            elif reasoning_effort is not None:
+                sampling_args["reasoning_effort"] = reasoning_effort
             if "max_tokens" in sampling_args:
                 sampling_args["max_completion_tokens"] = sampling_args.pop("max_tokens")
             return {k: v for k, v in sampling_args.items() if v is not None}

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/verifiers/clients/renderer_client.py

@@ -20,10 +20,13 @@ from openai import AsyncOpenAI
 
 from renderers import Message as RendererMessage
 from renderers import (
+    MultimodalRenderer,
+    RenderedTokens,
     Renderer,
     RendererPool,
     ToolSpec,
     create_renderer_pool,
+    is_multimodal,
 )
 from renderers import ToolCall as RendererToolCall
 from renderers import ToolCallFunction
@@ -94,15 +97,15 @@ _DEFAULT_POOL_SIZE = 1
 # ── Helpers ─────────────────────────────────────────────────────────
 
 
-async def _run_with_renderer(renderer: Renderer | RendererPool, fn):
-    if isinstance(renderer, RendererPool):
-
-        def _work():
-            with renderer.checkout() as r:
-                return fn(r)
+async def _maybe_offload(renderer: Renderer | RendererPool, fn):
+    """Run sync renderer work on a thread iff ``renderer`` is a pool.
 
-        return await asyncio.to_thread(_work)
-    return fn(renderer)
+    Pool methods can block on the internal queue/lock; we offload to keep
+    the event loop responsive. A bare ``Renderer`` runs inline.
+    """
+    if isinstance(renderer, RendererPool):
+        return await asyncio.to_thread(fn)
+    return fn()
 
 
 def _get_value(obj: Any, key: str, default: Any = None) -> Any:
@@ -295,6 +298,28 @@ def _step_token_ids(step: Any) -> tuple[list[int], list[int]] | None:
     return list(prompt_ids), list(completion_ids)
 
 
+def _step_multi_modal_data(step: Any):
+    """Recover the previous turn's ``MultiModalData`` for bridging.
+
+    Mirrors :func:`_step_token_ids`: prefer ``step.tokens.multi_modal_data``
+    (post-parse_response_tokens), fall back to ``step.response.message.tokens``.
+    Returns ``None`` when no multimodal sidecar was emitted (text-only
+    rollouts) — the bridge handles that branch transparently.
+    """
+    tokens = _get_value(step, "tokens")
+    if tokens is not None:
+        mm = _get_value(tokens, "multi_modal_data")
+        if mm is not None:
+            return mm
+
+    response = _get_value(step, "response")
+    message = _get_value(response, "message")
+    raw_tokens = _get_value(message, "tokens")
+    if raw_tokens is None:
+        return None
+    return _get_value(raw_tokens, "multi_modal_data")
+
+
 def _step_rendered_messages(step: Any) -> list[RendererMessage]:
     prompt = list(_get_value(step, "prompt", []) or [])
     completion = list(_get_value(step, "completion", []) or [])
@@ -309,7 +334,13 @@ async def _get_incremental_prompt_ids(
     prompt: list[RendererMessage],
     state: Any,
     tools: list[ToolSpec] | None,
-) -> list[int] | None:
+) -> "RenderedTokens | None":
+    """Return the bridged prompt for the next turn as ``RenderedTokens``.
+
+    Returns ``None`` when no prior trajectory step lines up with the new
+    prompt's prefix or the renderer's ``bridge_to_next_turn`` can't extend
+    — both cases fall back to a full re-render in :func:`generate`.
+    """
     if not state:
         return None
 
@@ -342,15 +373,32 @@ async def _get_incremental_prompt_ids(
             continue
 
         previous_prompt_ids, previous_completion_ids = token_ids
-        bridged = await _run_with_renderer(
-            renderer,
-            lambda r: r.bridge_to_next_turn(
+        previous_mm_data = _step_multi_modal_data(step)
+        # Multimodal renderers' bridge accepts ``previous_multi_modal_data``
+        # so earlier-turn images carry forward into the new prompt's
+        # ``mm_placeholders``. Without that carry-forward, vLLM sees
+        # placeholder counts that don't match the combined token sequence
+        # and silently falls back to hash-cache lookup (or errors).
+        # Text-only renderers' bridge signature doesn't include that
+        # kwarg. ``is_multimodal`` is type-cached so this dispatch is a
+        # dict lookup, not a runtime_checkable Protocol walk.
+        if is_multimodal(renderer):
+            mm_renderer = cast(MultimodalRenderer, renderer)
+            bridge = lambda: mm_renderer.bridge_to_next_turn(  # noqa: E731
                 previous_prompt_ids,
                 previous_completion_ids,
                 tail,
                 tools=tools,
-            ),
-        )
+                previous_multi_modal_data=previous_mm_data,
+            )
+        else:
+            bridge = lambda: renderer.bridge_to_next_turn(  # noqa: E731
+                previous_prompt_ids,
+                previous_completion_ids,
+                tail,
+                tools=tools,
+            )
+        bridged = await _maybe_offload(renderer, bridge)
         _record_bridge(success=bridged is not None)
         return bridged
 
@@ -514,12 +562,21 @@ class RendererClient(
         if args.get("prompt_logprobs"):
             sampling_params["prompt_logprobs"] = 1
 
-        prompt_ids = await _get_incremental_prompt_ids(
+        bridged = await _get_incremental_prompt_ids(
             renderer=renderer,
             prompt=prompt,
             state=kwargs.get("state"),
             tools=tools,
         )
+        # ``bridged`` is RenderedTokens | None. Unpack token_ids + mm_data
+        # so multimodal renderers thread per-image features through to
+        # /inference/v1/generate without re-rendering the whole turn.
+        if bridged is not None:
+            prompt_ids = bridged.token_ids
+            multi_modal_data = bridged.multi_modal_data
+        else:
+            prompt_ids = None
+            multi_modal_data = None
 
         return await generate(
             client=self.client,
@@ -527,6 +584,7 @@ class RendererClient(
             messages=prompt,
             model=model,
             prompt_ids=prompt_ids,
+            multi_modal_data=multi_modal_data,
             tools=tools,
             sampling_params=sampling_params,
             cache_salt=args.get("cache_salt")
@@ -580,6 +638,7 @@ class RendererClient(
             completion_mask=[1] * len(completion_ids),
             completion_logprobs=completion_logprobs,
             routed_experts=response.get("routed_experts"),
+            multi_modal_data=response.get("multi_modal_data"),
         )
 
         # /inference/v1/generate doesn't return usage; reconstruct from tokens.

{verifiers-0.1.15.dev0 → verifiers-0.1.15.dev1}/verifiers/serve/client/zmq_env_client.py

@@ -30,7 +30,7 @@ from verifiers.serve.types import (
 class ZMQEnvClient(EnvClient):
     """ZMQ-based environment client."""
 
-    DEFAULT_REQUEST_TIMEOUT = 36_000  # 10h
+    DEFAULT_REQUEST_TIMEOUT: float | None = None
 
     def __init__(self, address: str = "tcp://127.0.0.1:5000", **kwargs):
         super().__init__(address=address, **kwargs)