[None][fix] Tighten GLM-5.3-Flash modeling_v2 routing and fused MTP step

tensorrt_llm/_torch/_experimental/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default/modeling.py

@@ -15,15 +15,17 @@
 **Split speculative decoding.** The causal LM is a ``SpecDecOneEngineForCausalLM``: the engine's
 speculative worker runs verification, acceptance, the recurrent-state commit and the draft loop. For one-model MTP
 the stock drafter builds this module's MTP layer (``Glm5NextModel.mtp_layer_cls``). Routing admits the modes whose
-worker commits the KDA state for the accepted tokens and that read no captured hidden states; the sibling
-``glm_5_3_flash_nvfp4__sm_100__default_mtp_fused`` target serves linear one-model MTP-Eagle with the step fused into
-its forward.
+worker commits the KDA state for the accepted tokens, that read no captured hidden states and that draft a linear
+chain, since the verify reads no tree mask; the sibling ``glm_5_3_flash_nvfp4__sm_100__default_mtp_fused`` target
+serves linear one-model MTP-Eagle with the step fused into its forward.
 
 ``default`` is the built-in model's parallel coverage: the weight shapes are computed from the engine's ``Mapping``
 (tensor-parallel or expert-parallel MoE, attention DP), without pipeline or context parallelism.
 
 **Text only.** The checkpoint is the vision-language wrapper. This target builds and loads no vision tower: the
-weight mapper's audit allowlists the ``model.visual.*`` namespace.
+weight mapper's audit allowlists the ``model.visual.*`` namespace. A request that carries multimodal input is
+refused at admission (``validate_multimodal_request_data``), so a deployment that keeps the multimodal encoder
+serves text requests and fails image and video requests alone.
 """
 
 from __future__ import annotations
@@ -83,8 +85,8 @@
 _SM = (10, 0)
 
 #: Stock code the generic path runs outside the catalog, declared so it is not consumed silently: every
-#: tensorrt_llm import of this module that computes (test_modeling_v2_claims.py checks the list both ways). An entry
-#: leaves the list when a catalog entry replaces it.
+#: tensorrt_llm import of this module that computes (this target's unit tests check the list both ways, with
+#: ``_glm5_next_generic_calls.py``). An entry leaves the list when a catalog entry replaces it.
 UNCERTIFIED_GENERIC_CALLS = (
     # The causal LM's and the text model's base classes and the checkpoint's weight mapper.
     "tensorrt_llm._torch.models.modeling_utils.DecoderModel",
@@ -2080,3 +2082,15 @@ def __init__(self, model_config: ModelConfig[PretrainedConfig]) -> None:
 
     def load_weights(self, weights: Any, weight_mapper: BaseWeightMapper | None = None) -> None:
         _weights.load(self, weights, weight_mapper)
+
+    def validate_multimodal_request_data(self, mm_data: dict) -> None:
+        """Refuse, at admission, a request that carries multimodal input: this target runs no vision tower.
+
+        The executor calls this only for a request with multimodal data. Refusing here fails that request alone;
+        the forward would otherwise serve its text without the image or video.
+        """
+        del mm_data
+        raise ValueError(
+            "the GLM-5.3-Flash modeling_v2 target serves text only and runs no vision tower; the request carries "
+            "multimodal input"
+        )

tensorrt_llm/_torch/_experimental/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default_mtp_fused/modeling.py

@@ -19,13 +19,16 @@
 rewind). It computes what the stock MTP-Eagle worker computes for greedy and plain sampling; every other speculative
 feature, and running without speculation, is served by the sibling split target
 ``glm_5_3_flash_nvfp4__sm_100__default``. Routing declines them here, and the constructor checks again
-(``_check_speculation``).
+(``_check_speculation``). Routing also sends DWDP deployments to the split target, whose stock drafter declares the
+MTP layer to DWDP as a repeated layer; the constructor does not see DWDP.
 
 ``default`` is the built-in model's parallel coverage: the weight shapes are computed from the engine's ``Mapping``
 (tensor-parallel or expert-parallel MoE, attention DP), without pipeline or context parallelism.
 
 **Text only.** The checkpoint is the vision-language wrapper. This target builds and loads no vision tower: the
-weight mapper's audit allowlists the ``model.visual.*`` namespace.
+weight mapper's audit allowlists the ``model.visual.*`` namespace. A request that carries multimodal input is
+refused at admission (``validate_multimodal_request_data``), so a deployment that keeps the multimodal encoder
+serves text requests and fails image and video requests alone.
 """
 
 from __future__ import annotations
@@ -91,8 +94,8 @@
 _SM = (10, 0)
 
 #: Stock code the generic path runs outside the catalog, declared so it is not consumed silently: every
-#: tensorrt_llm import of this module that computes (test_modeling_v2_claims.py checks the list both ways). An entry
-#: leaves the list when a catalog entry replaces it.
+#: tensorrt_llm import of this module that computes (this target's unit tests check the list both ways, with
+#: ``_glm5_next_generic_calls.py``). An entry leaves the list when a catalog entry replaces it.
 UNCERTIFIED_GENERIC_CALLS = (
     # The causal LM's and the text model's base classes and the checkpoint's weight mapper.
     "tensorrt_llm._torch.models.modeling_utils.DecoderModelForCausalLM",
@@ -2184,8 +2187,10 @@ def __call__(
             )
 
         original_all_rank_num_tokens = attn_metadata.all_rank_num_tokens
-        self._save_metadata(attn_metadata, batch_size)
         try:
+            # Saved inside the ``try``: a save that fails partway, such as an out-of-memory copy during the engine's
+            # warmup, must not leave the lengths saved, or every later step fails in ``prepare_for_spec_dec``.
+            self._save_metadata(attn_metadata, batch_size)
             next_draft_tokens = self._draft(
                 input_ids,
                 position_ids,
@@ -2420,6 +2425,7 @@ def _save_metadata(self, attn_metadata: AttentionMetadata, batch_size: int) -> N
         self._saved = saved
 
     def _restore_metadata(self, attn_metadata: AttentionMetadata) -> None:
+        """Undo :meth:`_save_metadata`, also after a save that failed partway: each field only if it was saved."""
         if attn_metadata.has_spec_dec_saved_state:
             attn_metadata.restore_from_spec_dec()
             attn_metadata.on_update()
@@ -2468,3 +2474,15 @@ def __init__(self, model_config: ModelConfig[PretrainedConfig]) -> None:
 
     def load_weights(self, weights: Any, weight_mapper: BaseWeightMapper | None = None) -> None:
         _weights.load(self, weights, weight_mapper)
+
+    def validate_multimodal_request_data(self, mm_data: dict) -> None:
+        """Refuse, at admission, a request that carries multimodal input: this target runs no vision tower.
+
+        The executor calls this only for a request with multimodal data. Refusing here fails that request alone;
+        the forward would otherwise serve its text without the image or video.
+        """
+        del mm_data
+        raise ValueError(
+            "the GLM-5.3-Flash modeling_v2 target serves text only and runs no vision tower; the request carries "
+            "multimodal input"
+        )

tensorrt_llm/_torch/_experimental/modeling_v2/models/glm5_next/routing.py

@@ -19,7 +19,10 @@
 
 The checkpoint declares the vision-language wrapper, and the language model's
 shape lives in its ``text_config``, so that is what this tree reads. The
-targets are text-only: they load no vision tower.
+targets are text only: they load no vision tower, and each refuses a request
+that carries image or video input at admission
+(``validate_multimodal_request_data``). ``route`` therefore takes a deployment
+whether or not it disables the multimodal encoder.
 """
 
 from __future__ import annotations
@@ -82,7 +85,9 @@ def fused_speculation_refused(spec_config: Any) -> list[str]:
     """The speculative features the MTP-fused target does not compute; empty when it computes this config.
 
     The target runs the checkpoint's MTP layer as a linear one-model MTP-Eagle chain with strict acceptance (greedy or
-    plain sampling) inside its own forward. ``route`` declines these features so the split target takes the
+    plain sampling) inside its own forward. Its drafter projects the drafts through the target's LM head and runs the
+    MTP layer's MoE on the target's backend, so it also refuses the drafter options the stock drafter applies: an
+    MXFP8 draft head and a draft MoE backend. ``route`` declines these features so the split target takes the
     deployment, and the fused target's constructor refuses them against direct construction.
     """
     if spec_config is None:
@@ -99,6 +104,8 @@ def fused_speculation_refused(spec_config: Any) -> list[str]:
         "sa_config": spec_config.sa_config is not None,
         "a separate speculative checkpoint": spec_config.speculative_model is not None,
         "a draft-length schedule": spec_config.draft_len_schedule is not None,
+        "an MXFP8 draft LM head": spec_config.draft_lm_head_dtype != "auto",
+        "a draft MoE backend": spec_config.moe_backend is not None,
     }
     return [name for name, present in refused.items() if present]
 
@@ -116,6 +123,10 @@ def _fused_refused(
         refused.append("guided decoding")
     if _mtp_with_split_head(model_config, spec_config):
         refused.append("an LM head split across attention-DP ranks")
+    # The draft chain runs the MTP layer once per draft step, and only the stock drafter declares it to DWDP as a
+    # repeated layer (``add_repeated_layer``).
+    if llm_args.dwdp_config is not None:
+        refused.append("DWDP")
     return refused
 
 
@@ -125,7 +136,9 @@ def _split_refused(model_config: ModelConfig, spec_config: Any) -> list[str]:
     The engine's speculative worker drives the target. A mode is admitted when its worker commits the KDA recurrent
     state for the accepted tokens and it reads no hidden states captured from the decoder layers, which this model
     does not capture: one-model MTP (vanilla or MTP-Eagle, from the checkpoint's own MTP layer) and suffix-automaton
-    drafting.
+    drafting. The target verifies the drafts as a linear chain: KDA advances its recurrent state through the verify
+    tokens in order and the sparse layers place them at consecutive positions, neither reading a tree mask, so draft
+    trees are declined.
     """
     if spec_config is None:
         return []
@@ -134,6 +147,8 @@ def _split_refused(model_config: ModelConfig, spec_config: Any) -> list[str]:
     if not isinstance(spec_config, MTPDecodingConfig):
         return [f"{type(spec_config).__name__} (only MTP or SA)"]
     refused = {
+        "a dynamic draft tree": spec_config.use_dynamic_tree,
+        "draft trees": spec_config.max_total_draft_tokens not in (None, spec_config.max_draft_len),
         "a separate speculative checkpoint": spec_config.speculative_model is not None,
         "an LM head split across attention-DP ranks": _mtp_with_split_head(
             model_config, spec_config
@@ -196,6 +211,6 @@ def route(
     spec = spec_config.spec_dec_mode.name
     raise NoTarget(
         f"{deployment}, speculative decoding {spec} with {', '.join(split_refused)}; the glm5_next "
-        "targets run one-model MTP (vanilla or MTP-Eagle, from the checkpoint's MTP layer), "
-        "suffix-automaton drafting or no speculative decoding"
+        "targets run one-model MTP (vanilla or MTP-Eagle, from the checkpoint's MTP layer, as a "
+        "linear draft chain), suffix-automaton drafting or no speculative decoding"
     )

tests/integration/test_lists/test-db/l0_cpu.yml

@@ -110,6 +110,12 @@ l0_cpu:
   # -m cpu_only, so the directory's GPU tests are left to l0_b300's modeling_v2 entry.
   - unittest/_torch/modeling_v2/models/qwen4_exp/qwen3_8_flash_next_nvfp4__sm_103__default
   - unittest/_torch/modeling_v2/models/glm5_next/test_glm5_next_routing.py
+  # GLM-5.3-Flash targets' cpu_only checks: UNCERTIFIED_GENERIC_CALLS against the sources, and the text-only
+  # admission hook.
+  - unittest/_torch/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default/test_glm53_flash_default_uncertified_generic_calls.py
+  - unittest/_torch/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default/test_glm53_flash_default_text_only.py
+  - unittest/_torch/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default_mtp_fused/test_glm53_flash_default_mtp_fused_uncertified_generic_calls.py
+  - unittest/_torch/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default_mtp_fused/test_glm53_flash_default_mtp_fused_text_only.py
   - unittest/_torch/pyexecutor
   - unittest/_torch/test_connector.py::test_a_partial_grouped_scheduler_is_rejected_at_bring_up
   - unittest/_torch/test_connector.py::test_a_grouped_scheduler_and_a_single_group_cache_are_accepted

tests/unittest/_torch/modeling_v2/models/glm5_next/_glm5_next_generic_calls.py

@@ -0,0 +1,100 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""The check that a GLM-5.3-Flash target module's ``UNCERTIFIED_GENERIC_CALLS`` names the stock code it runs.
+
+A target's generic path runs stock tensorrt_llm modules that no catalog entry certifies. The module that imports
+them lists them in ``UNCERTIFIED_GENERIC_CALLS``, so a dependency on stock code is visible and the list shrinks as
+entries replace stock calls. The check reads the source and imports nothing. Each target's test directory runs it on
+that target's declaring modules.
+"""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+PACKAGE = "tensorrt_llm._torch._experimental.modeling_v2"
+FAMILY = "glm5_next"
+FAMILY_DIR = (
+    Path(__file__).resolve().parents[6] / "tensorrt_llm/_torch/_experimental/modeling_v2/models"
+) / FAMILY
+
+#: tensorrt_llm imports that compute nothing, so the generic path need not declare them: types and configs it
+#: reads, enums it passes, the metadata it is handed and its logger.
+_NON_COMPUTE_IMPORTS = frozenset(
+    {
+        "AllReduceStrategy",
+        "AttentionMetadata",
+        "AuxStreamType",
+        "Mapping",
+        "ModelConfig",
+        "QuantAlgo",
+        "QuantConfig",
+        "logger",
+    }
+)
+
+
+def is_entry_module(module: str, target: str) -> bool:
+    """Whether ``module`` is modeling_v2 code the declaring module may call: catalog entries, the native loader, the
+    family's ``ops`` and the target's own ``ops``."""
+    family_package = f"{PACKAGE}.models.{FAMILY}"
+    roots = (
+        f"{PACKAGE}.catalog",
+        f"{PACKAGE}._native",
+        f"{family_package}.ops",
+        f"{family_package}.{target}.ops",
+    )
+    return any(module == root or module.startswith(root + ".") for root in roots)
+
+
+def declared(tree: ast.Module) -> tuple[str, ...] | None:
+    """The string tuple assigned to ``UNCERTIFIED_GENERIC_CALLS``, or None if the module has none."""
+    for node in tree.body:
+        if isinstance(node, ast.Assign) and any(
+            isinstance(t, ast.Name) and t.id == "UNCERTIFIED_GENERIC_CALLS" for t in node.targets
+        ):
+            return tuple(ast.literal_eval(node.value))
+    return None
+
+
+def stock_imports(tree: ast.Module, target: str) -> set[str]:
+    """Every tensorrt_llm name the module imports with ``from ... import`` outside modeling_v2 entries, module level,
+    function local or for type checking only, except the names that compute nothing."""
+    imported = set()
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, ast.ImportFrom)
+            and node.level == 0
+            and node.module is not None
+            and node.module.split(".")[0] == "tensorrt_llm"
+            and not is_entry_module(node.module, target)
+        ):
+            imported.update(
+                f"{node.module}.{alias.name}"
+                for alias in node.names
+                if alias.name not in _NON_COMPUTE_IMPORTS
+            )
+    return imported
+
+
+def declaring_modules(target: str) -> list[Path]:
+    """The modules of ``target`` that declare ``UNCERTIFIED_GENERIC_CALLS``."""
+    return sorted(
+        p
+        for p in (FAMILY_DIR / target).rglob("*.py")
+        if declared(ast.parse(p.read_text())) is not None
+    )
+
+
+def check_names_every_stock_import(path: Path, target: str) -> None:
+    """The list of the module at ``path`` in ``target`` names every stock import, and nothing it does not import, so
+    it cannot go stale."""
+    tree = ast.parse(path.read_text())
+    names, imported = set(declared(tree)), stock_imports(tree, target)
+    assert imported <= names, (
+        f"imported but not in UNCERTIFIED_GENERIC_CALLS: {sorted(imported - names)}"
+    )
+    assert names <= imported, (
+        f"UNCERTIFIED_GENERIC_CALLS names what it does not import: {sorted(names - imported)}"
+    )

tests/unittest/_torch/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default/test_glm53_flash_default_text_only.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""The split target serves text only: its multimodal admission hook refuses a request that carries image or video
+input, which the forward would otherwise serve as its text alone."""
+
+import types
+
+import pytest
+
+from tensorrt_llm._torch._experimental.modeling_v2.models.glm5_next.glm_5_3_flash_nvfp4__sm_100__default.modeling import (  # noqa: E501
+    ModelingV2Glm53FlashNvfp4Sm100Default as Target,
+)
+from tensorrt_llm._torch.models.modeling_multimodal_mixin import MultimodalModelMixin
+
+pytestmark = pytest.mark.cpu_only
+
+_HOOK = "validate_multimodal_request_data"
+
+
+def test_the_target_defines_the_admission_hook():
+    """``PyExecutor._validate_request`` calls the hook by the name ``MultimodalModelMixin`` declares."""
+    assert callable(getattr(MultimodalModelMixin, _HOOK, None))
+    assert _HOOK in vars(Target)
+
+
+@pytest.mark.parametrize(
+    "mm_data",
+    [
+        {"image": {"pixel_values": None, "image_grid_thw": None}},
+        {"video": {"pixel_values_videos": None, "video_grid_thw": None}},
+    ],
+    ids=["image", "video"],
+)
+def test_multimodal_input_is_refused_at_admission(mm_data):
+    # The hook reads no model state, so it runs without building the model.
+    with pytest.raises(ValueError, match="serves text only"):
+        getattr(Target, _HOOK)(types.SimpleNamespace(), mm_data)

tests/unittest/_torch/modeling_v2/models/glm5_next/glm_5_3_flash_nvfp4__sm_100__default/test_glm53_flash_default_uncertified_generic_calls.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Each module of the split target that declares ``UNCERTIFIED_GENERIC_CALLS`` (its ``modeling.py`` must) names there
+every stock tensorrt_llm name it imports with ``from ... import``, and nothing else.
+
+The check is ``_glm5_next_generic_calls``; it reads the source and imports nothing."""
+
+import pytest
+
+__extra_import_path__ = [".."]
+from _glm5_next_generic_calls import (  # noqa: E402
+    FAMILY_DIR,
+    check_names_every_stock_import,
+    declaring_modules,
+)
+
+pytestmark = pytest.mark.cpu_only
+
+TARGET = "glm_5_3_flash_nvfp4__sm_100__default"
+MODULES = declaring_modules(TARGET)
+
+
+def test_modeling_declares_the_generic_calls():
+    assert FAMILY_DIR / TARGET / "modeling.py" in MODULES, (
+        f"{TARGET}/modeling.py does not declare UNCERTIFIED_GENERIC_CALLS"
+    )
+
+
+@pytest.mark.parametrize("path", MODULES, ids=lambda p: str(p.relative_to(FAMILY_DIR / TARGET)))
+def test_uncertified_generic_calls_name_every_stock_import(path):
+    check_names_every_stock_import(path, TARGET)