[Chore] Use Transformers v5 names and drop redundant processor use_fast (#58550)

Signed-off-by: Harry Mellor <19981378+hmellor@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

docs/models/supported_models.md

@@ -164,9 +164,9 @@ For your model to be compatible with vLLM's tensor parallel and/or pipeline para
 
 ```python
 
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
-class MyConfig(PretrainedConfig):
+class MyConfig(PreTrainedConfig):
     base_model_tp_plan = {
         "layers.*.self_attn.k_proj": "colwise",
         "layers.*.self_attn.v_proj": "colwise",

tests/config/test_bailing_mtp_config.py

@@ -3,7 +3,7 @@
 
 from typing import get_args
 
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.speculative import MTPModelTypes, SpeculativeConfig
 from vllm.transformers_utils.model_arch_config_convertor import (
@@ -11,8 +11,8 @@ from vllm.transformers_utils.model_arch_config_convertor import (
 )
 
 
-def _bailing_config() -> PretrainedConfig:
-    config = PretrainedConfig(
+def _bailing_config() -> PreTrainedConfig:
+    config = PreTrainedConfig(
         architectures=["BailingMoeV2_5ForCausalLM"],
         hidden_size=4096,
         kv_lora_rank=512,

tests/config/test_model_arch_config.py

@@ -10,7 +10,7 @@ from typing import cast
 from unittest.mock import Mock
 
 import pytest
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 from transformers.models.gemma4.configuration_gemma4 import Gemma4TextConfig
 
 from vllm.config import ModelConfig, ParallelConfig, SpeculativeConfig
@@ -125,7 +125,7 @@ def _assert_model_config_methods(
 
 def test_head_size_falls_back_when_head_dim_is_zero():
     """Regression test for configs that materialize missing head_dim as 0."""
-    hf_config = PretrainedConfig(
+    hf_config = PreTrainedConfig(
         model_type="deepseek_vl_v2",
         hidden_size=1280,
         num_attention_heads=10,
@@ -140,7 +140,7 @@ def test_head_size_falls_back_when_head_dim_is_zero():
 
 
 def test_qk_rope_head_dim_recovery_uses_model_revision(monkeypatch: pytest.MonkeyPatch):
-    hf_config = PretrainedConfig(
+    hf_config = PreTrainedConfig(
         model_type="deepseek_v2",
         qk_rope_head_dim=128,
         qk_nope_head_dim=128,
@@ -176,7 +176,7 @@ def test_qk_rope_head_dim_recovery_uses_model_revision(monkeypatch: pytest.Monke
     ],
 )
 def test_num_experts_per_tok_aliases(attribute: str):
-    hf_config = PretrainedConfig(**{attribute: 4})
+    hf_config = PreTrainedConfig(**{attribute: 4})
     convertor = ModelArchConfigConvertorBase(hf_config, hf_config)
     model_config = cast(
         ModelConfig,
@@ -191,7 +191,7 @@ def test_num_experts_per_tok_aliases(attribute: str):
 
 
 def test_num_experts_per_tok_none_is_normalized():
-    hf_config = PretrainedConfig(top_k_experts=None)
+    hf_config = PreTrainedConfig(top_k_experts=None)
     convertor = ModelArchConfigConvertorBase(hf_config, hf_config)
 
     assert convertor.get_num_experts_per_token() == 0
@@ -207,7 +207,7 @@ def test_legacy_modelopt_config_without_producer_is_normalized():
             "modelopt_quant_config": {"quant_cfg": {}},
         }
     }
-    hf_config = PretrainedConfig(quantization_config=quantization_config)
+    hf_config = PreTrainedConfig(quantization_config=quantization_config)
 
     convertor = ModelArchConfigConvertorBase(hf_config, hf_config)
 
@@ -370,7 +370,7 @@ def test_gemma4_uniform_head_dims_are_homogeneous():
     assert arch[3] is arch
 
 
-class _HeterogeneousConfig(PretrainedConfig):
+class _HeterogeneousConfig(PreTrainedConfig):
     """A heterogeneous config with no convertor of its own.
 
     Mirrors the parts vLLM uses: per-layer configs are shallow copies with the
@@ -384,7 +384,7 @@ class _HeterogeneousConfig(PretrainedConfig):
         super().__init__(**kwargs)
 
     @property
-    def per_layer_config(self) -> list[PretrainedConfig]:
+    def per_layer_config(self) -> list[PreTrainedConfig]:
         layers = []
         for i in range(self.num_hidden_layers):
             layer = copy(self)

tests/config/test_multimodal_config.py

@@ -6,7 +6,7 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from tests.models.utils import build_model_context
 from vllm.config.ec_transfer import ECRole, ECTransferConfig
@@ -136,7 +136,7 @@ def test_language_model_only_disables_via_supports_multimodal_inputs():
 
 
 def test_convertor_clears_mm_prefix_when_multimodal_disabled():
-    hf_config = PretrainedConfig(
+    hf_config = PreTrainedConfig(
         model_type="gemma3",
         architectures=["Gemma3ForConditionalGeneration"],
     )

tests/config/test_speculative_draft_hf_overrides.py

@@ -15,20 +15,20 @@ import functools
 from unittest.mock import MagicMock, patch
 
 import pytest
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.parallel import ParallelConfig
 from vllm.config.speculative import SpeculativeConfig
 
 
-def _make_hf_config(**kwargs) -> PretrainedConfig:
+def _make_hf_config(**kwargs) -> PreTrainedConfig:
     defaults = dict(
         architectures=["LlamaForCausalLM"],
         model_type="llama",
         num_hidden_layers=64,
     )
     defaults.update(kwargs)
-    return PretrainedConfig(**defaults)
+    return PreTrainedConfig(**defaults)
 
 
 @pytest.mark.cpu_test
@@ -137,7 +137,7 @@ def test_callable_overrides_reach_the_draft_config():
     """A callable override (config-to-config transform) composes with the
     architecture-mapping override and is applied to the draft config."""
 
-    def shrink(hf_config: PretrainedConfig) -> PretrainedConfig:
+    def shrink(hf_config: PreTrainedConfig) -> PreTrainedConfig:
         hf_config.num_hidden_layers = 1
         return hf_config
 
@@ -155,7 +155,7 @@ def test_arch_mapping_applies_before_callable_override():
     observes (and may adjust) the post-mapping config."""
     seen_architectures: list[str] = []
 
-    def record(hf_config: PretrainedConfig) -> PretrainedConfig:
+    def record(hf_config: PreTrainedConfig) -> PreTrainedConfig:
         seen_architectures.append(hf_config.architectures[0])
         return hf_config
 
@@ -202,7 +202,7 @@ def test_inkling_override_exposes_all_mtp_depths():
     assert out.local_layer_ids == [0, 2, 4]
 
 
-def _module_level_shrink(hf_config: PretrainedConfig) -> PretrainedConfig:
+def _module_level_shrink(hf_config: PreTrainedConfig) -> PreTrainedConfig:
     hf_config.num_hidden_layers = 1
     return hf_config
 

tests/config/test_speculative_draft_max_position_embeddings.py

@@ -17,7 +17,7 @@ import logging
 from typing import Literal
 
 import pytest
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.model import ModelConfig
 from vllm.config.parallel import ParallelConfig
@@ -46,7 +46,7 @@ def _override_logged(caplog: pytest.LogCaptureFixture) -> bool:
 
 @pytest.mark.cpu_test
 def test_override_raises_smaller_value(vllm_caplog: pytest.LogCaptureFixture):
-    hf_config = PretrainedConfig(max_position_embeddings=2048)
+    hf_config = PreTrainedConfig(max_position_embeddings=2048)
     SpeculativeConfig._maybe_override_draft_max_position_embeddings(
         hf_config, target_max_model_len=8192
     )
@@ -56,7 +56,7 @@ def test_override_raises_smaller_value(vllm_caplog: pytest.LogCaptureFixture):
 
 @pytest.mark.cpu_test
 def test_override_keeps_sufficient_value(vllm_caplog: pytest.LogCaptureFixture):
-    hf_config = PretrainedConfig(max_position_embeddings=8192)
+    hf_config = PreTrainedConfig(max_position_embeddings=8192)
     SpeculativeConfig._maybe_override_draft_max_position_embeddings(
         hf_config, target_max_model_len=8192
     )
@@ -66,7 +66,7 @@ def test_override_keeps_sufficient_value(vllm_caplog: pytest.LogCaptureFixture):
 
 @pytest.mark.cpu_test
 def test_override_ignores_missing_attribute(vllm_caplog: pytest.LogCaptureFixture):
-    hf_config = PretrainedConfig()
+    hf_config = PreTrainedConfig()
     hf_config.__dict__.pop("max_position_embeddings", None)
     SpeculativeConfig._maybe_override_draft_max_position_embeddings(
         hf_config, target_max_model_len=8192

tests/entrypoints/pooling/scoring/test_jina_ranking_io_processor_unit.py

@@ -7,7 +7,7 @@ from unittest.mock import MagicMock
 
 import pytest
 from tokenizers import Tokenizer, models, pre_tokenizers
-from transformers import PreTrainedTokenizerFast
+from transformers import TokenizersBackend
 
 from vllm import PoolingParams
 from vllm.entrypoints.pooling.base.io_processor import PoolingIOProcessor
@@ -70,7 +70,7 @@ def offline_processor_and_context():
     backend = Tokenizer(models.WordLevel({"[UNK]": 0}, unk_token="[UNK]"))
     backend.pre_tokenizer = pre_tokenizers.WhitespaceSplit()
     proc = JinaRankingIOProcessor.__new__(JinaRankingIOProcessor)
-    proc.tokenizer = PreTrainedTokenizerFast(tokenizer_object=backend)
+    proc.tokenizer = TokenizersBackend(tokenizer_object=backend)
     proc.model_config = SimpleNamespace(max_model_len=1024, is_encoder_decoder=False)
     proc.renderer = SimpleNamespace(
         default_cmpl_tok_params=TokenizeParams(max_total_tokens=1024)

tests/model_executor/layers/test_pooler_methods.py

@@ -9,7 +9,7 @@ from unittest.mock import patch
 import numpy as np
 import pytest
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import PoolerConfig, set_current_vllm_config
 from vllm.model_executor.layers.pooler import PoolingParamsUpdate
@@ -315,7 +315,7 @@ def test_dispatch_seq_cls_honors_token_pooling_type(tok_pooling_type):
         model_config=SimpleNamespace(
             pooler_config=pooler_config,
             head_dtype=None,
-            hf_config=PretrainedConfig(num_labels=3),
+            hf_config=PreTrainedConfig(num_labels=3),
         ),
     )
     classifier = torch.nn.Linear(4, 3)

tests/model_executor/test_qwen3_omni.py

@@ -8,7 +8,7 @@ from unittest.mock import Mock, patch
 import pytest
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import ParallelConfig
 from vllm.multimodal.processing import InputProcessingContext
@@ -52,7 +52,7 @@ def print_input_ids(input_ids):
 @pytest.fixture
 def mock_qwen3_omni_config():
     """Create a mock Qwen3OmniMoeThinker config."""
-    config = Mock(spec=PretrainedConfig)
+    config = Mock(spec=PreTrainedConfig)
     # Token IDs from https://huggingface.co/Qwen/Qwen3-Omni-30B-A3B-Instruct/blob/main/tokenizer_config.json
     config.audio_token_id = 151675  # <|audio_pad|>
     config.video_token_id = 151656  # <|video_pad|>

tests/models/language/pooling/test_jina_embeddings_v5.py

@@ -14,7 +14,7 @@ from types import SimpleNamespace
 from typing import cast
 
 import pytest
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import ModelConfig
 from vllm.model_executor.models.config import (
@@ -23,7 +23,7 @@ from vllm.model_executor.models.config import (
 )
 
 
-def _model_config(hf_config: PretrainedConfig) -> ModelConfig:
+def _model_config(hf_config: PreTrainedConfig) -> ModelConfig:
     """Minimal stand-in for ModelConfig; only hf_config is read."""
     return cast(ModelConfig, SimpleNamespace(hf_config=hf_config))
 
@@ -42,7 +42,7 @@ def test_encoder_backbone_enables_bidirectional_attention():
     EncoderOnlyAttention; JinaEmbeddingsV5Model then dispatches to the encoder
     implementation.
     """
-    hf_config = PretrainedConfig(is_decoder=False)
+    hf_config = PreTrainedConfig(is_decoder=False)
 
     JinaEmbeddingsV5ModelConfig.verify_and_update_model_config(_model_config(hf_config))
 
@@ -55,13 +55,13 @@ def test_supported_decoder_backbone_is_accepted():
 
     `-small` omits `is_decoder` entirely, so an absent attribute has to be
     treated as a decoder. The first assertion pins that assumption: if
-    PretrainedConfig ever gains an `is_decoder=False` default, this fails here
+    PreTrainedConfig ever gains an `is_decoder=False` default, this fails here
     rather than silently rejecting a supported checkpoint.
     """
-    absent = PretrainedConfig()
+    absent = PreTrainedConfig()
     assert not hasattr(absent, "is_decoder")
 
     JinaEmbeddingsV5ModelConfig.verify_and_update_model_config(_model_config(absent))
     JinaEmbeddingsV5ModelConfig.verify_and_update_model_config(
-        _model_config(PretrainedConfig(is_decoder=True))
+        _model_config(PreTrainedConfig(is_decoder=True))
     )

tests/models/multimodal/processing/test_audioflamingo3.py

@@ -22,19 +22,19 @@ from unittest.mock import MagicMock
 import numpy as np
 import pytest
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from tests.models.registry import HF_EXAMPLE_MODELS
 from vllm.config.multimodal import MultiModalDummyOptions
 
 
-class MockAudioFlamingo3Config(PretrainedConfig):
+class MockAudioFlamingo3Config(PreTrainedConfig):
     model_type = "audioflamingo3"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.audio_config = PretrainedConfig()
-        self.text_config = PretrainedConfig()
+        self.audio_config = PreTrainedConfig()
+        self.text_config = PreTrainedConfig()
 
 
 class MockAudioFlamingo3Processor:

tests/models/multimodal/processing/test_bailing_moe_v3_vl.py

@@ -8,7 +8,7 @@ import pytest
 import torch
 from PIL import Image
 from tokenizers import Tokenizer, decoders, models, pre_tokenizers
-from transformers import PreTrainedTokenizerFast
+from transformers import TokenizersBackend
 
 from vllm.model_executor.models.bailing_moe_v3_vl import (
     IMAGE_PLACEHOLDER,
@@ -34,7 +34,7 @@ def processor():
         add_prefix_space=False, use_regex=False
     )
     backend.decoder = decoders.ByteLevel()
-    tokenizer = PreTrainedTokenizerFast(
+    tokenizer = TokenizersBackend(
         tokenizer_object=backend,
         additional_special_tokens=[
             "<|vision_start|>",

tests/models/multimodal/processing/test_h2ovl.py

@@ -6,7 +6,7 @@ from collections.abc import Mapping
 
 import pytest
 from PIL import Image
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.multimodal import MULTIMODAL_REGISTRY
 from vllm.multimodal.image import rescale_image_size
@@ -17,7 +17,7 @@ from ...utils import build_model_context
 
 
 def _get_expected_num_patches(
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
     image: Image.Image,
     num_imgs: int,
     min_num: int,

tests/models/multimodal/processing/test_internvl.py

@@ -6,7 +6,7 @@ from collections.abc import Mapping
 
 import pytest
 from PIL import Image
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.multimodal import MULTIMODAL_REGISTRY
 from vllm.multimodal.image import rescale_image_size
@@ -17,7 +17,7 @@ from ...utils import build_model_context
 
 
 def _get_expected_num_patches(
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
     image: Image.Image,
     num_imgs: int,
     min_num: int,

tests/models/multimodal/processing/test_nemotron_vl.py

@@ -6,7 +6,7 @@ from collections.abc import Mapping
 
 import pytest
 from PIL import Image
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.multimodal import MULTIMODAL_REGISTRY
 from vllm.multimodal.image import rescale_image_size
@@ -17,7 +17,7 @@ from ...utils import build_model_context
 
 
 def _get_expected_num_patches(
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
     image: Image.Image,
     num_imgs: int,
     min_num: int,

tests/models/registry.py

@@ -7,7 +7,7 @@ from typing import Any, Literal
 
 import pytest
 from packaging.version import Version
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 from transformers import __version__ as TRANSFORMERS_VERSION
 
 from vllm.config.model import ModelDType, TokenizerMode
@@ -1233,7 +1233,7 @@ _MULTIMODAL_EXAMPLE_MODELS = {
         # NemotronH layers are constructed via `hybrid_override_pattern`
         use_original_num_layers=True,
         hf_overrides={
-            "vision_config": PretrainedConfig(
+            "vision_config": PreTrainedConfig(
                 args={
                     "min_num_patches": 1,
                     "max_num_patches": 12,

tests/models/test_adapters.py

@@ -4,7 +4,7 @@
 
 import pytest
 import torch
-from transformers import Gemma3Config, PretrainedConfig, Qwen2Config
+from transformers import Gemma3Config, PreTrainedConfig, Qwen2Config
 
 from vllm.model_executor.models.adapters import (
     _create_pooling_model_cls,
@@ -266,14 +266,14 @@ def test_resolve_num_labels_defaults_when_undeclared():
     config = _composite_config()
     assert (
         _resolve_num_labels(config, config.get_text_config())
-        == PretrainedConfig().num_labels
+        == PreTrainedConfig().num_labels
     )
 
 
 def test_resolve_num_labels_declared_on_outer_config():
     """Multimodal checkpoints keep id2label/problem_type on the top-level config."""
     config = _composite_config(outer_labels=20)
-    assert config.get_text_config().num_labels == PretrainedConfig().num_labels
+    assert config.get_text_config().num_labels == PreTrainedConfig().num_labels
     assert _resolve_num_labels(config, config.get_text_config()) == 20
 
 

tests/models/test_qwen3_5_mtp_config.py

@@ -5,7 +5,7 @@
 from typing import Any
 
 import pytest
-from transformers import AutoConfig, PretrainedConfig
+from transformers import AutoConfig, PreTrainedConfig
 
 from vllm.config.speculative import SpeculativeConfig
 
@@ -15,19 +15,19 @@ _CHECKPOINTS = {
 }
 
 
-def _mtp_config(model_type: str) -> PretrainedConfig:
+def _mtp_config(model_type: str) -> PreTrainedConfig:
     """Create a top-level MTP configuration with mtp_num_hidden_layers."""
     kwargs: dict[str, Any] = {
         "model_type": model_type,
         "architectures": ["SomeArch"],
         "mtp_num_hidden_layers": 1,
     }
-    return PretrainedConfig(**kwargs)
+    return PreTrainedConfig(**kwargs)
 
 
 def _multimodal_wrapper_mtp_config(
     model_type: str, mtp_layers: int = 1
-) -> PretrainedConfig:
+) -> PreTrainedConfig:
     """Download a multimodal wrapper config via AutoConfig.from_pretrained
     and configure mtp_num_hidden_layers in text_config.
 
@@ -36,7 +36,7 @@ def _multimodal_wrapper_mtp_config(
     - MoE   (qwen3_5_moe): Qwen/Qwen3.6-35B-A3B
     """
     repo = _CHECKPOINTS[model_type]
-    config: PretrainedConfig = AutoConfig.from_pretrained(repo)
+    config: PreTrainedConfig = AutoConfig.from_pretrained(repo)
     text_config = config.get_text_config()
     text_config.mtp_num_hidden_layers = mtp_layers
     return config

tests/models/transformers/test_backend.py

@@ -13,7 +13,7 @@ from typing import Any
 import pytest
 import torch
 import torch.nn as nn
-from transformers import AutoConfig, AutoModel, PretrainedConfig
+from transformers import AutoConfig, AutoModel, PreTrainedConfig
 
 from vllm.config import ModelConfig, VllmConfig
 from vllm.model_executor.models.interfaces import SupportsMultiModal
@@ -524,7 +524,7 @@ def replace_vocab_embeddings(model, **config_kwargs):
 
     stub = nn.Module()
     stub.model = model
-    stub.config = PretrainedConfig(
+    stub.config = PreTrainedConfig(
         vocab_size=VOCAB_SIZE, num_positions=NUM_POSITIONS, **config_kwargs
     )
     embeddings = Base._vocab_embeddings(stub)

tests/models/utils.py

@@ -8,7 +8,7 @@ from typing import Any
 
 import torch
 import torch.nn.functional as F
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.model import AttnTypeStr, ModelConfig, ModelDType, RunnerOption
 from vllm.config.pooler import SequencePoolingType, TokenPoolingType
@@ -446,12 +446,12 @@ def get_vllm_extra_kwargs(model_info: ModelInfo, vllm_extra_kwargs):
 
 
 def dummy_hf_overrides(
-    hf_config: PretrainedConfig,
+    hf_config: PreTrainedConfig,
     *,
     model_arch: str = "",
     exist_overrides: dict[str, Any] | None = None,
     use_original_num_layers: bool = False,
-) -> PretrainedConfig:
+) -> PreTrainedConfig:
     """Dummy HF overrides function used to create dummy model
     with only minimum nums of layer.
     """

tests/test_config.py

@@ -62,16 +62,16 @@ def test_nested_rope_validation_patch_preserves_flat_rope_parameters(monkeypatch
     def original_validate_rope(config, *args, **kwargs):
         calls.append(config)
 
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
-    monkeypatch.setattr(PretrainedConfig, "validate_rope", original_validate_rope)
+    monkeypatch.setattr(PreTrainedConfig, "validate_rope", original_validate_rope)
     _patch_hf_transformers_nested_rope_validation()
 
     nested_rope_parameters = {
         "full_attention": {"rope_type": "default"},
         "original_max_position_embeddings": 32768,
     }
-    PretrainedConfig.validate_rope(
+    PreTrainedConfig.validate_rope(
         SimpleNamespace(rope_parameters=nested_rope_parameters)
     )
     assert nested_rope_parameters == {"full_attention": {"rope_type": "default"}}
@@ -81,7 +81,7 @@ def test_nested_rope_validation_patch_preserves_flat_rope_parameters(monkeypatch
         "factor": 8.0,
         "rope_theta": 500000.0,
     }
-    PretrainedConfig.validate_rope(
+    PreTrainedConfig.validate_rope(
         SimpleNamespace(rope_parameters=flat_rope_parameters)
     )
     assert flat_rope_parameters == {
@@ -730,9 +730,9 @@ def test_batch_invariant_breakable_cudagraph(
     ],
 )
 def test_dsa_models_select_matching_mtp(model_type, expected_architecture):
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
-    hf_config = PretrainedConfig(
+    hf_config = PreTrainedConfig(
         architectures=["DeepseekV32ForCausalLM"],
         num_nextn_predict_layers=1,
     )
@@ -2463,14 +2463,14 @@ def test_get_and_verify_max_len_with_nope_layers(
     max_model_len, rope_parameters, expected_max_len
 ):
     """NoPE layers do not prevent deriving or scaling the context length."""
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
     from vllm.config.model import _get_and_verify_max_len
     from vllm.transformers_utils.model_arch_config_convertor import (
         ModelArchConfigConvertorBase,
     )
 
-    hf_config = PretrainedConfig(
+    hf_config = PreTrainedConfig(
         max_position_embeddings=4096,
         original_max_position_embeddings=2048,
     )
@@ -2514,14 +2514,14 @@ def test_get_and_verify_max_len_yarn_is_already_scaled(
     for every YaRN variant, so scaling it again overstates the limit and lets
     requests past the end of the cos/sin cache.
     """
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
     from vllm.config.model import _get_and_verify_max_len
     from vllm.transformers_utils.model_arch_config_convertor import (
         ModelArchConfigConvertorBase,
     )
 
-    hf_config = PretrainedConfig(max_position_embeddings=32768)
+    hf_config = PreTrainedConfig(max_position_embeddings=32768)
     hf_config.rope_parameters = {
         "rope_type": rope_type,
         "factor": factor,

tests/transformers_utils/test_config.py

@@ -11,7 +11,7 @@ from typing import cast
 from unittest.mock import MagicMock, patch
 
 import pytest
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.model import ModelConfig
 from vllm.tokenizers import get_tokenizer
@@ -223,7 +223,7 @@ def test_model_config_generation_fallback_forwards_code_revision():
         patch.object(
             config_module,
             "get_config",
-            return_value=PretrainedConfig(),
+            return_value=PreTrainedConfig(),
         ) as get_config,
     ):
         ModelConfig.try_get_generation_config(model_config)
@@ -269,7 +269,7 @@ def test_safetensors_metadata_of_repo_without_safetensors():
     ],
 )
 def test_mrope_num_dims(section_key, mrope_section, expected_num_dims):
-    config = PretrainedConfig()
+    config = PreTrainedConfig()
     config.rope_parameters = {"rope_type": "default", section_key: mrope_section}
 
     assert uses_mrope(config)
@@ -280,7 +280,7 @@ def test_mrope_num_dims(section_key, mrope_section, expected_num_dims):
 def test_mrope_num_dims_from_config_attribute(section_name):
     """Some configs expose the section as an attribute rather than under
     `rope_parameters`."""
-    config = PretrainedConfig()
+    config = PreTrainedConfig()
     setattr(config, section_name, [16, 16, 16, 16])
 
     assert uses_mrope(config)
@@ -289,7 +289,7 @@ def test_mrope_num_dims_from_config_attribute(section_name):
 
 def test_mrope_num_dims_from_nested_rope_parameters():
     """Sections nested by layer type must be found, not silently defaulted."""
-    config = PretrainedConfig()
+    config = PreTrainedConfig()
     config.rope_parameters = {
         "full_attention": {"mrope_section": [16, 16, 16, 16]},
         "linear_attention": {"rope_type": "default"},
@@ -300,4 +300,4 @@ def test_mrope_num_dims_from_nested_rope_parameters():
 
 
 def test_mrope_num_dims_without_mrope():
-    assert mrope_num_dims(PretrainedConfig()) == 0
+    assert mrope_num_dims(PreTrainedConfig()) == 0

tests/transformers_utils/test_config_parser_registry.py

@@ -4,7 +4,7 @@
 from pathlib import Path
 
 import pytest
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.transformers_utils.config import get_config_parser, register_config_parser
 from vllm.transformers_utils.config_parser_base import ConfigParserBase
@@ -19,7 +19,7 @@ class CustomConfigParser(ConfigParserBase):
         revision: str | None = None,
         code_revision: str | None = None,
         **kwargs,
-    ) -> tuple[dict, PretrainedConfig]:
+    ) -> tuple[dict, PreTrainedConfig]:
         raise NotImplementedError
 
 

tests/transformers_utils/test_hf_overrides_model_type.py

@@ -5,12 +5,12 @@
 import json
 import tempfile
 
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.transformers_utils.config import _CONFIG_REGISTRY, get_config
 
 
-class _TestCustomConfig(PretrainedConfig):
+class _TestCustomConfig(PreTrainedConfig):
     model_type = "test_custom_model"
 
     def __init__(self, custom_attr=42, **kw):

tests/transformers_utils/test_speculators_override.py

@@ -40,7 +40,7 @@ _SPECULATORS_CONFIG_DICT = {
 def _patched_get_config_dict(config_dict):
     """Return a patch context that bypasses HF Hub for get_config_dict."""
     return patch(
-        "vllm.transformers_utils.config.PretrainedConfig.get_config_dict",
+        "vllm.transformers_utils.config.PreTrainedConfig.get_config_dict",
         return_value=(config_dict, {}),
     )
 

tests/v1/spec_decode/test_extract_hidden_states.py

@@ -7,7 +7,7 @@ from unittest import mock
 import numpy as np
 import pytest
 import torch
-from transformers import CLIPVisionConfig, LlamaConfig, LlavaConfig, PretrainedConfig
+from transformers import CLIPVisionConfig, LlamaConfig, LlavaConfig, PreTrainedConfig
 
 from tests.v1.attention.utils import (
     BatchSpec,
@@ -336,7 +336,7 @@ def test_propose_different_layer_counts(num_hidden_layers):
 # ---------------------------------------------------------------------------
 
 
-class _DummyVLMConfig(PretrainedConfig):
+class _DummyVLMConfig(PreTrainedConfig):
     """Minimal composite config that mimics VLMs like Kimi-K2.5 or LLaVA.
 
     The text model's parameters (hidden_size, num_attention_heads, …) live
@@ -345,11 +345,11 @@ class _DummyVLMConfig(PretrainedConfig):
 
     model_type = "test_vlm"
 
-    def __init__(self, text_config: PretrainedConfig, **kwargs):
+    def __init__(self, text_config: PreTrainedConfig, **kwargs):
         self.text_config = text_config
         super().__init__(architectures=["LlamaForCausalLM"], **kwargs)
 
-    def get_text_config(self, decoder: bool = False) -> PretrainedConfig:
+    def get_text_config(self, decoder: bool = False) -> PreTrainedConfig:
         del decoder
         return self.text_config
 
@@ -403,7 +403,7 @@ def test_extract_hidden_states_config_preserves_vlm_text_config():
         eagle_aux_hidden_state_layer_ids=[1, 2],
     )
 
-    # The fix: text_config is still a PretrainedConfig, not a dict.
+    # The fix: text_config is still a PreTrainedConfig, not a dict.
     assert isinstance(extract_config.text_config, LlamaConfig)
 
     extracted = get_hf_text_config(extract_config)
@@ -473,7 +473,7 @@ def test_extract_hidden_states_speculative_config_vlm():
 
 def test_extract_hidden_states_config_invalid_text_config():
     """A nested text_config missing required attrs must still be rejected."""
-    broken_text_config = PretrainedConfig(hidden_size=128)
+    broken_text_config = PreTrainedConfig(hidden_size=128)
     vlm_config = _DummyVLMConfig(text_config=broken_text_config)
 
     extract_config = ExtractHiddenStatesConfig(

tools/pre_commit/check_forbidden_imports.py

@@ -13,6 +13,16 @@ _HF_NAMES = (
     r"|list_repo_refs|repo_exists"
 )
 
+# Transformers v4 names kept as aliases in v5.
+_TRANSFORMERS_LEGACY_NAMES = (
+    r"PretrainedConfig|PreTrainedTokenizer|PreTrainedTokenizerFast"
+    r"|BaseImageProcessorFast|\w+ImageProcessorFast"
+)
+_TRANSFORMERS_LEGACY_MODULES = (
+    r"tokenization_utils|tokenization_utils_fast|image_processing_utils_fast"
+    r"|models\.\w+\.\w+_fast"
+)
+
 
 @dataclass
 class ForbiddenImport:
@@ -117,6 +127,26 @@ CHECK_IMPORTS = {
         allowed_files={"vllm/transformers_utils/repo_utils.py"},
         allowed_dirs={"examples/"},
     ),
+    "transformers legacy names": ForbiddenImport(
+        pattern=(
+            r"^\s*from\s+transformers(?:\.[\w.]+)?\s+import\s*\([^)]*\b(?:"
+            + _TRANSFORMERS_LEGACY_NAMES
+            + r")\b"
+            r"|"
+            r"^\s*from\s+transformers(?:\.[\w.]+)?\s+import\b[^\n]*\b(?:"
+            + _TRANSFORMERS_LEGACY_NAMES
+            + r")\b"
+            r"|"
+            r"^\s*(?:from|import)\s+transformers\.(?:"
+            + _TRANSFORMERS_LEGACY_MODULES
+            + r")\b"
+        ),
+        tip=(
+            "Use the Transformers v5 names, e.g. PreTrainedConfig, PythonBackend, "
+            "TokenizersBackend, TorchvisionBackend, tokenization_utils_tokenizers, "
+            "tokenization_utils_sentencepiece and image_processing_backends."
+        ),
+    ),
 }
 
 
@@ -247,6 +277,46 @@ def test_regex():
             f"(expected {should_match}, got {result})"
         )
 
+    transformers_cases = [
+        # Should match
+        ("from transformers import PretrainedConfig", True),
+        ("from transformers import AutoConfig, PretrainedConfig", True),
+        ("from transformers import PreTrainedTokenizer", True),
+        ("from transformers import PreTrainedTokenizerFast", True),
+        ("from transformers.models.siglip import SiglipImageProcessorFast", True),
+        ("from transformers import (\n    PreTrainedTokenizerFast,\n)", True),
+        ("from transformers.configuration_utils import PretrainedConfig", True),
+        ("    from transformers import PretrainedConfig", True),
+        ("from transformers.tokenization_utils import AddedToken", True),
+        ("from transformers.tokenization_utils_fast import X", True),
+        ("from transformers.image_processing_utils_fast import X", True),
+        (
+            "from transformers.models.qwen2_vl.image_processing_qwen2_vl_fast import X",
+            True,
+        ),
+        ("import transformers.tokenization_utils_fast", True),
+        # Should not match
+        ("from transformers import PreTrainedConfig", False),
+        ("from transformers import PreTrainedTokenizerBase", False),
+        ("from transformers import PythonBackend, TokenizersBackend", False),
+        ("from transformers.tokenization_utils_base import BatchEncoding", False),
+        ("from transformers.tokenization_utils_tokenizers import X", False),
+        (
+            "from transformers.image_processing_backends import TorchvisionBackend",
+            False,
+        ),
+        ("from transformers.models.qwen2_vl import Qwen2VLImageProcessor", False),
+        ("from vllm.foo import GLM4VImageProcessorFast", False),
+        ("from transformers import (\n    PreTrainedConfig,\n)", False),
+        ("# from transformers import PretrainedConfig", False),
+    ]
+    for i, (content, should_match) in enumerate(transformers_cases):
+        result = matches("transformers legacy names", content)
+        assert result == should_match, (
+            f"transformers case {i} failed: {content!r} "
+            f"(expected {should_match}, got {result})"
+        )
+
     print("All regex tests passed.")
 
 

vllm/config/model.py

@@ -55,7 +55,7 @@ from vllm.utils.import_utils import LazyLoader
 from vllm.v1.attention.backends.registry import AttentionBackendEnum
 
 if TYPE_CHECKING:
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
     import vllm.model_executor.layers.quantization as me_quant
     import vllm.model_executor.models as me_models
@@ -64,7 +64,7 @@ if TYPE_CHECKING:
     from vllm.model_executor.layers.quantization import QuantizationMethods
     from vllm.v1.sample.logits_processor import LogitsProcessor
 else:
-    PretrainedConfig = Any
+    PreTrainedConfig = Any
 
     me_quant = LazyLoader(
         "model_executor", globals(), "vllm.model_executor.layers.quantization"
@@ -105,7 +105,7 @@ PROCESSED_LOGPROBS_MODES: tuple[LogprobsMode, ...] = (
     "processed_logits",
     "processed_logprobs",
 )
-HfOverrides = dict[str, Any] | Callable[[PretrainedConfig], PretrainedConfig]
+HfOverrides = dict[str, Any] | Callable[[PreTrainedConfig], PreTrainedConfig]
 ModelImpl = Literal["auto", "vllm", "transformers", "terratorch"]
 LayerBlockType = Literal["attention", "linear_attention", "mamba"]
 
@@ -183,9 +183,9 @@ class ModelConfig:
     We must set the global seed because otherwise,
     different tensor parallel workers would sample different tokens,
     leading to inconsistent results."""
-    hf_config: PretrainedConfig = field(init=False)
+    hf_config: PreTrainedConfig = field(init=False)
     """The Hugging Face config of the model."""
-    hf_text_config: PretrainedConfig = field(init=False)
+    hf_text_config: PreTrainedConfig = field(init=False)
     """The Hugging Face config of the text model (same as hf_config for text models)."""
     is_submodel_config: bool = field(default=False, init=False)
     """Whether this is a submodule view derived by `VllmConfig.with_hf_config`
@@ -483,7 +483,7 @@ class ModelConfig:
 
     def _update_nested(
         self,
-        target: PretrainedConfig | dict[str, Any],
+        target: PreTrainedConfig | dict[str, Any],
         updates: dict[str, Any],
     ) -> None:
         """Recursively updates a config or dict with nested updates."""
@@ -511,15 +511,15 @@ class ModelConfig:
 
     def _apply_dict_overrides(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         overrides: dict[str, Any],
     ) -> None:
         """Apply dict overrides, handling both nested configs and dict values."""
-        from transformers import PretrainedConfig
+        from transformers import PreTrainedConfig
 
         for key, value in overrides.items():
             attr = getattr(config, key, None)
-            if attr is not None and isinstance(attr, PretrainedConfig):
+            if attr is not None and isinstance(attr, PreTrainedConfig):
                 # It's a nested config - recursively update it
                 self._update_nested(attr, value)
             else:
@@ -2393,7 +2393,7 @@ def _resolve_auto_dtype(
 
 def _get_and_verify_dtype(
     model_id: str,
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
     dtype: str | torch.dtype,
     *,
     is_pooling_model: bool,
@@ -2440,7 +2440,7 @@ def _get_and_verify_dtype(
 
 
 def _get_head_dtype(
-    config: PretrainedConfig, dtype: torch.dtype, runner_type: str
+    config: PreTrainedConfig, dtype: torch.dtype, runner_type: str
 ) -> torch.dtype:
     head_dtype: str | torch.dtype | None = getattr(config, "head_dtype", None)
 
@@ -2464,7 +2464,7 @@ def _get_head_dtype(
 
 
 def _get_and_verify_max_len(
-    hf_config: PretrainedConfig,
+    hf_config: PreTrainedConfig,
     model_arch_config: ModelArchitectureConfig,
     tokenizer_config: dict | None,
     max_model_len: int | None,

vllm/config/speculative.py

@@ -22,12 +22,12 @@ from vllm.utils.import_utils import LazyLoader, has_arctic_inference
 from vllm.v1.attention.backends.registry import AttentionBackendEnum
 
 if TYPE_CHECKING:
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
     import vllm.model_executor.layers.quantization as me_quant
     from vllm.config.vllm import VllmConfig
 else:
-    PretrainedConfig = Any
+    PreTrainedConfig = Any
     VllmConfig = Any
 
     me_quant = LazyLoader(
@@ -657,7 +657,7 @@ class SpeculativeConfig:
         return hash_str
 
     @staticmethod
-    def hf_config_override(hf_config: PretrainedConfig) -> PretrainedConfig:
+    def hf_config_override(hf_config: PreTrainedConfig) -> PreTrainedConfig:
         initial_architecture = hf_config.architectures[0]
         use_v32_mtp = hf_config.model_type in ("deepseek_v32", "glm_moe_dsa")
         if hf_config.model_type == "dots3_note":
@@ -1066,16 +1066,16 @@ class SpeculativeConfig:
 
     @staticmethod
     def _apply_composed_hf_override(
-        target_hf_overrides: Callable[[PretrainedConfig], PretrainedConfig],
-        hf_config: PretrainedConfig,
-    ) -> PretrainedConfig:
+        target_hf_overrides: Callable[[PreTrainedConfig], PreTrainedConfig],
+        hf_config: PreTrainedConfig,
+    ) -> PreTrainedConfig:
         hf_config = SpeculativeConfig.hf_config_override(hf_config)
         return target_hf_overrides(hf_config)
 
     @staticmethod
     def compose_draft_hf_overrides(
         target_hf_overrides: HfOverrides | None,
-    ) -> Callable[[PretrainedConfig], PretrainedConfig]:
+    ) -> Callable[[PreTrainedConfig], PreTrainedConfig]:
         """Build the ``hf_overrides`` for the draft ``ModelConfig``.
 
         Callable overrides on the target are config-to-config transforms
@@ -1667,7 +1667,7 @@ class SpeculativeConfig:
 
     @staticmethod
     def _maybe_override_draft_max_position_embeddings(
-        draft_hf_config: PretrainedConfig,
+        draft_hf_config: PreTrainedConfig,
         target_max_model_len: int,
     ) -> None:
         """Raise an EAGLE draft's max_position_embeddings up to the target's.
@@ -1704,7 +1704,7 @@ class SpeculativeConfig:
     def _verify_and_get_draft_tp(
         target_parallel_config: ParallelConfig,
         speculative_draft_tensor_parallel_size: int | None,
-        draft_hf_config: PretrainedConfig,
+        draft_hf_config: PreTrainedConfig,
     ) -> int:
         """Verifies and adjusts the tensor parallel size for a draft model
         specified using speculative_draft_tensor_parallel_size.

vllm/config/utils.py

@@ -138,7 +138,7 @@ def getattr_iter(
 ) -> Any:
     """A helper function that retrieves an attribute from an object which may
     have multiple possible names. This is useful when fetching attributes from
-    arbitrary `transformers.PretrainedConfig` instances.
+    arbitrary `transformers.PreTrainedConfig` instances.
 
     In the case where the first name in `names` is the preferred name, and
     any other names are deprecated aliases, setting `warn=True` will log a
@@ -314,7 +314,7 @@ def normalize_value(x):
         except Exception:
             return str(x)
 
-    # PretrainedConfig (must be before dataclass branch as these are now dataclasses)
+    # PreTrainedConfig (must be before dataclass branch as these are now dataclasses)
     if hasattr(x, "to_json_string") and callable(x.to_json_string):
         try:
             return x.to_json_string()

vllm/config/vllm.py

@@ -56,12 +56,12 @@ from .watermarking import WatermarkConfig
 from .weight_transfer import WeightTransferConfig
 
 if TYPE_CHECKING:
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
     from vllm.model_executor.layers.quantization.base_config import QuantizationConfig
     from vllm.v1.kv_cache_interface import KVCacheConfig
 else:
-    PretrainedConfig = Any
+    PreTrainedConfig = Any
 
     QuantizationConfig = Any
 
@@ -939,7 +939,7 @@ class VllmConfig:
 
     def with_hf_config(
         self,
-        hf_config: PretrainedConfig,
+        hf_config: PreTrainedConfig,
         architectures: list[str] | None = None,
     ) -> "VllmConfig":
         if architectures is not None:

vllm/lora/layers/base.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, overload
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.lora import LoRAConfig
 
@@ -73,7 +73,7 @@ class BaseLayerWithLoRA(nn.Module):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         """Initializes lora matrices."""
         ...
@@ -103,7 +103,7 @@ class BaseLayerWithLoRA(nn.Module):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         """Returns True if the layer can be replaced by this LoRA layer."""
         raise NotImplementedError

vllm/lora/layers/base_linear.py

@@ -3,7 +3,7 @@
 
 
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm import envs
 from vllm.config import get_current_vllm_config
@@ -105,7 +105,7 @@ class BaseLinearLayerWithLoRA(BaseLayerWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         self.lora_config = lora_config
         if isinstance(self.base_layer, ReplicatedLinear):

vllm/lora/layers/classifier.py

@@ -3,7 +3,7 @@
 
 
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.lora import LoRAConfig
 from vllm.platforms import current_platform
@@ -16,7 +16,7 @@ class ClassificationHeadWithLoRA(ReplicatedLinearWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         # Preserve ordinary LoRA A/B support for classification heads.
         super().create_lora_weights(max_loras, lora_config, model_config)

vllm/lora/layers/column_parallel_linear.py

@@ -4,7 +4,7 @@
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.lora import LoRAConfig
 from vllm.distributed import tensor_model_parallel_all_gather
@@ -164,7 +164,7 @@ class ColumnParallelLinearWithLoRA(BaseLinearLayerWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         if type(source_layer) is maybe_get_oot_by_class(ColumnParallelLinear):
             return True
@@ -208,7 +208,7 @@ class MergedColumnParallelLinearWithLoRA(ColumnParallelLinearWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         """The main reason for overriding this function is to enhance  code
         maintainability.
@@ -366,7 +366,7 @@ class MergedColumnParallelLinearWithLoRA(ColumnParallelLinearWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
         decorate: bool = True,
     ) -> bool:
         merged_cls = maybe_get_oot_by_class(MergedColumnParallelLinear)
@@ -442,7 +442,7 @@ class QKVParallelLinearWithLoRA(ColumnParallelLinearWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         return (
             type(source_layer) is maybe_get_oot_by_class(QKVParallelLinear)
@@ -488,7 +488,7 @@ class MergedQKVParallelLinearWithLoRA(MergedColumnParallelLinearWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         """The main reason for overloading this function is to handle inconsistent
         weight dimensions in qkv lora.
@@ -502,7 +502,7 @@ class MergedQKVParallelLinearWithLoRA(MergedColumnParallelLinearWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
         decorate: bool = True,
     ) -> bool:
         return (
@@ -543,7 +543,7 @@ class ColumnParallelLinearWithShardedLoRA(ColumnParallelLinearWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
         decorate: bool = True,
     ) -> bool:
         # specifying kwargs so they can be easily accessed in decorator
@@ -585,7 +585,7 @@ class MergedColumnParallelLinearWithShardedLoRA(MergedColumnParallelLinearWithLo
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
         decorate: bool = True,
     ) -> bool:
         # specifying kwargs so they can be easily accessed in decorator
@@ -621,7 +621,7 @@ class QKVParallelLinearWithShardedLoRA(QKVParallelLinearWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         # specifying kwargs so they can be easily accessed in decorator
         return super().can_replace_layer(
@@ -669,7 +669,7 @@ class MergedQKVParallelLinearWithShardedLoRA(MergedQKVParallelLinearWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
         decorate: bool = True,
     ) -> bool:
         # specifying kwargs so they can be easily accessed in decorator
@@ -698,7 +698,7 @@ class MergedColumnParallelLinearVariableSliceWithLoRA(
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
         decorate: bool = True,
     ) -> bool:
         # Support MergedColumnParallelLinear with 3 or more slices

vllm/lora/layers/fused_moe.py

@@ -3,7 +3,7 @@
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm import envs
 from vllm.config.lora import LoRAConfig
@@ -245,7 +245,7 @@ class FusedMoEWithLoRA(BaseLayerWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         """Initializes lora matrices."""
         self._verify_ep_fs(lora_config)
@@ -465,7 +465,7 @@ class FusedMoEWithLoRA(BaseLayerWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         """Returns True if the layer can be replaced by this LoRA layer."""
         # source_layer is MoERunner
@@ -511,7 +511,7 @@ class FusedMoE3DWithLoRA(FusedMoEWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         """Initializes lora matrices."""
         if model_config is None:
@@ -624,7 +624,7 @@ class FusedMoE3DWithLoRA(FusedMoEWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         """Returns True if the layer can be replaced by this LoRA layer."""
         # source_layer is MoERunner

vllm/lora/layers/logits_processor.py

@@ -3,7 +3,7 @@
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.lora import LoRAConfig
 from vllm.distributed import (
@@ -85,7 +85,7 @@ class LogitsProcessorWithLoRA(BaseLayerWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         # TODO: Verify if this condition can be further relaxed
         if self.base_layer.vocab_size > 258048:
@@ -221,7 +221,7 @@ class LogitsProcessorWithLoRA(BaseLayerWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         # Special handling for the LogitsProcessor.
         return False

vllm/lora/layers/replicated_linear.py

@@ -4,7 +4,7 @@
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.lora import LoRAConfig
 from vllm.model_executor.custom_op import maybe_get_oot_by_class
@@ -61,7 +61,7 @@ class ReplicatedLinearWithLoRA(BaseLinearLayerWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         return isinstance(source_layer, maybe_get_oot_by_class(ReplicatedLinear))
 

vllm/lora/layers/row_parallel_linear.py

@@ -4,7 +4,7 @@
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.lora import LoRAConfig
 from vllm.distributed import (
@@ -89,7 +89,7 @@ class RowParallelLinearWithLoRA(BaseLinearLayerWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         return type(source_layer) is maybe_get_oot_by_class(RowParallelLinear)
 
@@ -165,7 +165,7 @@ class RowParallelLinearWithShardedLoRA(RowParallelLinearWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         # specifying kwargs so they can be easily accessed in decorator
         return super().can_replace_layer(

vllm/lora/layers/vocab_parallel_embedding.py

@@ -4,7 +4,7 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config.lora import LoRAConfig
 from vllm.model_executor.custom_op import maybe_get_oot_by_class
@@ -26,7 +26,7 @@ class VocabParallelEmbeddingWithLoRA(BaseLayerWithLoRA):
         self,
         max_loras: int,
         lora_config: LoRAConfig,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> None:
         self.lora_a_stacked = torch.zeros(
             (
@@ -113,7 +113,7 @@ class VocabParallelEmbeddingWithLoRA(BaseLayerWithLoRA):
         source_layer: nn.Module,
         lora_config: LoRAConfig,
         packed_modules_list: list,
-        model_config: PretrainedConfig | None = None,
+        model_config: PreTrainedConfig | None = None,
     ) -> bool:
         # Accept both the in-tree and any OOT class, because layers built on top of
         # `VocabParallelEmbedding` (e.g. by the Transformers modelling backend) use the

vllm/lora/utils.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 from huggingface_hub.utils import HfHubHTTPError, HFValidationError
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm import envs
 from vllm.config.lora import LoRAConfig
@@ -109,7 +109,7 @@ def from_layer(
     max_loras: int,
     lora_config: LoRAConfig,
     packed_modules_list: list,
-    model_config: PretrainedConfig | None = None,
+    model_config: PreTrainedConfig | None = None,
 ) -> nn.Module:
     for lora_cls in _all_lora_classes:
         # specifying kwargs so they can be easily accessed in decorator
@@ -130,7 +130,7 @@ def from_layer_logits_processor(
     lm_head: "ParallelLMHead",
     max_loras: int,
     lora_config: LoRAConfig,
-    model_config: PretrainedConfig | None = None,
+    model_config: PreTrainedConfig | None = None,
 ) -> LogitsProcessorWithLoRA:
     ret = LogitsProcessorWithLoRA(
         layer,
@@ -147,7 +147,7 @@ def from_layer_classification(
     layer: nn.Module,
     max_loras: int,
     lora_config: LoRAConfig,
-    model_config: PretrainedConfig | None = None,
+    model_config: PreTrainedConfig | None = None,
 ) -> ClassificationHeadWithLoRA:
     instance_layer = ClassificationHeadWithLoRA(layer)
     instance_layer.create_lora_weights(max_loras, lora_config, model_config)

vllm/model_executor/layers/mamba/gdn/base.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import (
     VllmConfig,
@@ -24,7 +24,7 @@ class GatedDeltaNetAttention(PluggableLayer, MambaBase):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         vllm_config: VllmConfig,
         prefix: str = "",
     ) -> None:

vllm/model_executor/layers/mamba/linear/bailing_linear_attn.py

@@ -4,7 +4,7 @@ import copy
 
 import torch
 import torch.nn.functional as F
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.config import (
     VllmConfig,
@@ -37,7 +37,7 @@ from vllm.triton_utils import tl, triton
 from vllm.v1.attention.backends.linear_attn import LinearAttentionMetadata
 
 
-def _build_rope_parameters(config: PretrainedConfig) -> dict | None:
+def _build_rope_parameters(config: PreTrainedConfig) -> dict | None:
     rope_parameters = copy.deepcopy(getattr(config, "rope_parameters", None)) or {}
     if "rope_theta" not in rope_parameters and hasattr(config, "rope_theta"):
         rope_parameters["rope_theta"] = config.rope_theta
@@ -385,7 +385,7 @@ class BailingMoELinearAttention(LinearAttention):
     # --8<-- [end:bailing_moe_linear_attention]
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         vllm_config: VllmConfig,
         prefix: str = "linear_attn",
     ):

vllm/model_executor/layers/mamba/linear/base.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright contributors to the vLLM project
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import (
     VllmConfig,
@@ -24,7 +24,7 @@ class LinearAttention(PluggableLayer, MambaBase):
     """Base class for Linear attention layer."""
 
     def __init__(
-        self, config: PretrainedConfig, vllm_config: VllmConfig, prefix: str = ""
+        self, config: PreTrainedConfig, vllm_config: VllmConfig, prefix: str = ""
     ):
         super().__init__()
         self.layer_idx = extract_layer_index(prefix)

vllm/model_executor/layers/pooler/activations.py

@@ -7,7 +7,7 @@ from typing import TypeVar
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import ModelConfig
 from vllm.logger import init_logger
@@ -17,7 +17,7 @@ logger = init_logger(__name__)
 
 
 def get_act_fn(
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
     static_num_labels: bool = True,
 ) -> "PoolerActivation":
     # get classification act_fn

vllm/model_executor/layers/quantization/auto_awq.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Union
 import torch
 from safetensors.torch import _TYPES as _SAFETENSORS_TO_TORCH_DTYPE
 from torch.nn import Parameter
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 import vllm.model_executor.layers.fused_moe  # noqa
 from vllm import _custom_ops as ops
@@ -370,7 +370,7 @@ class AutoAWQConfig(QuantizationConfig):
     def maybe_update_config(
         self,
         model_name: str,
-        hf_config: PretrainedConfig | None = None,
+        hf_config: PreTrainedConfig | None = None,
         revision: str | None = None,
     ):
         if self.modules_to_not_convert:

vllm/model_executor/layers/quantization/auto_gptq.py

@@ -6,7 +6,7 @@ from typing import Any
 
 import torch
 from safetensors.torch import _TYPES as _SAFETENSORS_TO_TORCH_DTYPE
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 import vllm.model_executor.layers.fused_moe  # noqa
 from vllm.logger import init_logger
@@ -273,7 +273,7 @@ class AutoGPTQConfig(QuantizationConfig):
     def maybe_update_config(
         self,
         model_name: str,
-        hf_config: PretrainedConfig | None = None,
+        hf_config: PreTrainedConfig | None = None,
         revision: str | None = None,
     ):
         if self.modules_in_block_to_quantize:

vllm/model_executor/layers/quantization/base_config.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any
 import regex as re
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 if TYPE_CHECKING:
     from vllm.model_executor.layers.quantization import QuantizationMethods
@@ -265,7 +265,7 @@ class QuantizationConfig(ABC):
     def maybe_update_config(  # noqa: B027
         self,
         model_name: str,
-        hf_config: PretrainedConfig | None = None,
+        hf_config: PreTrainedConfig | None = None,
         revision: str | None = None,
     ):
         """Interface to update values after config initialization.

vllm/model_executor/model_loader/tensorizer.py

@@ -18,7 +18,7 @@ import regex as re
 import torch
 from torch import nn
 from torch.utils._python_dispatch import TorchDispatchMode
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 import vllm.envs as envs
 from vllm.config import ModelConfig, ParallelConfig, VllmConfig, set_current_vllm_config
@@ -173,7 +173,7 @@ class TensorizerConfig(MutableMapping):
     deserialization_kwargs: dict[str, Any] | None = None
     _extra_serialization_attrs: dict[str, Any] | None = field(init=False, default=None)
     model_class: type[torch.nn.Module] | None = field(init=False, default=None)
-    hf_config: PretrainedConfig | None = field(init=False, default=None)
+    hf_config: PreTrainedConfig | None = field(init=False, default=None)
     dtype: str | torch.dtype | None = field(init=False, default=None)
     _is_sharded: bool = field(init=False, default=False)
     _fields: ClassVar[tuple[str, ...]]

vllm/model_executor/models/adapters.py

@@ -284,7 +284,7 @@ def as_embedding_model(cls: type[_T]) -> type[_T]:
 def _resolve_num_labels(hf_config: Any, text_config: Any) -> int:
     """Resolve the label count for a sequence classification head.
 
-    ``PretrainedConfig.num_labels`` is derived from ``id2label``, which always
+    ``PreTrainedConfig.num_labels`` is derived from ``id2label``, which always
     carries a default of two entries. Composite configs (such as multimodal
     checkpoints) declare their label space on the top-level config, so reading
     ``num_labels`` from ``get_text_config()`` silently returns that default and
@@ -297,9 +297,9 @@ def _resolve_num_labels(hf_config: Any, text_config: Any) -> int:
     if text_config is hf_config:
         return hf_config.num_labels
 
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
-    if hf_config.num_labels != PretrainedConfig().num_labels:
+    if hf_config.num_labels != PreTrainedConfig().num_labels:
         return hf_config.num_labels
     return text_config.num_labels
 

vllm/model_executor/models/audioflamingo3.py

@@ -22,7 +22,7 @@ from typing import Annotated, Any, Literal, TypeAlias
 
 import torch
 import torch.nn as nn
-from transformers import BatchFeature, PretrainedConfig
+from transformers import BatchFeature, PreTrainedConfig
 from transformers.models.audioflamingo3 import (
     AudioFlamingo3Config,
     AudioFlamingo3Processor,
@@ -118,7 +118,7 @@ AudioFlamingo3Inputs: TypeAlias = (
 class AudioFlamingo3Encoder(Qwen2AudioEncoder):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
     ):
         super().__init__(config)
         self.avg_pooler = nn.AvgPool1d(kernel_size=2, stride=2)
@@ -161,7 +161,7 @@ class AudioFlamingo3Encoder(Qwen2AudioEncoder):
 
 
 class AudioFlamingo3MultiModalProjector(nn.Module):
-    def __init__(self, config: PretrainedConfig):
+    def __init__(self, config: PreTrainedConfig):
         super().__init__()
         self.linear_1 = nn.Linear(
             config.audio_config.hidden_size,

vllm/model_executor/models/bailing_moe.py

@@ -30,7 +30,7 @@ from itertools import islice
 import torch
 import torch.nn.functional as F
 from torch import nn
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -74,7 +74,7 @@ from .utils import (
 class BailingAttention(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         reduce_results: bool = True,
@@ -183,7 +183,7 @@ class BailingMLP(nn.Module):
     def __init__(
         self,
         intermediate_size: int,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         reduce_results: bool = True,
         prefix: str = "",
@@ -217,7 +217,7 @@ class BailingMoE(nn.Module):
     def __init__(
         self,
         intermediate_size: int,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         reduce_results: bool | None = True,
         prefix: str = "",
@@ -328,7 +328,7 @@ class BailingMoE(nn.Module):
 class BailingMoeBlock(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",

vllm/model_executor/models/bailing_moe_linear.py

@@ -5,7 +5,7 @@ from collections.abc import Callable, Iterable
 
 import torch
 import torch.nn as nn
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -79,7 +79,7 @@ class BailingMoeV25MLAAttention(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         layer_id: int = 0,
         prefix: str = "attention",
@@ -234,7 +234,7 @@ class BailingMoeV25(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         layer_id: int = 0,
         prefix: str = "",
@@ -349,7 +349,7 @@ class BailingMoeV25DecoderLayer(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         vllm_config: VllmConfig,
         prefix: str = "layer",
         layer_id: int = 0,

vllm/model_executor/models/bailing_moe_mtp.py

@@ -6,7 +6,7 @@ from collections.abc import Callable, Iterable
 
 import torch
 import torch.nn as nn
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import VllmConfig
@@ -36,7 +36,7 @@ from vllm.sequence import IntermediateTensors
 from .utils import PPMissingLayer, is_pp_missing_parameter, maybe_prefix
 
 
-def _get_draft_hf_config(vllm_config: VllmConfig) -> PretrainedConfig:
+def _get_draft_hf_config(vllm_config: VllmConfig) -> PreTrainedConfig:
     speculative_config = vllm_config.speculative_config
     if speculative_config is not None:
         draft_model_config = speculative_config.draft_model_config
@@ -48,7 +48,7 @@ def _get_draft_hf_config(vllm_config: VllmConfig) -> PretrainedConfig:
 class BailingMTPSharedHead(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         vllm_config: VllmConfig,
     ) -> None:

vllm/model_executor/models/bailing_moe_v3.py

@@ -17,7 +17,7 @@ import regex as re
 import torch
 import torch.nn as nn
 from einops import rearrange
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, ModelConfig, VllmConfig, get_current_vllm_config
@@ -151,7 +151,7 @@ def _get_kda_state_shape_for_config(
     return shapes
 
 
-def _build_rope_parameters(config: PretrainedConfig) -> dict | None:
+def _build_rope_parameters(config: PreTrainedConfig) -> dict | None:
     rope_parameters = copy.deepcopy(getattr(config, "rope_parameters", None)) or {}
     if "rope_theta" not in rope_parameters and hasattr(config, "rope_theta"):
         rope_parameters["rope_theta"] = config.rope_theta
@@ -172,7 +172,7 @@ def _build_rope_parameters(config: PretrainedConfig) -> dict | None:
 
 
 def _build_mla_rotary_embedding(
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
     head_size: int,
 ) -> nn.Module:
     rope_parameters = _build_rope_parameters(config)
@@ -223,7 +223,7 @@ def _is_block_fp8_config(
 
 def _configure_ling_fp8_quant_config(
     quant_config: QuantizationConfig | None,
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
 ) -> None:
     if not _is_block_fp8_config(quant_config):
         return
@@ -372,7 +372,7 @@ def _pad_block_fp8_mlp_checkpoint_tensor(
 
 def _maybe_pad_block_fp8_shared_expert_checkpoint_tensor(
     quant_config: QuantizationConfig | None,
-    config: PretrainedConfig,
+    config: PreTrainedConfig,
     name: str,
     loaded_weight: torch.Tensor,
 ) -> torch.Tensor:
@@ -410,7 +410,7 @@ class BailingMoeV3MLP(nn.Module):
     def __init__(
         self,
         intermediate_size: int,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         reduce_results: bool = True,
         prefix: str = "",
@@ -446,7 +446,7 @@ class BailingMoeV3MLP(nn.Module):
 class BailingMoeV3MLAAttention(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         layer_id: int = 0,
         prefix: str = "attention",
@@ -625,7 +625,7 @@ class BailingMoeV3KimiDeltaAttention(PluggableLayer, MambaBase):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         layer_id: int = 0,
         prefix: str = "attention",
@@ -1121,7 +1121,7 @@ class BailingMoeV3KimiDeltaAttention(PluggableLayer, MambaBase):
 class BailingMoeV3MoE(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         layer_id: int = 0,
         prefix: str = "",
@@ -1193,7 +1193,7 @@ class BailingMoeV3MoE(nn.Module):
 class BailingMoeV3DecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         layer_id: int = 0,
         prefix: str = "layer",

vllm/model_executor/models/bailing_moe_v3_mtp.py

@@ -6,7 +6,7 @@ from collections.abc import Callable, Iterable
 
 import torch
 import torch.nn as nn
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import VllmConfig
@@ -47,7 +47,7 @@ from vllm.model_executor.models.utils import (
 from vllm.sequence import IntermediateTensors
 
 
-def _get_draft_hf_config(vllm_config: VllmConfig) -> PretrainedConfig:
+def _get_draft_hf_config(vllm_config: VllmConfig) -> PreTrainedConfig:
     speculative_config = vllm_config.speculative_config
     if speculative_config is not None:
         draft_model_config = speculative_config.draft_model_config
@@ -59,7 +59,7 @@ def _get_draft_hf_config(vllm_config: VllmConfig) -> PretrainedConfig:
 class BailingMoeV3MTPSharedHead(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         vllm_config: VllmConfig,
     ) -> None:

vllm/model_executor/models/bert_with_rope.py

@@ -4,7 +4,7 @@ from collections.abc import Iterable
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -50,7 +50,7 @@ from .interfaces_base import default_pooling_type
 
 
 class BertWithRopeEmbedding(nn.Module):
-    def __init__(self, config: PretrainedConfig):
+    def __init__(self, config: PreTrainedConfig):
         super().__init__()
         if config.position_embedding_type not in ["rope", "rotary"]:
             raise ValueError(
@@ -347,7 +347,7 @@ class NomicMoE(nn.Module):
 class BertWithRopeBlock(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         moe: bool = False,

vllm/model_executor/models/cohere2_vision.py

@@ -8,10 +8,10 @@ from typing import Annotated, Literal
 
 import torch
 from torch import nn
-from transformers import BatchFeature, PretrainedConfig
+from transformers import BatchFeature, PreTrainedConfig
 from transformers.models.cohere2_vision import Cohere2VisionConfig
-from transformers.models.cohere2_vision.image_processing_cohere2_vision_fast import (  # noqa: E501
-    Cohere2VisionImageProcessorFast,
+from transformers.models.cohere2_vision.image_processing_cohere2_vision import (  # noqa: E501
+    Cohere2VisionImageProcessor,
 )
 from transformers.models.cohere2_vision.processing_cohere2_vision import (
     Cohere2VisionProcessor,
@@ -178,7 +178,7 @@ class Cohere2VisionProcessingInfo(BaseProcessingInfo):
         """Calculate the number of image patches for a given image.
         Uses the HF processor to determine the actual number of patches.
         """
-        image_processor: Cohere2VisionImageProcessorFast = processor.image_processor
+        image_processor: Cohere2VisionImageProcessor = processor.image_processor
 
         return image_processor.get_number_of_image_patches(
             image_height,
@@ -415,7 +415,7 @@ class Cohere2VisionForConditionalGeneration(
         )
 
     def _patch_quant_config(
-        self, config: PretrainedConfig, quant_config: QuantizationConfig | None
+        self, config: PreTrainedConfig, quant_config: QuantizationConfig | None
     ):
         # the awq models from OpenGVLab missing `modules_to_not_convert`
         # patch the quant_config to add `modules_to_not_convert` back

vllm/model_executor/models/cohere_asr.py

@@ -8,7 +8,7 @@ from typing import Any, ClassVar
 import torch
 import torch.nn.functional as F
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, ModelConfig, SpeechToTextConfig, VllmConfig
@@ -1861,7 +1861,7 @@ class CohereASRModel(nn.Module):
 
 
 class CohereASRProcessingInfo(BaseProcessingInfo):
-    def get_hf_config(self) -> PretrainedConfig:
+    def get_hf_config(self) -> PreTrainedConfig:
         return self.ctx.get_hf_config()
 
     def get_default_tok_params(self) -> TokenizeParams:

vllm/model_executor/models/cohere_compass.py

@@ -1161,7 +1161,6 @@ class CohereCompassProcessingInfo(BaseProcessingInfo):
     def get_hf_processor(self, **kwargs: object) -> CohereCompassProcessor:
         return self.ctx.get_hf_processor(
             CohereCompassProcessor,
-            use_fast=kwargs.pop("use_fast", True),
             **kwargs,
         )
 

vllm/model_executor/models/colqwen3.py

@@ -61,7 +61,6 @@ class ColQwen3ProcessingInfo(Qwen3VLProcessingInfo):
         # correctly for the Qwen3-VL backbone.
         return self.ctx.get_hf_processor(
             Qwen3VLProcessor,
-            use_fast=kwargs.pop("use_fast", True),
             **kwargs,
         )
 

vllm/model_executor/models/colqwen3_5.py

@@ -58,7 +58,6 @@ class ColQwen3_5ProcessingInfo(Qwen3_5ProcessingInfo):
     def get_hf_processor(self, **kwargs: object) -> Qwen3VLProcessor:
         return self.ctx.get_hf_processor(
             Qwen3VLProcessor,
-            use_fast=kwargs.pop("use_fast", True),
             **kwargs,
         )
 

vllm/model_executor/models/config.py

@@ -6,7 +6,7 @@ from vllm.logger import init_logger
 from vllm.utils.math_utils import round_up
 
 if TYPE_CHECKING:
-    from transformers import PretrainedConfig
+    from transformers import PreTrainedConfig
 
     from vllm.config import CacheConfig, ModelConfig, VllmConfig
     from vllm.config.cache import MambaDType
@@ -681,7 +681,7 @@ class NemotronHForCausalLMConfig(VerifyAndUpdateConfig):
 
     @classmethod
     def update_mamba_ssm_cache_dtype(
-        cls, *, cache_config: "CacheConfig", hf_config: "PretrainedConfig"
+        cls, *, cache_config: "CacheConfig", hf_config: "PreTrainedConfig"
     ) -> None:
         """Update mamba_ssm_cache_dtype for NemotronH models when set to 'auto'
         (or not explicitly set), to the value specified in the HF config, or to

vllm/model_executor/models/deepseek_mtp.py

@@ -5,7 +5,7 @@ from collections.abc import Callable, Iterable
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import VllmConfig
@@ -51,7 +51,7 @@ from .utils import (
 class SharedHead(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         quant_config: QuantizationConfig | None = None,
         *,

vllm/model_executor/models/diffusion_gemma.py

@@ -112,13 +112,13 @@ class DiffusionGemmaProcessingInfo(Gemma4ProcessingInfo):
     """Processing info for DiffusionGemma.
 
     Overrides ``get_hf_config`` to accept ``DiffusionGemmaConfig``
-    (which inherits from ``PretrainedConfig``, not ``Gemma4Config``).
+    (which inherits from ``PreTrainedConfig``, not ``Gemma4Config``).
     Supports image and video modalities.
     """
 
     def get_hf_config(self):
         # DiffusionGemmaConfig doesn't inherit from Gemma4Config, so we
-        # accept any PretrainedConfig here.
+        # accept any PreTrainedConfig here.
         return self.ctx.get_hf_config()
 
     def get_supported_mm_limits(self) -> Mapping[str, int | None]:

vllm/model_executor/models/eagle2_5_vl.py

@@ -8,7 +8,7 @@ from typing import Annotated, Literal, TypeAlias
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import VllmConfig
 from vllm.model_executor.layers.quantization import QuantizationConfig
@@ -193,7 +193,7 @@ class Eagle2_5_VLForConditionalGeneration(
 
     def _init_vision_model(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         prefix: str,
     ):
@@ -220,7 +220,7 @@ class Eagle2_5_VLForConditionalGeneration(
             prefix=prefix,
         )
 
-    def _init_mlp1(self, config: PretrainedConfig) -> nn.Module:
+    def _init_mlp1(self, config: PreTrainedConfig) -> nn.Module:
         """Initialize MLP projection layer."""
         vit_hidden_size = config.vision_config.hidden_size
         llm_hidden_size = config.text_config.hidden_size

vllm/model_executor/models/ernie45_moe.py

@@ -29,7 +29,7 @@ from typing import Any
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig, get_current_vllm_config
@@ -119,7 +119,7 @@ class Ernie4_5_MoeMLP(nn.Module):
 class Ernie4_5_MoeMoE(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
         enable_eplb: bool = False,
@@ -305,7 +305,7 @@ class Ernie4_5_MoeAttention(nn.Module):
 class Ernie4_5_MoeDecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",

vllm/model_executor/models/ernie45_vl.py

@@ -881,7 +881,7 @@ class Ernie4_5_VLProcessingInfo(BaseProcessingInfo):
         return self.ctx.model_config.hf_config
 
     def get_hf_processor(self, **kwargs: object):
-        return self.ctx.get_hf_processor(use_fast=True, **kwargs)
+        return self.ctx.get_hf_processor(**kwargs)
 
     def get_image_processor(self, **kwargs: object):
         return self.get_hf_processor(**kwargs).image_processor

vllm/model_executor/models/ernie45_vl_moe.py

@@ -29,7 +29,7 @@ from typing import Any
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 # from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -192,7 +192,7 @@ class Ernie4_5_VLMoeAttention(nn.Module):
 class Ernie4_5_VLMoeMoE(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -385,7 +385,7 @@ class Ernie4_5_VLMoeMoE(nn.Module):
 class Ernie4_5_VLMoeDecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",

vllm/model_executor/models/exaone.py

@@ -30,7 +30,7 @@ from itertools import islice
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -104,7 +104,7 @@ class ExaoneGatedMLP(nn.Module):
 class ExaoneAttention(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         hidden_size: int,
         num_heads: int,
         num_kv_heads: int,
@@ -191,7 +191,7 @@ class ExaoneAttention(nn.Module):
 class ExaoneBlockAttention(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         hidden_size: int,
         num_heads: int,
         num_kv_heads: int,
@@ -228,7 +228,7 @@ class ExaoneBlockAttention(nn.Module):
 class ExaoneDecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",

vllm/model_executor/models/exaone4_5.py

@@ -311,7 +311,6 @@ class Exaone4_5_ProcessingInfo(Qwen2VLProcessingInfo):
     def get_hf_processor(self, **kwargs: object) -> Exaone4_5_Processor:
         return self.ctx.get_hf_processor(
             Exaone4_5_Processor,
-            use_fast=kwargs.pop("use_fast", True),
             **kwargs,
         )
 

vllm/model_executor/models/exaone_moe.py

@@ -20,7 +20,7 @@ from itertools import islice
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig, get_current_vllm_config
@@ -65,7 +65,7 @@ from .utils import (
 class ExaoneMoe(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         swiglu_limit: float | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
@@ -289,7 +289,7 @@ class ExaoneMoeAttention(nn.Module):
 class ExaoneMoeDecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         is_mtp: bool = False,

vllm/model_executor/models/gemma3n_mm.py

@@ -15,7 +15,7 @@ from transformers.models.gemma3n import (
     Gemma3nTextConfig,
     Gemma3nVisionConfig,
 )
-from transformers.models.siglip import SiglipImageProcessorFast
+from transformers.models.siglip import SiglipImageProcessor
 
 from vllm.config import ModelConfig, SpeechToTextConfig, VllmConfig
 from vllm.config.multimodal import MultiModalDummyOptions
@@ -239,7 +239,7 @@ class Gemma3nDummyInputsBuilder(BaseDummyInputsBuilder[Gemma3nProcessingInfo]):
             processor.feature_extractor
         )
         audio_len = audio_feature_extractor.fft_length
-        image_processor: SiglipImageProcessorFast = processor.image_processor
+        image_processor: SiglipImageProcessor = processor.image_processor
         img_width = image_processor.size.get("width", 224)
         img_height = image_processor.size.get("height", 224)
 

vllm/model_executor/models/glm4_moe_lite_mtp.py

@@ -28,7 +28,7 @@ from collections.abc import Callable, Iterable
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import VllmConfig
 from vllm.model_executor.layers.fused_moe import (
@@ -68,7 +68,7 @@ from .utils import get_spec_layer_idx_from_weight_name, maybe_prefix
 class SharedHead(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         quant_config: QuantizationConfig | None = None,
     ) -> None:

vllm/model_executor/models/glm4_moe_mtp.py

@@ -29,7 +29,7 @@ from collections.abc import Callable, Iterable
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import CacheConfig, ParallelConfig, VllmConfig
 from vllm.model_executor.layers.fused_moe import (
@@ -60,7 +60,7 @@ from .utils import get_spec_layer_idx_from_weight_name, maybe_prefix
 class SharedHead(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         quant_config: QuantizationConfig | None = None,
     ) -> None:
@@ -80,7 +80,7 @@ class SharedHead(nn.Module):
 class Glm4MoeMultiTokenPredictorLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,

vllm/model_executor/models/granite.py

@@ -36,7 +36,7 @@ from itertools import islice
 import torch
 from torch import nn
 from transformers import GraniteConfig
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -72,7 +72,7 @@ from .utils import (
 
 
 def granite_layer_attn_params(
-    config: PretrainedConfig, layer_idx: int
+    config: PreTrainedConfig, layer_idx: int
 ) -> tuple[int | None, float, bool]:
     """Resolve one layer's sliding window, RoPE base and sink usage.
 

vllm/model_executor/models/granite_speech.py

@@ -31,7 +31,7 @@ from typing import Annotated
 import torch
 import torch.nn.functional as F
 from torch import nn
-from transformers import BatchFeature, PretrainedConfig
+from transformers import BatchFeature, PreTrainedConfig
 
 from vllm.config import CacheConfig, ModelConfig, SpeechToTextConfig, VllmConfig
 from vllm.config.multimodal import MultiModalDummyOptions
@@ -229,7 +229,7 @@ class GraniteSpeechDummyInputsBuilder(
 class GraniteSpeechEncoderProjector(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
@@ -287,7 +287,7 @@ class GraniteSpeechConformerFeedForward(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -323,7 +323,7 @@ class GraniteSpeechConformerAttention(nn.Module):
     for more details.
     """
 
-    def __init__(self, config: PretrainedConfig, prefix: str = ""):
+    def __init__(self, config: PreTrainedConfig, prefix: str = ""):
         super().__init__()
 
         inner_dim = config.dim_head * config.num_heads
@@ -429,7 +429,7 @@ class GraniteSpeechConformerConvModule(nn.Module):
     convolutional layers.
     """
 
-    def __init__(self, config: PretrainedConfig, prefix: str = ""):
+    def __init__(self, config: PreTrainedConfig, prefix: str = ""):
         super().__init__()
         inner_dim = config.hidden_dim * config.conv_expansion_factor
 
@@ -460,7 +460,7 @@ class GraniteSpeechConformerBlock(nn.Module):
     """Conformer block, consisting largely of linear layers,
     attention, and convolutional layers."""
 
-    def __init__(self, config: PretrainedConfig, prefix: str = ""):
+    def __init__(self, config: PreTrainedConfig, prefix: str = ""):
         super().__init__()
         self.ff1 = GraniteSpeechConformerFeedForward(config, prefix=f"{prefix}.ff1")
         self.attn = GraniteSpeechConformerAttention(config, prefix=f"{prefix}.attn")
@@ -486,7 +486,7 @@ class GraniteSpeechCTCEncoder(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         quant_config: QuantizationConfig | None = None,
     ):
@@ -622,7 +622,7 @@ class GraniteSpeechForConditionalGeneration(
 
     def _build_encoder(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         prefix: str,
     ) -> "GraniteSpeechCTCEncoder":

vllm/model_executor/models/granite_speech_plus.py

@@ -3,7 +3,7 @@
 """Inference-only IBM Granite Speech Plus model."""
 
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.model_executor.layers.quantization import QuantizationConfig
 from vllm.multimodal import MULTIMODAL_REGISTRY
@@ -68,7 +68,7 @@ class GraniteSpeechPlusForConditionalGeneration(GraniteSpeechForConditionalGener
 
     def _build_encoder(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         prefix: str,
     ) -> GraniteSpeechCTCEncoder:

vllm/model_executor/models/granitemoe.py

@@ -29,7 +29,7 @@ from itertools import islice
 
 import torch
 from torch import nn
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -141,7 +141,7 @@ class GraniteMoeMoE(nn.Module):
 class GraniteMoeAttention(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         hidden_size: int,
         num_heads: int,
         num_kv_heads: int,

vllm/model_executor/models/h2ovl.py

@@ -10,7 +10,7 @@
 # --------------------------------------------------------
 
 import torch
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.model_executor.layers.quantization import QuantizationConfig
 from vllm.multimodal import MULTIMODAL_REGISTRY
@@ -158,7 +158,7 @@ class H2OVLMultiModalProcessor(BaseInternVLMultiModalProcessor[H2OVLProcessingIn
 class H2OVLChatModel(InternVLChatModel):
     def _init_vision_model(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         *,
         prefix: str,

vllm/model_executor/models/hrm_text.py

@@ -25,7 +25,7 @@ from typing import Literal
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -122,7 +122,7 @@ class HrmTextAttention(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         layer_idx_in_stack: int,
         stack_kind: Literal["L", "H"],
         cache_config: CacheConfig | None = None,
@@ -245,7 +245,7 @@ class HrmTextAttention(nn.Module):
 class HrmTextDecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         layer_idx_in_stack: int,
         stack_kind: Literal["L", "H"],
         cache_config: CacheConfig | None = None,
@@ -310,7 +310,7 @@ class HrmTextStack(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         stack_kind: Literal["L", "H"],
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,

vllm/model_executor/models/hy_v3.py

@@ -31,7 +31,7 @@ from typing import Any
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig, get_current_vllm_config
@@ -220,7 +220,7 @@ class HYV3MoEFused(nn.Module):
 class HYV3Attention(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         hidden_size: int,
         num_heads: int,
         num_kv_heads: int,
@@ -365,7 +365,7 @@ class HYV3Attention(nn.Module):
 class HYV3DecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",

vllm/model_executor/models/hy_v3_mtp.py

@@ -29,7 +29,7 @@ from collections.abc import Callable, Iterable
 import regex as re
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import CacheConfig, ModelConfig, VllmConfig
 from vllm.model_executor.layers.fused_moe import (
@@ -59,7 +59,7 @@ from .utils import (
 )
 
 
-def _is_moe(config: PretrainedConfig) -> bool:
+def _is_moe(config: PreTrainedConfig) -> bool:
     return bool(
         getattr(config, "num_experts", None)
         and (
@@ -69,7 +69,7 @@ def _is_moe(config: PretrainedConfig) -> bool:
     )
 
 
-def _get_cla_factor(config: PretrainedConfig) -> int:
+def _get_cla_factor(config: PreTrainedConfig) -> int:
     if not getattr(config, "use_cla", False):
         return 1
     return getattr(config, "cla_share_factor", 1)
@@ -78,7 +78,7 @@ def _get_cla_factor(config: PretrainedConfig) -> int:
 class HYV3SharedHead(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
     ) -> None:
         super().__init__()
@@ -93,7 +93,7 @@ class HYV3SharedHead(nn.Module):
 class HYV3MultiTokenPredictorLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         model_config: ModelConfig,
         cache_config: CacheConfig | None = None,

vllm/model_executor/models/intern_vit.py

@@ -13,7 +13,7 @@ from functools import partial
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import (
     should_torch_compile_mm_encoder,
@@ -47,7 +47,7 @@ NORM2FN = {
 
 
 class InternVisionEmbeddings(nn.Module):
-    def __init__(self, config: PretrainedConfig):
+    def __init__(self, config: PreTrainedConfig):
         super().__init__()
         self.config = config
         self.embed_dim = config.hidden_size
@@ -119,7 +119,7 @@ class InternParallelAttention(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         *,
         num_dummy_heads: int = 0,
@@ -222,7 +222,7 @@ class InternParallelAttention(nn.Module):
 class InternMLP(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ) -> None:
@@ -264,7 +264,7 @@ class InternMLP(nn.Module):
 class InternVisionEncoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         *,
         num_dummy_heads: int = 0,
@@ -297,7 +297,7 @@ class InternVisionEncoderLayer(nn.Module):
 
     def _init_attn(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         *,
         num_dummy_heads: int,
@@ -324,7 +324,7 @@ class InternVisionEncoderLayer(nn.Module):
 class InternVisionEncoder(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         *,
         num_hidden_layers_override: int | None = None,
@@ -369,7 +369,7 @@ class InternVisionModel(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         *,
         num_hidden_layers_override: int | None = None,

vllm/model_executor/models/internlm2.py

@@ -8,7 +8,7 @@ from typing import Any
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -195,7 +195,7 @@ class InternLM2Attention(nn.Module):
 class InternLMDecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",

vllm/model_executor/models/interns1.py

@@ -12,10 +12,10 @@ from typing import Annotated, Literal, TypeAlias, TypedDict
 import regex as re
 import torch
 import torch.nn as nn
-from transformers import BatchFeature, InternVLProcessor, PretrainedConfig
+from transformers import BatchFeature, InternVLProcessor, PreTrainedConfig
 from transformers.activations import ACT2FN
-from transformers.models.got_ocr2.image_processing_got_ocr2_fast import (
-    GotOcr2ImageProcessorFast,
+from transformers.models.got_ocr2.image_processing_got_ocr2 import (
+    GotOcr2ImageProcessor,
 )
 from transformers.models.internvl.video_processing_internvl import (
     InternVLVideoProcessor,
@@ -202,7 +202,7 @@ class InternS1ProcessingInfo(BaseProcessingInfo):
         processor: InternVLProcessor,
         mm_kwargs: Mapping[str, object],
     ) -> int:
-        image_processor: GotOcr2ImageProcessorFast = processor.image_processor
+        image_processor: GotOcr2ImageProcessor = processor.image_processor
 
         num_image_patches = image_processor.get_number_of_image_patches(
             image_height,
@@ -612,7 +612,7 @@ class InternS1ForConditionalGeneration(
 
     def _init_vision_model(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         *,
         prefix: str,
@@ -625,7 +625,7 @@ class InternS1ForConditionalGeneration(
             prefix=prefix,
         )
 
-    def _init_mlp1(self, config: PretrainedConfig) -> nn.Module:
+    def _init_mlp1(self, config: PreTrainedConfig) -> nn.Module:
         return InternS1MultiModalProjector(config)
 
     def pixel_shuffle(self, x, scale_factor=0.5):

vllm/model_executor/models/interns1_pro.py

@@ -30,7 +30,7 @@ from typing import Any, ClassVar
 
 import torch
 from torch import nn
-from transformers import AutoProcessor, PretrainedConfig
+from transformers import AutoProcessor, PreTrainedConfig
 
 from vllm.config import CacheConfig, VllmConfig
 from vllm.distributed import (
@@ -563,7 +563,7 @@ class InternS1ProForConditionalGeneration(
 
     def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
         super(Qwen3VLForConditionalGeneration, self).__init__()
-        config: PretrainedConfig = vllm_config.model_config.hf_config
+        config: PreTrainedConfig = vllm_config.model_config.hf_config
         multimodal_config = vllm_config.model_config.get_multimodal_config()
 
         self.config = config

vllm/model_executor/models/interns1_vit.py

@@ -11,7 +11,7 @@ from collections.abc import Iterable
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 from transformers.utils import torch_int
 
 from vllm.model_executor.layers.activation import get_act_fn
@@ -65,7 +65,7 @@ class InternS1VisionPatchEmbeddings(nn.Module):
 
 
 class InternS1VisionEmbeddings(nn.Module):
-    def __init__(self, config: PretrainedConfig):
+    def __init__(self, config: PreTrainedConfig):
         super().__init__()
         self.config = config
         self.cls_token = nn.Parameter(torch.zeros(1, 1, config.hidden_size))
@@ -166,7 +166,7 @@ class InternSdpaAttention(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         *,
         num_dummy_heads: int = 0,
         prefix: str = "",
@@ -242,7 +242,7 @@ class InternSdpaAttention(nn.Module):
 class InternS1VisionMLP(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ) -> None:
@@ -276,7 +276,7 @@ class InternS1VisionMLP(nn.Module):
 class InternS1VisionLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         *,
         num_dummy_heads: int = 0,
@@ -311,7 +311,7 @@ class InternS1VisionLayer(nn.Module):
 
     def _init_attn(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         *,
         num_dummy_heads: int,
@@ -343,7 +343,7 @@ class InternS1VisionLayer(nn.Module):
 class InternS1VisionEncoder(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         *,
         num_hidden_layers_override: int | None = None,
@@ -382,7 +382,7 @@ class InternS1VisionEncoder(nn.Module):
 class InternS1VisionModel(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         *,
         num_hidden_layers_override: int | None = None,

vllm/model_executor/models/internvl.py

@@ -14,7 +14,7 @@ from typing import Annotated, Any, Literal, TypeAlias, TypedDict, TypeVar
 
 import torch
 import torch.nn as nn
-from transformers import BatchFeature, PretrainedConfig
+from transformers import BatchFeature, PreTrainedConfig
 
 from vllm.config import VllmConfig
 from vllm.config.multimodal import MultiModalDummyOptions
@@ -629,7 +629,7 @@ class InternVLChatModel(
         )
 
     def _patch_quant_config(
-        self, config: PretrainedConfig, quant_config: QuantizationConfig | None
+        self, config: PreTrainedConfig, quant_config: QuantizationConfig | None
     ):
         # the awq models from OpenGVLab missing `modules_to_not_convert`
         # patch the quant_config to add `modules_to_not_convert` back
@@ -643,7 +643,7 @@ class InternVLChatModel(
 
     def _init_vision_model(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None,
         *,
         prefix: str,
@@ -663,7 +663,7 @@ class InternVLChatModel(
             prefix=prefix,
         )
 
-    def _init_mlp1(self, config: PretrainedConfig) -> nn.Module:
+    def _init_mlp1(self, config: PreTrainedConfig) -> nn.Module:
         vit_hidden_size = config.vision_config.hidden_size
         llm_hidden_size = config.text_config.hidden_size
 

vllm/model_executor/models/iquest_loopcoder.py

@@ -22,7 +22,7 @@ from typing import Any
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -60,7 +60,7 @@ from .utils import (
 class LoopCoderAttention(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         hidden_size: int,
         num_heads: int,
         num_kv_heads: int,
@@ -210,7 +210,7 @@ class LoopCoderAttention(nn.Module):
 class LoopCoderDecoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         cache_config: CacheConfig | None = None,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",

vllm/model_executor/models/keye.py

@@ -10,7 +10,7 @@ import numpy as np
 import torch
 import torch.nn as nn
 from einops import rearrange
-from transformers import BaseImageProcessor, PretrainedConfig
+from transformers import BaseImageProcessor, PreTrainedConfig
 from transformers.activations import GELUActivation
 from transformers.feature_extraction_utils import BatchFeature
 from transformers.modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling
@@ -191,7 +191,7 @@ KeyeVideoInputs: TypeAlias = KeyeVideoPixelInputs | KeyeVideoEmbeddingInputs
 
 
 class KeyeVisionEmbeddings(nn.Module):
-    def __init__(self, config: PretrainedConfig):
+    def __init__(self, config: PreTrainedConfig):
         super().__init__()
         self.config = config
         self.embed_dim = config.hidden_size
@@ -349,7 +349,7 @@ class KeyeSiglipAttention(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -487,7 +487,7 @@ class SigLIPRotaryEmbedding(nn.Module):
 class KeyeSiglipEncoderLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -539,7 +539,7 @@ class KeyeSiglipEncoderLayer(nn.Module):
 class KeyeSiglipEncoder(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -634,7 +634,7 @@ class KeyeSiglipEncoder(nn.Module):
 class KeyeSiglipVisionTransformer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -710,7 +710,7 @@ class KeyeSiglipVisionTransformer(nn.Module):
 
 
 class KeyeSiglipVisionModel(nn.Module):
-    config_class = PretrainedConfig
+    config_class = PreTrainedConfig
     main_input_name = "pixel_values"
 
     hf_to_vllm_mapper = WeightsMapper(
@@ -724,7 +724,7 @@ class KeyeSiglipVisionModel(nn.Module):
 
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -787,8 +787,8 @@ class KeyeSiglipVisionModel(nn.Module):
 class Projector(nn.Module):
     def __init__(
         self,
-        text_config: PretrainedConfig,
-        vision_config: PretrainedConfig,
+        text_config: PreTrainedConfig,
+        vision_config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -1232,7 +1232,7 @@ class BaseKeyeModule(nn.Module, SupportsMultiModal):
 
     def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
         super().__init__()
-        config: PretrainedConfig = vllm_config.model_config.hf_config
+        config: PreTrainedConfig = vllm_config.model_config.hf_config
         quant_config = vllm_config.quant_config
 
         self.config = config
@@ -1264,8 +1264,8 @@ class BaseKeyeModule(nn.Module, SupportsMultiModal):
     @abstractmethod
     def _build_projector(
         self,
-        text_config: PretrainedConfig,
-        vision_config: PretrainedConfig,
+        text_config: PreTrainedConfig,
+        vision_config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ) -> nn.Module:
@@ -1511,8 +1511,8 @@ class KeyeForConditionalGeneration(
 ):
     def _build_projector(
         self,
-        text_config: PretrainedConfig,
-        vision_config: PretrainedConfig,
+        text_config: PreTrainedConfig,
+        vision_config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ) -> nn.Module:

vllm/model_executor/models/keye_vl1_5.py

@@ -9,7 +9,7 @@ import numpy as np
 import torch
 import torch.nn as nn
 from einops import rearrange
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 from transformers.activations import GELUActivation
 from transformers.feature_extraction_utils import BatchFeature
 
@@ -197,8 +197,8 @@ KeyeVL1_5VideoInputs: TypeAlias = (
 class KeyeVL1_5Projector(nn.Module):
     def __init__(
         self,
-        text_config: PretrainedConfig,
-        vision_config: PretrainedConfig,
+        text_config: PreTrainedConfig,
+        vision_config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ):
@@ -509,15 +509,15 @@ class KeyeVL1_5ForConditionalGeneration(
 ):
     def _build_projector(
         self,
-        text_config: PretrainedConfig,
-        vision_config: PretrainedConfig,
+        text_config: PreTrainedConfig,
+        vision_config: PreTrainedConfig,
         quant_config: QuantizationConfig | None = None,
         prefix: str = "",
     ) -> nn.Module:
         return KeyeVL1_5Projector(text_config, vision_config, quant_config, prefix)
 
     def __init__(self, *, vllm_config: VllmConfig, prefix: str = ""):
-        config: PretrainedConfig = vllm_config.model_config.hf_config
+        config: PreTrainedConfig = vllm_config.model_config.hf_config
         self.merge_size = config.vision_config.spatial_merge_size
         super().__init__(vllm_config=vllm_config, prefix=prefix)
 

vllm/model_executor/models/lfm2_siglip2.py

@@ -334,7 +334,7 @@ class Siglip2Encoder(nn.Module):
     self attention layers. Each layer is a [`Siglip2EncoderLayer`].
 
     Args:
-        config: PretrainedConfig
+        config: PreTrainedConfig
 
     """
 

vllm/model_executor/models/lfm2_vl.py

@@ -13,8 +13,8 @@ from transformers import BatchFeature
 from transformers.activations import ACT2FN
 from transformers.models.lfm2_vl import Lfm2VlProcessor
 from transformers.models.lfm2_vl.configuration_lfm2_vl import Lfm2VlConfig
-from transformers.models.lfm2_vl.image_processing_lfm2_vl_fast import (
-    Lfm2VlImageProcessorFast,
+from transformers.models.lfm2_vl.image_processing_lfm2_vl import (
+    Lfm2VlImageProcessor,
     find_closest_aspect_ratio,
     round_by_factor,
 )
@@ -104,7 +104,7 @@ class Lfm2VLProcessingInfo(BaseProcessingInfo):
     def get_hf_processor(self, **kwargs):
         return self.ctx.get_hf_processor(Lfm2VlProcessor, **kwargs)
 
-    def get_image_processor(self, **kwargs: object) -> Lfm2VlImageProcessorFast:
+    def get_image_processor(self, **kwargs: object) -> Lfm2VlImageProcessor:
         return self.get_hf_processor(**kwargs).image_processor
 
     def get_default_tok_params(self) -> TokenizeParams:
@@ -213,7 +213,7 @@ class Lfm2VLProcessingInfo(BaseProcessingInfo):
         processor: Lfm2VlProcessor,
         mm_kwargs: Mapping[str, object],
     ) -> tuple[int, int, int]:
-        image_processor: Lfm2VlImageProcessorFast = processor.image_processor
+        image_processor: Lfm2VlImageProcessor = processor.image_processor
 
         mm_kwargs = self.ctx.get_merged_mm_kwargs(mm_kwargs)
         downsample_factor = mm_kwargs.get(
@@ -336,7 +336,7 @@ class Lfm2VLProcessingInfo(BaseProcessingInfo):
         processor: Lfm2VlProcessor,
         mm_kwargs: Mapping[str, object],
     ) -> tuple[int, int]:
-        image_processor: Lfm2VlImageProcessorFast = processor.image_processor
+        image_processor: Lfm2VlImageProcessor = processor.image_processor
 
         mm_kwargs = self.ctx.get_merged_mm_kwargs(mm_kwargs)
         downsample_factor = mm_kwargs.get(

vllm/model_executor/models/llava.py

@@ -12,7 +12,7 @@ from transformers import (
     CLIPVisionConfig,
     LlavaConfig,
     PixtralVisionConfig,
-    PretrainedConfig,
+    PreTrainedConfig,
     SiglipVisionConfig,
 )
 from transformers.models.llava import LlavaProcessor
@@ -156,7 +156,7 @@ class LlavaMultiModalProjector(nn.Module):
 
 
 class LlavaLikeConfig(Protocol):
-    vision_config: PretrainedConfig
+    vision_config: PreTrainedConfig
     image_token_index: int
     vision_feature_select_strategy: str
     vision_feature_layer: int | list[int]

vllm/model_executor/models/llava_onevision2.py

@@ -1307,7 +1307,6 @@ class LlavaOnevision2ProcessingInfo(BaseProcessingInfo):
         # ``_merge_mm_kwargs`` restricts caller ``mm_processor_kwargs`` to known
         # processor args and wraps values as hashable for the lru_cache.
         merged = _merge_mm_kwargs(model_config, AutoProcessor, **kwargs)
-        merged.setdefault("use_fast", True)
         return _load_ov2_processor(
             model_config.model,
             model_config.revision,

vllm/model_executor/models/longcat_flash.py

@@ -39,7 +39,7 @@ from itertools import islice
 
 import torch
 from torch import nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.compilation.decorators import support_torch_compile
 from vllm.config import CacheConfig, VllmConfig
@@ -80,7 +80,7 @@ from .utils import (
 logger = init_logger(__name__)
 
 
-class FlashConfig(PretrainedConfig):
+class FlashConfig(PreTrainedConfig):
     """Flash model configuration."""
 
     moe_intermediate_size: int

vllm/model_executor/models/longcat_flash_mtp.py

@@ -7,7 +7,7 @@ from collections.abc import Iterable
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import VllmConfig
 from vllm.model_executor.layers.layernorm import RMSNorm
@@ -30,7 +30,7 @@ from .utils import maybe_prefix
 class LongCatMultiTokenPredictorLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         vllm_config: VllmConfig,
         quant_config: QuantizationConfig | None = None,
@@ -353,7 +353,7 @@ class LongCatFlashMTP(nn.Module):
         return name
 
     def get_spec_layer_idx_from_weight_name(
-        self, config: PretrainedConfig, weight_name: str
+        self, config: PreTrainedConfig, weight_name: str
     ) -> int | None:
         if "model.mtp" in weight_name:
             return config.num_hidden_layers * 2

vllm/model_executor/models/mimo_audio.py

@@ -21,7 +21,7 @@ import torch.nn as nn
 import torch.nn.functional as F
 from einops import rearrange, repeat
 from transformers.activations import ACT2FN
-from transformers.configuration_utils import PretrainedConfig
+from transformers.configuration_utils import PreTrainedConfig
 from transformers.modeling_utils import PreTrainedModel
 from transformers.models.qwen2.configuration_qwen2 import Qwen2Config
 from transformers.models.qwen2.modeling_qwen2 import Qwen2Model
@@ -518,7 +518,7 @@ class ResidualVectorQuantizer(nn.Module):
 # ---------------------------------------------------------------------------
 
 
-class MiMoAudioTokenizerConfig(PretrainedConfig):
+class MiMoAudioTokenizerConfig(PreTrainedConfig):
     model_type = "mimo_audio_tokenizer"
 
     def __init__(

vllm/model_executor/models/mimo_mtp.py

@@ -24,7 +24,7 @@ from collections.abc import Iterable
 
 import torch
 import torch.nn as nn
-from transformers import PretrainedConfig
+from transformers import PreTrainedConfig
 
 from vllm.config import CacheConfig, ModelConfig, VllmConfig
 from vllm.model_executor.layers.layernorm import RMSNorm
@@ -43,7 +43,7 @@ from .utils import AutoWeightsLoader, WeightsMapper, maybe_prefix
 class MiMoMultiTokenPredictorLayer(nn.Module):
     def __init__(
         self,
-        config: PretrainedConfig,
+        config: PreTrainedConfig,
         prefix: str,
         model_config: ModelConfig,
         cache_config: CacheConfig | None = None,