Merge branch 'v0.9.2-dev' into 'v0.9.2-dev-add_connector'

# Conflicts:
#   vllm/distributed/kv_transfer/kv_connector/v1/p2p/p2p_nccl_engine.py

vllm/model_executor/models/falcon.py

@@ -58,6 +58,7 @@ from .utils import (AutoWeightsLoader, is_pp_missing_parameter,
 
 from vllm import _custom_ops as ops
 from vllm.model_executor.utils import pad_weight, gemm_bank_conf
+import vllm.envs as envs
 
 FalconConfig = Union[HF_FalconConfig, RWConfig]
 
@@ -393,7 +394,7 @@ class FalconModel(nn.Module):
         self.use_gemm_pad = os.environ.get('GEMM_PAD') == '1'
         self.use_fa_pad = os.environ.get('FA_PAD') == '1'
         self.use_awq_pad = os.environ.get('AWQ_PAD') == '1'
-        self.w8a8_strategy=int(os.getenv('W8A8_SUPPORT_METHODS', '1'))
+        self.w8a8_strategy = envs.VLLM_W8A8_BACKEND
 
     def get_input_embeddings(self, input_ids: torch.Tensor) -> torch.Tensor:
         return self.word_embeddings(input_ids)

vllm/model_executor/models/glm4.py

@@ -31,6 +31,47 @@ from typing import Optional, Union
 import torch
 from torch import nn
 from transformers import Glm4Config
+import vllm.envs as envs
+
+
+class MultiModalConfigProxy:
+    """
+    Proxy class to handle both flat configs (e.g., Glm4Config) and 
+    nested multimodal configs (e.g., Glm4vConfig with text_config).
+    
+    For multimodal configs where attributes are in text_config, this proxy
+    transparently delegates attribute access to text_config when needed.
+    """
+    
+    def __init__(self, config):
+        # Store original config (for attributes that do exist at top level)
+        object.__setattr__(self, '_config', config)
+    
+    def __getattr__(self, name):
+        # First try to get from the original config (works for flat configs)
+        try:
+            return getattr(self._config, name)
+        except AttributeError:
+            # If not found and config has text_config, try there
+            if hasattr(self._config, 'text_config'):
+                return getattr(self._config.text_config, name)
+            # Re-raise the original error if text_config doesn't have it either
+            raise AttributeError(
+                f"'{type(self._config).__name__}' object has no attribute '{name}'"
+            )
+    
+    def __setattr__(self, name, value):
+        # Allow setting attributes on the proxy itself
+        if name == '_config':
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._config, name, value)
+    
+    def __hasattr__(self, name):
+        return hasattr(self._config, name) or (
+            hasattr(self._config, 'text_config') and 
+            hasattr(self._config.text_config, name)
+        )
 
 from vllm.attention import Attention, AttentionType
 from vllm.compilation.decorators import support_torch_compile
@@ -151,6 +192,9 @@ class Glm4DecoderLayer(nn.Module):
         prefix: str = "",
     ) -> None:
         super().__init__()
+        # Wrap config to handle both flat and nested multimodal configs
+        config = MultiModalConfigProxy(config)
+        
         self.hidden_size = config.hidden_size
         rope_theta = getattr(config, "rope_theta", 1000000)
         rope_scaling = getattr(config, "rope_scaling", None)
@@ -177,14 +221,11 @@ class Glm4DecoderLayer(nn.Module):
             quant_config=quant_config,
             prefix=f"{prefix}.mlp",
         )
-        self.input_layernorm = RMSNorm(config.hidden_size,
-                                       eps=config.rms_norm_eps)
-        self.post_attention_layernorm = RMSNorm(config.hidden_size,
-                                                eps=config.rms_norm_eps)
-        self.post_self_attn_layernorm = RMSNorm(config.hidden_size,
-                                                eps=config.rms_norm_eps)
-        self.post_mlp_layernorm = RMSNorm(config.hidden_size,
-                                          eps=config.rms_norm_eps)
+        rms_norm_eps = getattr(config, 'rms_norm_eps', 1e-5)
+        self.input_layernorm = RMSNorm(config.hidden_size, eps=rms_norm_eps)
+        self.post_attention_layernorm = RMSNorm(config.hidden_size, eps=rms_norm_eps)
+        self.post_self_attn_layernorm = RMSNorm(self.hidden_size, eps=rms_norm_eps)
+        self.post_mlp_layernorm = RMSNorm(self.hidden_size, eps=rms_norm_eps)
 
     def forward(
         self,
@@ -254,6 +295,9 @@ class Glm4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):
         quant_config = vllm_config.quant_config
         lora_config = vllm_config.lora_config
 
+        # Wrap config to handle both flat and nested multimodal configs
+        config = MultiModalConfigProxy(config)
+        
         self.config = config
         self.lora_config = lora_config
 
@@ -289,7 +333,7 @@ class Glm4ForCausalLM(nn.Module, SupportsLoRA, SupportsPP):
         self.use_gemm_pad = os.environ.get('GEMM_PAD') == '1'
         self.use_fa_pad = os.environ.get('FA_PAD') == '1'
         self.use_awq_pad = os.environ.get('AWQ_PAD') == '1'
-        self.w8a8_strategy=int(os.getenv('W8A8_SUPPORT_METHODS', '1'))
+        self.w8a8_strategy = envs.VLLM_W8A8_BACKEND
 
     def get_input_embeddings(self, input_ids: torch.Tensor) -> torch.Tensor:
         return self.model.get_input_embeddings(input_ids)

vllm/model_executor/models/qwen3_moe.py

@@ -38,6 +38,19 @@ from vllm.distributed import get_pp_group, get_tensor_model_parallel_world_size
 from vllm.logger import init_logger
 from vllm.model_executor.layers.activation import SiluAndMul
 from vllm.model_executor.layers.fused_moe import FusedMoE
+try:
+    from vllm.model_executor.layers.fused_moe.router_capture import (
+        maybe_record_router_logits,
+    )
+except ImportError:
+
+    def maybe_record_router_logits(
+        *,
+        layer_name: str,
+        router_logits: torch.Tensor,
+        top_k: int,
+    ) -> None:
+        return None
 from vllm.model_executor.layers.layernorm import RMSNorm
 from vllm.model_executor.layers.linear import (MergedColumnParallelLinear,
                                                QKVParallelLinear,
@@ -111,6 +124,8 @@ class Qwen3MoeSparseMoeBlock(nn.Module):
     ):
         super().__init__()
         self.tp_size = get_tensor_model_parallel_world_size()
+        self._router_top_k = int(config.num_experts_per_tok)
+        self._router_capture_layer_name = prefix
 
         if self.tp_size > config.num_experts:
             raise ValueError(
@@ -140,6 +155,14 @@ class Qwen3MoeSparseMoeBlock(nn.Module):
 
         # router_logits: (num_tokens, n_experts)
         router_logits, _ = self.gate(hidden_states)
+        if not (hasattr(torch, "_dynamo") and torch._dynamo.is_compiling()):
+            capture_enabled = envs.VLLM_MOE_ROUTER_CAPTURE
+            if capture_enabled:
+                maybe_record_router_logits(
+                    layer_name=self._router_capture_layer_name,
+                    router_logits=router_logits,
+                    top_k=self._router_top_k,
+                )
         final_hidden_states = self.experts(hidden_states=hidden_states,
                                            router_logits=router_logits)
 
@@ -453,7 +476,7 @@ class Qwen3MoeModel(nn.Module):
         self.use_gemm_pad = os.environ.get('GEMM_PAD') == '1'
         self.use_fa_pad = os.environ.get('FA_PAD') == '1'
         self.use_awq_pad = os.environ.get('AWQ_PAD') == '1'
-        self.w8a8_strategy=int(os.getenv('W8A8_SUPPORT_METHODS', '1'))
+        self.w8a8_strategy = envs.VLLM_W8A8_BACKEND
 
     def get_input_embeddings(self, input_ids: torch.Tensor) -> torch.Tensor:
         return self.embed_tokens(input_ids)