[Frontend] Use new Renderer for Completions and Tokenize API

vllm/entrypoints/openai/chat_completion/protocol.py

@@ -13,12 +13,13 @@
     ChatCompletionAudio as OpenAIChatCompletionAudio,
 )
 from openai.types.chat.chat_completion_message import Annotation as OpenAIAnnotation
-from pydantic import (
-    Field,
-    model_validator,
-)
+from pydantic import Field, model_validator
 
-from vllm.entrypoints.chat_utils import ChatCompletionMessageParam
+from vllm.config import ModelConfig
+from vllm.entrypoints.chat_utils import (
+    ChatCompletionMessageParam,
+    ChatTemplateContentFormatOption,
+)
 from vllm.entrypoints.openai.engine.protocol import (
     AnyResponseFormat,
     DeltaMessage,
@@ -36,6 +37,7 @@
 from vllm.exceptions import VLLMValidationError
 from vllm.logger import init_logger
 from vllm.logprobs import Logprob
+from vllm.renderers import ChatParserParams, TokenizationParams
 from vllm.sampling_params import (
     BeamSearchParams,
     RequestOutputKind,
@@ -356,6 +358,42 @@ class ChatCompletionRequest(OpenAIBaseModel):
 
     # --8<-- [end:chat-completion-extra-params]
 
+    def build_chat_params(
+        self,
+        default_template: str | None,
+        default_template_content_format: ChatTemplateContentFormatOption,
+    ) -> ChatParserParams:
+        return ChatParserParams(
+            chat_template=self.chat_template or default_template,
+            chat_template_content_format=default_template_content_format,
+            chat_template_kwargs=dict(
+                add_generation_prompt=self.add_generation_prompt,
+                continue_final_message=self.continue_final_message,
+                documents=self.documents,
+                reasoning_effort=self.reasoning_effort,
+            ),
+        ).with_defaults(self.chat_template_kwargs)
+
+    def build_tok_params(self, model_config: ModelConfig) -> TokenizationParams:
+        max_tokens = self.max_completion_tokens
+
+        # Validate max_tokens before using it
+        if max_tokens is not None and max_tokens > model_config.max_model_len:
+            raise VLLMValidationError(
+                f"'max_tokens' ({max_tokens}) cannot be greater than the "
+                f"model's maximum context length ({model_config.max_model_len}).",
+                parameter="max_tokens",
+                value=max_tokens,
+            )
+
+        return TokenizationParams.from_config(
+            model_config,
+            max_length=model_config.max_model_len - (max_tokens or 0),
+            truncate_prompt_tokens=self.truncate_prompt_tokens,
+            add_special_tokens=self.add_special_tokens,
+            needs_detokenization=bool(self.echo and not self.return_token_ids),
+        )
+
     # Default sampling parameters for chat completion requests
     _DEFAULT_SAMPLING_PARAMS: dict = {
         "repetition_penalty": 1.0,

vllm/entrypoints/openai/chat_completion/serving.py

@@ -66,7 +66,7 @@
 )
 from vllm.entrypoints.openai.utils import maybe_filter_parallel_tool_calls
 from vllm.entrypoints.utils import get_max_tokens, should_include_usage
-from vllm.inputs.data import TokensPrompt
+from vllm.inputs.data import EmbedsPrompt, TokensPrompt
 from vllm.logger import init_logger
 from vllm.logprobs import Logprob
 from vllm.outputs import CompletionOutput, RequestOutput
@@ -186,8 +186,6 @@ async def warmup(self) -> None:
         start_time = time.perf_counter()
 
         try:
-            renderer = self.engine_client.renderer
-
             # Create a minimal dummy request
             dummy_request = ChatCompletionRequest(
                 messages=[{"role": "user", "content": "warmup"}],
@@ -202,18 +200,10 @@ async def warmup(self) -> None:
             # 3. Tokenizer initialization for chat
             await self._preprocess_chat(
                 dummy_request,
-                renderer,
                 dummy_request.messages,
-                chat_template=self.chat_template,
-                chat_template_content_format=self.chat_template_content_format,
-                add_generation_prompt=True,
-                continue_final_message=False,
-                tool_dicts=None,
-                documents=None,
-                chat_template_kwargs=None,
-                default_chat_template_kwargs=self.default_chat_template_kwargs,
-                tool_parser=None,
-                add_special_tokens=False,
+                default_template=self.chat_template,
+                default_template_content_format=self.chat_template_content_format,
+                default_template_kwargs=self.default_chat_template_kwargs,
             )
 
             elapsed = (time.perf_counter() - start_time) * 1000
@@ -226,7 +216,13 @@ async def warmup(self) -> None:
     async def render_chat_request(
         self,
         request: ChatCompletionRequest,
-    ) -> tuple[list[ConversationMessage], list[Any]] | ErrorResponse:
+    ) -> (
+        tuple[
+            list[ConversationMessage],
+            list[TokensPrompt | EmbedsPrompt],
+        ]
+        | ErrorResponse
+    ):
         """
         render chat request by validating and preprocessing inputs.
 
@@ -303,23 +299,14 @@ async def render_chat_request(
                 if error_check_ret is not None:
                     return error_check_ret
 
-                chat_template_kwargs = request.chat_template_kwargs or {}
-                chat_template_kwargs.update(reasoning_effort=request.reasoning_effort)
-
                 conversation, engine_prompts = await self._preprocess_chat(
                     request,
-                    renderer,
                     request.messages,
-                    chat_template=request.chat_template or self.chat_template,
-                    chat_template_content_format=self.chat_template_content_format,
-                    add_generation_prompt=request.add_generation_prompt,
-                    continue_final_message=request.continue_final_message,
+                    default_template=self.chat_template,
+                    default_template_content_format=self.chat_template_content_format,
+                    default_template_kwargs=self.default_chat_template_kwargs,
                     tool_dicts=tool_dicts,
-                    documents=request.documents,
-                    chat_template_kwargs=chat_template_kwargs,
-                    default_chat_template_kwargs=self.default_chat_template_kwargs,
                     tool_parser=tool_parser,
-                    add_special_tokens=request.add_special_tokens,
                 )
             else:
                 # For GPT-OSS.
@@ -376,7 +363,10 @@ async def create_chat_completion(
         generators: list[AsyncGenerator[RequestOutput, None]] = []
         try:
             for i, engine_prompt in enumerate(engine_prompts):
-                prompt_text, _, _ = self._get_prompt_components(engine_prompt)
+                prompt_text, prompt_ids, prompt_embeds = self._get_prompt_components(
+                    engine_prompt
+                )
+
                 # If we are creating sub requests for multiple prompts, ensure that they
                 # have unique request ids.
                 sub_request_id = (
@@ -386,10 +376,17 @@ async def create_chat_completion(
                 if self.default_sampling_params is None:
                     self.default_sampling_params = {}
 
+                if prompt_ids is not None:
+                    input_length = len(prompt_ids)
+                elif prompt_embeds is not None:
+                    input_length = len(prompt_embeds)
+                else:
+                    raise AssertionError(engine_prompt.keys())
+
                 max_tokens = get_max_tokens(
                     max_model_len=self.max_model_len,
                     request=request,
-                    input_length=len(engine_prompt["prompt_token_ids"]),
+                    input_length=input_length,
                     default_sampling_params=self.default_sampling_params,
                 )
 

vllm/entrypoints/openai/completion/protocol.py

@@ -9,11 +9,9 @@
 from typing import Annotated, Any, Literal
 
 import torch
-from pydantic import (
-    Field,
-    model_validator,
-)
+from pydantic import Field, model_validator
 
+from vllm.config import ModelConfig
 from vllm.entrypoints.openai.engine.protocol import (
     AnyResponseFormat,
     LegacyStructuralTagResponseFormat,
@@ -27,6 +25,7 @@
 from vllm.exceptions import VLLMValidationError
 from vllm.logger import init_logger
 from vllm.logprobs import Logprob
+from vllm.renderers import TokenizationParams
 from vllm.sampling_params import (
     BeamSearchParams,
     RequestOutputKind,
@@ -178,6 +177,26 @@ class CompletionRequest(OpenAIBaseModel):
 
     # --8<-- [end:completion-extra-params]
 
+    def build_tok_params(self, model_config: ModelConfig) -> TokenizationParams:
+        max_tokens = self.max_tokens
+
+        # Validate max_tokens before using it
+        if max_tokens is not None and max_tokens > model_config.max_model_len:
+            raise VLLMValidationError(
+                f"'max_tokens' ({max_tokens}) cannot be greater than the "
+                f"model's maximum context length ({model_config.max_model_len}).",
+                parameter="max_tokens",
+                value=max_tokens,
+            )
+
+        return TokenizationParams.from_config(
+            model_config,
+            max_length=model_config.max_model_len - (max_tokens or 0),
+            truncate_prompt_tokens=self.truncate_prompt_tokens,
+            add_special_tokens=self.add_special_tokens,
+            needs_detokenization=bool(self.echo and not self.return_token_ids),
+        )
+
     # Default sampling parameters for completion requests
     _DEFAULT_SAMPLING_PARAMS: dict = {
         "repetition_penalty": 1.0,

vllm/entrypoints/openai/completion/serving.py

@@ -7,7 +7,6 @@
 from collections.abc import Sequence as GenericSequence
 from typing import cast
 
-import jinja2
 from fastapi import Request
 
 from vllm.engine.protocol import EngineClient
@@ -32,7 +31,6 @@
     clamp_prompt_logprobs,
 )
 from vllm.entrypoints.openai.models.serving import OpenAIServingModels
-from vllm.entrypoints.renderer import RenderConfig
 from vllm.entrypoints.utils import get_max_tokens, should_include_usage
 from vllm.exceptions import VLLMValidationError
 from vllm.inputs.data import EmbedsPrompt, TokensPrompt, is_embeds_prompt
@@ -116,18 +114,11 @@ async def render_completion_request(
                 "prompt_logprobs is not compatible with prompt embeds."
             )
 
-        try:
-            renderer = self._get_completion_renderer()
-            engine_prompts = await renderer.render_prompt_and_embeds(
-                prompt_or_prompts=request.prompt,
-                prompt_embeds=request.prompt_embeds,
-                config=self._build_render_config(request),
-            )
-        except (ValueError, TypeError, RuntimeError, jinja2.TemplateError) as e:
-            logger.exception("Error in preprocessing prompt inputs")
-            return self.create_error_response(e)
-
-        return engine_prompts
+        return await self._preprocess_completion(
+            request,
+            prompt_input=request.prompt,
+            prompt_embeds=request.prompt_embeds,
+        )
 
     async def create_completion(
         self,
@@ -222,10 +213,6 @@ async def create_completion(
                     else await self._get_trace_headers(raw_request.headers)
                 )
 
-                # Mypy inconsistently requires this second cast in different
-                # environments. It shouldn't be necessary (redundant from above)
-                # but pre-commit in CI fails without it.
-                engine_prompt = cast(EmbedsPrompt | TokensPrompt, engine_prompt)
                 if isinstance(sampling_params, BeamSearchParams):
                     generator = self.beam_search(
                         prompt=engine_prompt,
@@ -728,26 +715,3 @@ def _create_completion_logprobs(
             tokens=out_tokens,
             top_logprobs=out_top_logprobs,
         )
-
-    def _build_render_config(
-        self,
-        request: CompletionRequest,
-        max_input_length: int | None = None,
-    ) -> RenderConfig:
-        # Validate max_tokens before using it
-        if request.max_tokens is not None and request.max_tokens > self.max_model_len:
-            raise VLLMValidationError(
-                f"'max_tokens' ({request.max_tokens}) cannot be greater than "
-                f"the model's maximum context length ({self.max_model_len}).",
-                parameter="max_tokens",
-                value=request.max_tokens,
-            )
-
-        max_input_tokens_len = self.max_model_len - (request.max_tokens or 0)
-        return RenderConfig(
-            max_length=max_input_tokens_len,
-            truncate_prompt_tokens=request.truncate_prompt_tokens,
-            add_special_tokens=request.add_special_tokens,
-            cache_salt=request.cache_salt,
-            needs_detokenization=bool(request.echo and not request.return_token_ids),
-        )

vllm/entrypoints/openai/engine/protocol.py

@@ -7,7 +7,6 @@
 from typing import Any, ClassVar, Literal, TypeAlias
 
 import regex as re
-import torch
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -17,16 +16,12 @@
 
 from vllm.entrypoints.chat_utils import make_tool_call_id
 from vllm.logger import init_logger
-from vllm.sampling_params import (
-    SamplingParams,
-)
+from vllm.sampling_params import SamplingParams
 from vllm.utils import random_uuid
 from vllm.utils.import_utils import resolve_obj_by_qualname
 
 logger = init_logger(__name__)
 
-_LONG_INFO = torch.iinfo(torch.long)
-
 
 class OpenAIBaseModel(BaseModel):
     # OpenAI API does allow extra fields