renderers 0.1.12.dev7__tar.gz → 0.1.12.dev9__tar.gz

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: renderers
-Version: 0.1.12.dev7
+Version: 0.1.12.dev9
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.12.dev7'
-__version_tuple__ = version_tuple = (0, 1, 12, 'dev7')
+__version__ = version = '0.1.12.dev9'
+__version_tuple__ = version_tuple = (0, 1, 12, 'dev9')
 
 __commit_id__ = commit_id = None

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/renderers/base.py

@@ -1017,6 +1017,7 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     # Nemotron 3.5 (Lightning). Its template is the Ultra variant's minus the
     # effort kwarg (``nemotron-3.5``).
     "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16": "nemotron-3.5",
+    "nvidia/NVIDIA-Nemotron-3.5-Super-EA-09112026": "nemotron-3.5",
     # Llama 3.2 (Instruct). Tested against the gated meta-llama repos and
     # the unrestricted unsloth/... mirror, which ships a byte-identical
     # chat template. ``Llama3Renderer`` defaults ``date_string`` to
@@ -1057,6 +1058,7 @@ MODEL_RENDERER_MAP: dict[str, str] = {
 # Modality values: ``"image"``, ``"video"``, ``"audio"``. Text is implicit
 # (every model supports it), so it doesn't appear in the set.
 MULTIMODAL_MODELS: dict[str, set[str]] = {
+    "nvidia/NVIDIA-Nemotron-3.5-Super-EA-09112026": {"image"},
     "Qwen/Qwen3-VL-4B-Instruct": {"image"},
     "Qwen/Qwen3-VL-8B-Instruct": {"image"},
     "Qwen/Qwen3-VL-30B-A3B-Instruct": {"image"},

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/renderers/client.py

@@ -486,6 +486,7 @@ def _build_mm_features(
     to change. Don't pre-build the abstraction with one engine in tree.
     """
     from renderers.gemma4 import Gemma4Renderer
+    from renderers.nemotron3 import Nemotron35Renderer
     from renderers.qwen3_vl import Qwen3VLRenderer
     from renderers.qwen35 import Qwen35Renderer
 
@@ -498,6 +499,8 @@ def _build_mm_features(
         return _build_qwen_vl_features(mm_data, spatial_merge_size=2)
     if issubclass(renderer_cls, Gemma4Renderer):
         return _build_gemma4_features(mm_data)
+    if issubclass(renderer_cls, Nemotron35Renderer):
+        return _build_nemotron35_features(mm_data)
 
     raise NotImplementedError(
         f"Multimodal serialization not implemented for {renderer_cls.__name__}. "
@@ -505,6 +508,79 @@ def _build_mm_features(
     )
 
 
+def _build_nemotron35_features(mm_data: MultiModalData) -> dict[str, Any]:
+    """Encode dynamic-resolution Nemotron image inputs for vLLM."""
+    _require_transformers("Encoding Nemotron 3.5 multimodal features for vLLM")
+    try:
+        import torch
+        from transformers.feature_extraction_utils import BatchFeature
+        from vllm.entrypoints.scale_out.token_in_token_out.mm_serde import (
+            encode_mm_kwargs_item,
+        )
+        from vllm.multimodal.inputs import (
+            MultiModalFieldConfig,
+            MultiModalKwargsItems,
+        )
+    except ImportError as exc:
+        raise RuntimeError(
+            "Nemotron 3.5 multimodal generate requires vLLM and torch."
+        ) from exc
+
+    out: dict[str, Any] = {
+        "mm_hashes": {},
+        "mm_placeholders": {},
+        "kwargs_data": {},
+    }
+    image_items = mm_data.mm_items.get("image") or []
+    if image_items:
+        pixel_values_flat = []
+        imgs_sizes = []
+        num_tokens_per_image = []
+        for item in image_items:
+            pixel_values = torch.as_tensor(item["pixel_values"])
+            if pixel_values.ndim != 4 or pixel_values.shape[0] != 1:
+                raise ValueError(
+                    "Each Nemotron pixel_values item must have shape (1, C, H, W)."
+                )
+            sizes = item["imgs_sizes"]
+            token_counts = item["num_tokens"]
+            if not (len(sizes) == len(token_counts) == 1):
+                raise ValueError(
+                    "Each Nemotron image item must contain one size and token count."
+                )
+            pixel_values_flat.append(pixel_values[0])
+            imgs_sizes.append(tuple(int(value) for value in sizes[0]))
+            num_tokens_per_image.append(int(token_counts[0]))
+
+        hf_inputs = BatchFeature(
+            data={
+                "pixel_values_flat": pixel_values_flat,
+                "imgs_sizes": imgs_sizes,
+                "num_tokens_per_image": num_tokens_per_image,
+            }
+        )
+        field_config = {
+            "pixel_values_flat": MultiModalFieldConfig.batched("image"),
+            "num_tokens_per_image": MultiModalFieldConfig.batched(
+                "image", keep_on_cpu=True
+            ),
+            "imgs_sizes": MultiModalFieldConfig.batched("image", keep_on_cpu=True),
+        }
+        kwargs_items = MultiModalKwargsItems.from_hf_inputs(hf_inputs, field_config)
+        out["kwargs_data"]["image"] = [
+            encode_mm_kwargs_item(item) for item in kwargs_items["image"]
+        ]
+        out["mm_hashes"]["image"] = list(mm_data.mm_hashes.get("image") or [])
+        out["mm_placeholders"]["image"] = [
+            {"offset": placeholder.offset, "length": placeholder.length}
+            for placeholder in mm_data.mm_placeholders.get("image") or []
+        ]
+
+    if not any(out["kwargs_data"].values()):
+        out["kwargs_data"] = None
+    return out
+
+
 def _build_gemma4_features(mm_data: MultiModalData) -> dict[str, Any]:
     """vLLM features payload for Gemma 4 image inputs.
 

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/renderers/nemotron3.py

@@ -14,18 +14,23 @@ Nemotron 3 uses the same <|im_start|>/<|im_end|> format as Qwen3.5 but differs i
 
 from __future__ import annotations
 
+from dataclasses import replace
 import json
+from pathlib import Path
 from typing import Any
 
 from renderers.reasoning import scan_reasoning, prompt_ends_in_reasoning
 
 from renderers.base import (
     Message,
+    MultiModalData,
     ParsedResponse,
+    PlaceholderRange,
     RenderedTokens,
     ToolSpec,
     Tokenizer,
     _content_mask_or_empty,
+    _require_transformers,
     attribute_text_segments,
     extract_message_tool_names,
     reject_assistant_in_extension,
@@ -39,6 +44,7 @@ from renderers.configs import (
     Nemotron35RendererConfig,
 )
 from renderers.parsing import parse_qwen35
+from renderers.qwen3_vl import _image_hash, _is_image_part, _load_pil_image
 
 # ---------------------------------------------------------------------------
 # Tool system prompt constants
@@ -894,3 +900,249 @@ class Nemotron35Renderer(Nemotron3Renderer):
 
     _config_cls = Nemotron35RendererConfig
     _ultra = True
+    supports_process_multimodal = True
+    supports_multimodal_bridge = False
+
+    _processor_model_prefix = "nvidia/NVIDIA-Nemotron-3.5"
+
+    def __init__(
+        self,
+        tokenizer: Tokenizer,
+        config: Nemotron35RendererConfig | None = None,
+        *,
+        processor: Any = None,
+    ):
+        super().__init__(tokenizer, config)
+        self._processor = processor
+        self._image = self._token_id("<image>", optional=True)
+
+    @property
+    def mm_token_type_id_map(self) -> dict[int, int]:
+        return {self._image: 1} if self._image is not None else {}
+
+    def _image_token_id(self) -> int:
+        if self._image is None:
+            raise RuntimeError("This Nemotron 3.5 tokenizer has no <image> token.")
+        return self._image
+
+    def _get_processor(self):
+        if self._processor is not None:
+            return self._processor
+        name = getattr(self._tokenizer, "name_or_path", None)
+        if not name:
+            raise RuntimeError(
+                "Nemotron35Renderer needs a processor for image content."
+            )
+        if Path(name).expanduser().is_dir():
+            raise RuntimeError(
+                "Local Nemotron remote-code processor paths require an explicitly "
+                "injected reviewed processor."
+            )
+        if not name.startswith(self._processor_model_prefix):
+            raise RuntimeError(
+                f"Nemotron processor {name!r} is not approved for remote-code "
+                "loading. Inject a reviewed processor."
+            )
+        transformers = _require_transformers("Auto-loading a Nemotron 3.5 processor")
+        self._processor = transformers.AutoProcessor.from_pretrained(
+            name, trust_remote_code=True
+        )
+        return self._processor
+
+    @staticmethod
+    def _is_image_part(item: Any) -> bool:
+        return _is_image_part(item) or (
+            isinstance(item, dict) and item.get("type") == "input_image"
+        )
+
+    @staticmethod
+    def _image_source(part: dict[str, Any]) -> dict[str, Any]:
+        if "input_image" not in part:
+            return part
+        return {**part, "image": part["input_image"]}
+
+    @classmethod
+    def _logical_multimodal_content(
+        cls, content: list[Any]
+    ) -> tuple[str, list[dict[str, Any]]]:
+        text = "".join(
+            item if isinstance(item, str) else str(item.get("text") or "")
+            for item in content
+            if isinstance(item, str)
+            or (isinstance(item, dict) and item.get("type") in ("text", "input_text"))
+        )
+        image_parts = [
+            item
+            for item in content
+            if isinstance(item, dict) and cls._is_image_part(item)
+        ]
+        emit_structured_images = "<image>" not in text
+        rendered: list[str] = []
+        image_index = 0
+        for item in content:
+            if isinstance(item, str):
+                rendered.append(item)
+            elif not isinstance(item, dict):
+                raise ValueError(f"Unexpected content item: {item}")
+            elif cls._is_image_part(item):
+                image_index += 1
+                if emit_structured_images:
+                    if len(image_parts) > 1:
+                        rendered.append(f"<image {image_index}><image>")
+                    else:
+                        rendered.append("<image>")
+            elif item.get("type") in ("video", "video_url", "input_video"):
+                raise NotImplementedError(
+                    "Video parts are not yet supported by Nemotron35Renderer."
+                )
+            elif item.get("type") in ("text", "input_text") or "text" in item:
+                rendered.append(str(item.get("text") or ""))
+        return "".join(rendered), image_parts
+
+    @staticmethod
+    def _load_image(part: dict[str, Any]):
+        source = Nemotron35Renderer._image_source(part)
+        if "image" in source:
+            raw = source["image"]
+        elif "image_url" in source:
+            image_url = source.get("image_url")
+            raw = image_url.get("url") if isinstance(image_url, dict) else image_url
+        else:
+            raw = source.get("url") or source.get("path")
+        if isinstance(raw, str) and not raw.startswith("data:image/"):
+            raise ValueError(
+                "Nemotron 3.5 accepts in-memory images or data:image URIs; "
+                "network and filesystem image sources are disabled."
+            )
+        return _load_pil_image(source)
+
+    def _process_image(self, part: dict[str, Any]) -> tuple[dict[str, Any], int, str]:
+        self._image_token_id()
+        image = self._load_image(part)
+        output = self._get_processor().image_processor(
+            images=[image], return_tensors="np"
+        )
+        return output, int(output["num_tokens"][0]), _image_hash(image)
+
+    @staticmethod
+    def _expand_image_tokens(content: str, token_counts: list[int]) -> str:
+        if content.count("<image>") != len(token_counts):
+            raise ValueError(
+                "Nemotron image content must contain one <image> placeholder per image."
+            )
+        segments = content.split("<image>")
+        expanded = [segments[0]]
+        for count, suffix in zip(token_counts, segments[1:]):
+            expanded.append("<img>" + "<image>" * count + "</img>" + suffix)
+        return "".join(expanded)
+
+    def _transform_multimodal_messages(
+        self,
+        messages: list[Message],
+        *,
+        process_multimodal: bool,
+    ) -> tuple[list[Message], list[tuple[dict[str, Any], int, str]]]:
+        transformed: list[Message] = []
+        processed_images: list[tuple[dict[str, Any], int, str]] = []
+        for message in messages:
+            copied = dict(message)
+            content = message.get("content")
+            if isinstance(content, list) and any(
+                self._is_image_part(item) for item in content
+            ):
+                logical_content, image_parts = self._logical_multimodal_content(content)
+                if process_multimodal:
+                    current_images = [self._process_image(part) for part in image_parts]
+                    logical_content = self._expand_image_tokens(
+                        logical_content, [item[1] for item in current_images]
+                    )
+                    processed_images.extend(current_images)
+                copied["content"] = logical_content
+            transformed.append(copied)
+        return transformed, processed_images
+
+    def render(
+        self,
+        messages: list[Message],
+        *,
+        tools: list[ToolSpec] | None = None,
+        add_generation_prompt: bool = False,
+        process_multimodal: bool = True,
+    ) -> RenderedTokens:
+        transformed, processed_images = self._transform_multimodal_messages(
+            messages, process_multimodal=process_multimodal
+        )
+
+        rendered = super().render(
+            transformed,
+            tools=tools,
+            add_generation_prompt=add_generation_prompt,
+        )
+        if not processed_images:
+            return rendered
+
+        image_token_id = self._image_token_id()
+        placeholder_runs: list[PlaceholderRange] = []
+        cursor = 0
+        for _, length, _ in processed_images:
+            while (
+                cursor < len(rendered.token_ids)
+                and rendered.token_ids[cursor] != image_token_id
+            ):
+                cursor += 1
+            if (
+                rendered.token_ids[cursor : cursor + length]
+                != [image_token_id] * length
+            ):
+                raise ValueError(
+                    "Rendered Nemotron image placeholders are not contiguous."
+                )
+            placeholder_runs.append(PlaceholderRange(offset=cursor, length=length))
+            cursor += length
+
+        mm_data = MultiModalData(
+            mm_hashes={"image": [item[2] for item in processed_images]},
+            mm_placeholders={"image": placeholder_runs},
+            mm_items={
+                "image": [
+                    {
+                        key: processor_output[key]
+                        for key in (
+                            "pixel_values",
+                            "imgs_sizes",
+                            "num_tokens",
+                            "num_patches",
+                        )
+                    }
+                    for processor_output, _, _ in processed_images
+                ],
+            },
+        )
+        return replace(rendered, multi_modal_data=mm_data)
+
+    def bridge_to_next_turn(
+        self,
+        previous_prompt_ids: list[int],
+        previous_completion_ids: list[int],
+        new_messages: list[Message],
+        *,
+        tools: list[ToolSpec] | None = None,
+        previous_multi_modal_data: MultiModalData | None = None,
+        process_multimodal: bool = True,
+    ) -> RenderedTokens | None:
+        has_new_images = any(
+            isinstance(message.get("content"), list)
+            and any(self._is_image_part(item) for item in message["content"])
+            for message in new_messages
+        )
+        if has_new_images or (
+            previous_multi_modal_data is not None
+            and not previous_multi_modal_data.is_empty()
+        ):
+            return None
+        return super().bridge_to_next_turn(
+            previous_prompt_ids,
+            previous_completion_ids,
+            new_messages,
+            tools=tools,
+        )

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/renderers/qwen3.py

@@ -93,9 +93,16 @@ class Qwen3Renderer:
         return self._tokenizer.encode(text, add_special_tokens=False)
 
     @staticmethod
-    def _query_boundary_text(content) -> str:
+    def _content_text(content) -> str:
+        """Return the text parts of a message in a renderer-safe form.
+
+        Qwen3's native template is text-only, but text-only messages can also
+        use OpenAI-style content lists: ``[{"type": "text", "text": ...}]``.
+        Treat both representations identically instead of silently dropping
+        the message body.
+        """
         if isinstance(content, str):
-            return content.strip()
+            return content
         if isinstance(content, list):
             parts: list[str] = []
             for item in content:
@@ -103,9 +110,13 @@ class Qwen3Renderer:
                     parts.append(item)
                 elif isinstance(item, dict) and isinstance(item.get("text"), str):
                     parts.append(item["text"])
-            return "".join(parts).strip()
+            return "".join(parts)
         return ""
 
+    @staticmethod
+    def _query_boundary_text(content) -> str:
+        return Qwen3Renderer._content_text(content).strip()
+
     @staticmethod
     def _is_user_query_message(msg: Message) -> bool:
         if msg.get("role") != "user":
@@ -186,7 +197,7 @@ class Qwen3Renderer:
             # JSON as message body.
             segments: list[tuple[str, bool]] = [("system\n", False)]
             if first_is_system:
-                sys_content = messages[0].get("content") or ""
+                sys_content = self._content_text(messages[0].get("content"))
                 if sys_content:
                     segments.append((sys_content, True))
                 segments.append(("\n\n", False))
@@ -199,7 +210,7 @@ class Qwen3Renderer:
             emit_text("\n", sys_idx, is_sampled=False, is_content=False)
         elif first_is_system:
             emit_special(self._im_start, 0, is_sampled=False, is_content=False)
-            sys_content = messages[0].get("content") or ""
+            sys_content = self._content_text(messages[0].get("content"))
             sys_segments: list[tuple[str, bool]] = [("system\n", False)]
             if sys_content:
                 sys_segments.append((sys_content, True))
@@ -214,7 +225,7 @@ class Qwen3Renderer:
         num_messages = len(messages)
         for i, msg in enumerate(messages):
             role = msg["role"]
-            content = msg.get("content") if isinstance(msg.get("content"), str) else ""
+            content = self._content_text(msg.get("content"))
 
             if role == "system":
                 if i == 0:
@@ -415,7 +426,7 @@ class Qwen3Renderer:
 
         for i, msg in enumerate(new_messages):
             role = msg.get("role")
-            content = msg.get("content") if isinstance(msg.get("content"), str) else ""
+            content = self._content_text(msg.get("content"))
             if role == "user":
                 emit_special(self._im_start, i)
                 user_segments: list[tuple[str, bool]] = [("user\n", False)]

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/tests/test_bridge.py

@@ -205,6 +205,24 @@ def test_bridge_extension_includes_new_message_text(
     )
 
 
+def test_qwen3_renders_openai_text_content_parts(br_renderer, br_tokenizer, br_model):
+    """Text content lists must not become an empty user turn."""
+    if br_model not in {"Qwen/Qwen3-8B", "Qwen/Qwen3-4B"}:
+        pytest.skip(f"{br_model}: not a Qwen3 text renderer")
+
+    text = "CONTENT_LIST_SENTINEL_XYZ"
+    string_ids = br_renderer.render_ids(
+        [{"role": "user", "content": text}], add_generation_prompt=True
+    )
+    list_ids = br_renderer.render_ids(
+        [{"role": "user", "content": [{"type": "text", "text": text}]}],
+        add_generation_prompt=True,
+    )
+
+    assert list_ids == string_ids
+    assert text in br_tokenizer.decode(list_ids, skip_special_tokens=False)
+
+
 def test_bridge_declines_across_user_query_when_template_drops_thinking():
     """Qwen3's template drops a past block's thinking once a new user turn
     arrives. The resolved ``tool_cycle`` bridge policy therefore treats a

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/tests/test_client.py

@@ -595,6 +595,105 @@ def test_generate_serializes_multimodal_features_for_gemma4():
     )
 
 
+def test_generate_serializes_nemotron_dynamic_image_features():
+    pytest.importorskip("torch")
+    pytest.importorskip("vllm", reason="vllm needed for features serialization")
+
+    from vllm.entrypoints.scale_out.token_in_token_out.mm_serde import (
+        decode_mm_kwargs_item,
+    )
+    from vllm.model_executor.models.nano_nemotron_vl import NemotronH_Nano_VL_V2
+    from vllm.multimodal.inputs import MultiModalKwargsItems
+
+    from renderers.base import MultiModalData, PlaceholderRange
+    from renderers.nemotron3 import Nemotron35Renderer
+
+    class _FakeNemotronRenderer(Nemotron35Renderer):
+        def get_stop_token_ids(self):
+            return [99]
+
+        def parse_response(self, completion_ids, *, tools=None, prompt_ids=None):
+            return ParsedResponse(content="done")
+
+    renderer = object.__new__(_FakeNemotronRenderer)
+    mm_data = MultiModalData(
+        mm_hashes={"image": ["wide", "tall"]},
+        mm_placeholders={
+            "image": [
+                PlaceholderRange(offset=2, length=6),
+                PlaceholderRange(offset=10, length=6),
+            ]
+        },
+        mm_items={
+            "image": [
+                {
+                    "pixel_values": np.zeros((1, 3, 32, 48), dtype=np.float32),
+                    "imgs_sizes": np.array([[32, 48]], dtype=np.int64),
+                    "num_tokens": [6],
+                    "num_patches": [1],
+                },
+                {
+                    "pixel_values": np.ones((1, 3, 48, 32), dtype=np.float32),
+                    "imgs_sizes": np.array([[48, 32]], dtype=np.int64),
+                    "num_tokens": [6],
+                    "num_patches": [1],
+                },
+            ]
+        },
+    )
+    client = _FakeClient()
+
+    asyncio.run(
+        generate(
+            client=client,
+            renderer=renderer,
+            messages=[],
+            model="nemotron35-super",
+            prompt_ids=list(range(20)),
+            multi_modal_data=mm_data,
+            sampling_params={"max_tokens": 4},
+        )
+    )
+
+    features = client.calls[0]["body"]["features"]
+    assert features["mm_hashes"] == {"image": ["wide", "tall"]}
+    assert features["mm_placeholders"] == {
+        "image": [{"offset": 2, "length": 6}, {"offset": 10, "length": 6}]
+    }
+    decoded_items = [
+        decode_mm_kwargs_item(item) for item in features["kwargs_data"]["image"]
+    ]
+    decoded = [item.get_data() for item in decoded_items]
+    assert [tuple(item["pixel_values_flat"].shape) for item in decoded] == [
+        (3, 32, 48),
+        (3, 48, 32),
+    ]
+    assert [tuple(item["imgs_sizes"]) for item in decoded] == [
+        (32, 48),
+        (48, 32),
+    ]
+    assert [int(item["num_tokens_per_image"]) for item in decoded] == [6, 6]
+    assert all("image_num_patches" not in item for item in decoded)
+
+    kwargs = MultiModalKwargsItems({"image": decoded_items}).get_data()
+    model = object.__new__(NemotronH_Nano_VL_V2)
+    model.dynamic_resolution = True
+    model.patch_size = 16
+    image_input = model._parse_and_validate_image_input(**kwargs)
+
+    assert image_input is not None
+    assert tuple(image_input["pixel_values_flat"].shape) == (
+        1,
+        12,
+        3 * 16 * 16,
+    )
+    assert [tuple(size) for size in image_input["imgs_sizes"]] == [
+        (32, 48),
+        (48, 32),
+    ]
+    assert image_input["num_tokens_per_image"] == [6, 6]
+
+
 # ---------------------------------------------------------------------------
 # Prompt overflow handling.
 # ---------------------------------------------------------------------------

{renderers-0.1.12.dev7 → renderers-0.1.12.dev9}/tests/test_multimodal.py

@@ -105,8 +105,8 @@ _loaded: dict[str, tuple] = {}
 
 
 # Models whose processors need ``trust_remote_code=True`` (custom Python
-# in the repo) AND a pinned revision for security. Mirrors the
-# ``TRUSTED_REVISIONS`` policy in ``renderers.base`` for tokenizers.
+# in the repo) and still use a pinned revision. Nemotron 3.5 is handled
+# separately below so its selected model revision is not overridden.
 _PROCESSOR_TRUSTED_REVISIONS: dict[str, str] = {
     "moonshotai/Kimi-K2.5": "4d01dfe0332d63057c186e0b262165819efb6611",
     "moonshotai/Kimi-K2.6": "2755962d07cb42aa2d988a35bcb65cd4a9c2de82",
@@ -119,7 +119,12 @@ def _load_processor_and_renderer(model_name: str):
 
         tokenizer = load_tokenizer(model_name)
         revision = _PROCESSOR_TRUSTED_REVISIONS.get(model_name)
-        if revision is not None:
+        if model_name.startswith("nvidia/NVIDIA-Nemotron-3.5"):
+            processor = AutoProcessor.from_pretrained(
+                model_name,
+                trust_remote_code=True,
+            )
+        elif revision is not None:
             processor = AutoProcessor.from_pretrained(
                 model_name,
                 trust_remote_code=True,
@@ -173,6 +178,8 @@ def _detect_family(model_name: str) -> str:
     - ``gemma4``: canonical Gemma turn grammar plus dynamic
       ``<|image>`` + N x ``<|image|>`` + ``<image|>`` expansion.
     """
+    if model_name.startswith("nvidia/NVIDIA-Nemotron-3.5"):
+        return "nemotron35"
     if model_name.startswith("moonshotai/Kimi-K2.5") or model_name.startswith(
         "moonshotai/Kimi-K2.6"
     ):
@@ -332,6 +339,12 @@ def _modality_kit(modality: str, model_name: str):
                 "placeholder_token": "<|unused_200054|>",
                 "processor_input_ids": _qwen_vl_processor_input_ids,
             }
+        if family == "nemotron35":
+            return {
+                "make_part": _image_content_part,
+                "placeholder_token": "<image>",
+                "processor_input_ids": _qwen_vl_processor_input_ids,
+            }
         # Default: Qwen-VL family (Qwen3-VL, Qwen3.5, Qwen3.6).
         return {
             "make_part": _image_content_part,
@@ -594,9 +607,13 @@ def _supports_tool_message_images(renderer) -> bool:
     asserting against them."""
     from renderers.gemma4 import Gemma4Renderer
     from renderers.kimi_k25 import KimiK25Renderer
+    from renderers.nemotron3 import Nemotron35Renderer
     from renderers.qwen35 import Qwen35Renderer
 
-    return isinstance(renderer, (Qwen35Renderer, KimiK25Renderer, Gemma4Renderer))
+    return isinstance(
+        renderer,
+        (Qwen35Renderer, KimiK25Renderer, Gemma4Renderer, Nemotron35Renderer),
+    )
 
 
 @pytest.mark.parametrize(
@@ -715,6 +732,8 @@ def test_multimodal_bridge_extends_and_carries_mm_data(
         tokenizer,
         _config_for_model(mm_model_name, thinking_retention="all"),
     )
+    if not getattr(renderer, "supports_multimodal_bridge", True):
+        pytest.skip(f"{type(renderer).__name__} uses full multimodal re-rendering")
     if hasattr(renderer, "_processor") and renderer._processor is None:
         renderer._processor = processor
     sample = _sample_for(modality, tiny_image)