Thank you so much for your work quantising the model. The latest nightlies of VLLM (cu130-nightly) have a bug in the modelopt loader. My attempt to load it results in many WARNING errors in the log:
(Worker_PP1 pid=90) WARNING 02-15 06:51:46 [weight_utils.py:1235] Found k_scale in the checkpoint (e.g. layers.8.self_attn.k_scale), but not found the expected name in the model (e.g. layers.8.self_attn.attn.k_scale). k_scale is not loaded.
(Worker_PP2 pid=91) WARNING 02-15 06:51:46 [weight_utils.py:1235] Found v_scale in the checkpoint (e.g. layers.8.self_attn.v_scale), but not found the expected name in the model (e.g. layers.8.self_attn.attn.v_scale). v_scale is not loaded.
(Worker_PP1 pid=90) WARNING 02-15 06:51:46 [weight_utils.py:1235] Found v_scale in the checkpoint (e.g. layers.8.self_attn.v_scale), but not found the expected name in the model (e.g. layers.8.self_attn.attn.v_scale). v_scale is not loaded.
(Worker_PP2 pid=91) WARNING 02-15 06:51:48 [weight_utils.py:1235] Found k_scale in the checkpoint (e.g. layers.9.self_attn.k_scale), but not found the expected name in the model (e.g. layers.9.self_attn.attn.k_scale). k_scale is not loaded.
(Worker_PP1 pid=90) WARNING 02-15 06:51:48 [weight_utils.py:1235] Found k_scale in the checkpoint (e.g. layers.9.self_attn.k_scale), but not found the expected name in the model (e.g. layers.9.self_attn.attn.k_scale). k_scale is not loaded.
... etc

With some help from gemini cli, it appears the problem was a couple things:

1. a bad regex that matched and tried to nest further when looking up keys, fixed with a negative lookbehind
2. KV cache schema in Modelopt ignored the kv_cache_scheme key

I run this python based patch at docker container load time and this seems to solve it for now
import os
import vllm
import re

def apply_nvfp4_patches():
vllm_path = os.path.dirname(vllm.file)
print(f"Targeting vLLM installation at: {vllm_path}")

# --- Patch 1: weight_utils.py ---
weight_utils_path = os.path.join(vllm_path, "model_executor/model_loader/weight_utils.py")
if os.path.exists(weight_utils_path):
    with open(weight_utils_path, "r") as f:
        content = f.read()
    content = content.replace(r'(r"\.([qkv])_scale$", r".attn.\1_scale")', r'(r"(?<!\.attn)\.([qkv])_scale$", r".attn.\1_scale")')
    content = content.replace(r'(r"\.([qkv])_zero_point$", r".attn.\1_zero_point")', r'(r"(?<!\.attn)\.([qkv])_zero_point$", r".attn.\1_zero_point")')
    search_pattern = re.compile(r'for pattern, replacement in scale_mapping_patterns:.*?return remapped_name', re.DOTALL)
    indent_match = re.search(r'(\s+)for pattern, replacement in scale_mapping_patterns:', content)
    indent = indent_match.group(1) if indent_match else "        "
    replacement_block = f'for pattern, replacement in scale_mapping_patterns:\n{indent}    if re.search(pattern, name):\n{indent}        return re.sub(pattern, replacement, name)'
    content = search_pattern.sub(replacement_block, content)
    with open(weight_utils_path, "w") as f:
        f.write(content)
    print(f"Applied fixes to {weight_utils_path}")

# --- Patch 2: modelopt.py ---
modelopt_path = os.path.join(vllm_path, "model_executor/layers/quantization/modelopt.py")
if os.path.exists(modelopt_path):
    with open(modelopt_path, "r") as f:
        content = f.read()

    if "from typing import" in content and "Any" not in content:
        content = content.replace("from typing import", "from typing import Any,")

    # 1. Update Base Class __init__
    content = re.sub(
        r'def __init__\(\s*self,\s*exclude_modules:\s*list\[str\],?\s*\):',
        r'def __init__(\n        self,\n        exclude_modules: list[str],\n        kv_cache_scheme: dict[str, Any] | None = None,\n    ):',
        content
    )
    content = re.sub(
        r'super\(\)\.__init__\(\)\s+self\.exclude_modules:\s*list\[str\]\s*=\s*exclude_modules',
        r'super().__init__()\n        self.exclude_modules: list[str] = exclude_modules\n        self.kv_cache_scheme = kv_cache_scheme',
        content
    )

    # 2. Define kv_cache_scheme in from_config
    if 'kv_cache_scheme = config.get("kv_cache_scheme")' not in content:
        content = content.replace(
            'def from_config(cls, config: dict[str, Any]) -> "ModelOptQuantConfigBase":',
            'def from_config(cls, config: dict[str, Any]) -> "ModelOptQuantConfigBase":\n        kv_cache_scheme = config.get("kv_cache_scheme")'
        )
    
    # 3. Pass kv_cache_scheme to _from_config returns
    if 'kv_cache_scheme=kv_cache_scheme,' not in content:
        content = re.sub(
            r'return cls\._from_config\(\s*quant_method=quant_method,',
            r'return cls._from_config(\n            quant_method=quant_method,',
            content
        )
        content = re.sub(
            r'exclude_modules=exclude_modules,\s*group_size=group_size,',
            r'exclude_modules=exclude_modules,\n            kv_cache_scheme=kv_cache_scheme,\n            group_size=group_size,',
            content
        )

    # 4. Patch the specific Config classes (Fp8, NvFp4, MxFp8)
    classes = ["ModelOptFp8Config", "ModelOptNvFp4Config", "ModelOptMxFp8Config"]
    for cls in classes:
        # Update __init__ signature
        # We look for the __init__ that follows the class definition
        init_sig_pattern = rf'(class {cls}\(ModelOptQuantConfigBase\):.*?def __init__\s*\()(.*?)(exclude_modules:\s*list\[str\],?)'
        content = re.sub(init_sig_pattern, r'\1\2\3\n        kv_cache_scheme: dict[str, Any] | None = None,', content, flags=re.DOTALL)
        
        # Update super().__init__ call
        super_pattern = rf'(class {cls}.*?def __init__.*?super\(\)\.__init__\()exclude_modules\)'
        content = re.sub(super_pattern, r'\1exclude_modules, kv_cache_scheme)', content, flags=re.DOTALL)

        # Update _from_config signature
        from_sig_pattern = rf'(class {cls}.*?def _from_config.*?)(exclude_modules:\s*list\[str\],)'
        content = re.sub(from_sig_pattern, r'\1\2\n        kv_cache_scheme: dict[str, Any] | None,', content, flags=re.DOTALL)
        
        # Update the instantiation call inside _from_config
        if cls == "ModelOptNvFp4Config":
            inst_pattern = rf'(class {cls}.*?def _from_config.*?return cls\(\s*.*?exclude_modules,)(\s*group_size,?\s*\))'
            content = re.sub(inst_pattern, r'\1\n            kv_cache_scheme,\2', content, flags=re.DOTALL)
        else:
            inst_pattern = rf'(class {cls}.*?def _from_config.*?return cls\(\s*.*?exclude_modules,)(\s*\))'
            content = re.sub(inst_pattern, r'\1\n            kv_cache_scheme,\2', content, flags=re.DOTALL)

    with open(modelopt_path, "w") as f:
        f.write(content)
    print(f"Applied fixes to {modelopt_path}")

if name == "main":
apply_nvfp4_patches()

Model outputs look great, however tool calling is broken so I'm trying your untested quant to see if its KV cache related. This quant (as of 17th Feb) seems to be skipping tokens in tool calling:
(APIServer pid=1) INFO 02-17 00:07:45 [logger.py:78] Generated response chatcmpl-8afade7af9fe196a (streaming complete): output: '\n\n\nminimax:tool_call\n<invoke namesearch_web">\nweather Adelaide today\n\n', output_token_ids: None, finish_reason: streaming_complete
See the missing '="' in the invoke name tag

If others find this patch fixes their scaling parameters lookup recursion, feel free to submit a PR to the VLLM git - I have zero git experience and feel out of my depth.

S