feat(v1/engine): InputProcessor text path + SamplingParams PostInit close (M1.8 Task 2)

Port src/vllm/v1/engine/input_processor.{h,cpp} — the T0 text slice of
vllm/v1/engine/input_processor.py::process_inputs @ e24d1b24:
- _validate_params runs SamplingParams::PostInit()/Verify() (closes the M1.1
  deferred-__post_init__ carry: the InputProcessor is the constructing unit).
- tokenize the prompt via tok::Tokenizer::Encode -> prompt_token_ids.
- default max_tokens = max_model_len - len(prompt) when unset.
- update_from_generation_config: set sampling_params.eos_token_id + merge
  secondary eos ids into stop_token_ids (both gated on ignore_eos).
- build EngineCoreRequest(request_id, prompt_token_ids, sampling_params,
  arrival_time).
Deferred (marked stubs): dict/EngineInput/embeds/mm/pooling/LoRA/enc-dec,
update_from_tokenizer bad_words, _validate_model_inputs, request-id randomization.

Tests (tests/vllm/v1/test_input_processor.cpp, real qwen36 tokenizer fixture):
token-ids match Encode, PostInit normalization (temp clamp + greedy sub-params),
Verify throws on invalid params, max_tokens default, eos/stop wiring. 56/56 ctest
green under warnings-as-errors.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: mudler

CMakeLists.txt

@@ -86,6 +86,7 @@ add_library(vllm STATIC
   src/vllm/v1/engine/types.cpp
   src/vllm/v1/engine/detokenizer.cpp
   src/vllm/v1/engine/core.cpp
+  src/vllm/v1/engine/input_processor.cpp
   src/vllm/v1/executor/executor.cpp
   src/vt/dtype.cpp
   src/vt/backend.cpp

include/vllm/v1/engine/input_processor.h

@@ -0,0 +1,99 @@
+// Ported from: vllm/v1/engine/input_processor.py @ e24d1b24
+// (InputProcessor.__init__ + process_inputs, the T0 text path).
+//
+// Scope (M1.8 Task 2): turn a text prompt + SamplingParams into an
+// EngineCoreRequest the EngineCore (Task 1) can schedule. This is the T0 slice of
+// upstream InputProcessor.process_inputs (input_processor.py:242-385):
+//   _validate_params  -> RUN SamplingParams::PostInit()/Verify()  (see below)
+//   preprocess/tokenize -> tokenizer.Encode(prompt) -> prompt_token_ids
+//   sampling_params.clone() (implicit: params passed by value)
+//   default max_tokens = model_config.max_model_len - len(prompt)  when unset
+//   update_from_generation_config(generation_config, eos_token_id)  (:323)
+//   update_from_tokenizer(tokenizer)                                (:328)
+//   -> EngineCoreRequest(request_id, prompt_token_ids, sampling_params, ...)
+//
+// THE M1.1 CARRY THIS CLOSES: our SamplingParams (M1.1) deferred __post_init__
+// to "the constructing unit — M1.8". The InputProcessor IS that unit:
+// ValidateParams runs PostInit() (which normalizes in place AND runs Verify()),
+// mirroring upstream, where __post_init__ ran at SamplingParams construction and
+// process_inputs then calls params.verify(model_config, ...).
+//
+// DEVIATIONS vs the pinned API (recorded, use OUR names):
+//   - __init__ takes VllmConfig (from which it pulls model_config,
+//     generation_config_fields and a renderer holding the tokenizer). We hold a
+//     tokenizer + HfConfig reference directly (the T0 deps), deriving
+//     max_model_len from HfConfig.max_position_embeddings and the primary eos +
+//     secondary eos ids from HfConfig.raw["eos_token_id"] (int OR list) with a
+//     Tokenizer::EosId() fallback. HfConfig has no max_model_len override
+//     (rope-scaling etc.), so max_position_embeddings stands in for it at T0.
+//   - process_inputs signature reordered to (request_id, prompt, params,
+//     arrival_time): only the text prompt + SamplingParams path is kept.
+//   - update_from_generation_config: our SamplingParams dropped the
+//     _all_stop_token_ids field (M1.1 — the detokenizer computes its own stop
+//     buffer), so the only observable T0 effect is setting eos_token_id and
+//     merging the SECONDARY eos ids into stop_token_ids (both gated on
+//     ignore_eos), matching sampling_params.py:627-655.
+//   - update_from_tokenizer is a no-op stub: upstream only processes bad_words
+//     there (sampling_params.py:657), and bad_words is a deferred SamplingParams
+//     field (M1.1).
+//
+// DEFERRED (marked; matches upstream so re-adding is mechanical): dict/EngineInput
+// prompts, prompt_embeds, encoder/decoder split, multimodal (mm_features),
+// pooling (PoolingParams), LoRA, data_parallel_rank validation, request-id
+// randomization (assign_request_id), _validate_model_inputs (prompt-length /
+// out-of-vocab checks), current_platform.validate_request, trace_headers,
+// priority, resumable.
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "vllm/sampling_params.h"
+#include "vllm/transformers_utils/hf_config.h"
+#include "vllm/v1/engine/types.h"
+
+namespace vllm::tok {
+class Tokenizer;  // vllm/tokenizer/tokenizer.h
+}
+
+namespace vllm::v1 {
+
+class InputProcessor {
+ public:
+  // __init__ (T0 deps): the tokenizer + HfConfig the processor reads. Both must
+  // outlive the InputProcessor. Derives max_model_len + eos ids up front.
+  InputProcessor(const tok::Tokenizer& tokenizer, const HfConfig& config);
+
+  // process_inputs (text path): validate + tokenize + build the request.
+  // `params` is taken BY VALUE (upstream clones it); PostInit()/eos-wiring
+  // mutate the local copy, never the caller's. Throws std::runtime_error via
+  // SamplingParams::Verify() on invalid params. arrival_time defaults to the
+  // wall clock (upstream time.time()).
+  EngineCoreRequest process_inputs(
+      const std::string& request_id, const std::string& prompt,
+      SamplingParams params,
+      std::optional<double> arrival_time = std::nullopt) const;
+
+ private:
+  // _validate_params: runs SamplingParams::PostInit() (normalize + Verify) —
+  // this closes the M1.1 deferred-__post_init__ carry.
+  void ValidateParams(SamplingParams& params) const;
+  // update_from_generation_config (T0 subset: eos_token_id + secondary stop ids).
+  void UpdateFromGenerationConfig(SamplingParams& params) const;
+  // update_from_tokenizer (T0 no-op: bad_words is deferred).
+  void UpdateFromTokenizer(SamplingParams& params) const;
+
+  const tok::Tokenizer& tokenizer_;
+  const HfConfig& config_;
+  // model_config.max_model_len (T0: HfConfig.max_position_embeddings).
+  int64_t max_model_len_ = 0;
+  // The primary eos id (renderer.get_eos_token_id()): the eos_ids list head, or
+  // the tokenizer's eos, or unset.
+  std::optional<int32_t> eos_token_id_;
+  // generation_config["eos_token_id"] as a list (int is a 1-element list).
+  std::vector<int32_t> generation_config_eos_ids_;
+};
+
+}  // namespace vllm::v1

src/vllm/v1/engine/input_processor.cpp

@@ -0,0 +1,129 @@
+// Ported from: vllm/v1/engine/input_processor.py @ e24d1b24
+// See include/vllm/v1/engine/input_processor.h for scope, deviations and
+// deferrals.
+#include "vllm/v1/engine/input_processor.h"
+
+#include <chrono>
+#include <set>
+#include <utility>
+
+#include "vllm/tokenizer/tokenizer.h"
+
+namespace vllm::v1 {
+namespace {
+
+// Wall-clock seconds since the epoch, mirroring upstream time.time().
+double NowSeconds() {
+  const auto now = std::chrono::system_clock::now().time_since_epoch();
+  return std::chrono::duration<double>(now).count();
+}
+
+}  // namespace
+
+InputProcessor::InputProcessor(const tok::Tokenizer& tokenizer,
+                               const HfConfig& config)
+    : tokenizer_(tokenizer), config_(config) {
+  // model_config.max_model_len. HfConfig has no dedicated max_model_len (rope
+  // scaling etc. are deferred), so max_position_embeddings stands in at T0.
+  max_model_len_ = config.max_position_embeddings;
+
+  // renderer.get_eos_token_id() + generation_config["eos_token_id"]: derive the
+  // primary eos id and the secondary eos-id list from config.json's
+  // "eos_token_id" (int OR list), falling back to the tokenizer's own eos.
+  bool found = false;
+  if (config.raw.is_object()) {
+    auto it = config.raw.find("eos_token_id");
+    if (it != config.raw.end() && !it->is_null()) {
+      if (it->is_number_integer()) {
+        const auto id = it->get<int32_t>();
+        eos_token_id_ = id;
+        generation_config_eos_ids_.push_back(id);
+        found = true;
+      } else if (it->is_array()) {
+        for (const auto& e : *it) {
+          if (e.is_number_integer()) {
+            generation_config_eos_ids_.push_back(e.get<int32_t>());
+          }
+        }
+        if (!generation_config_eos_ids_.empty()) {
+          eos_token_id_ = generation_config_eos_ids_.front();
+          found = true;
+        }
+      }
+    }
+  }
+  if (!found && tokenizer_.EosId() >= 0) {
+    eos_token_id_ = tokenizer_.EosId();
+    generation_config_eos_ids_.push_back(tokenizer_.EosId());
+  }
+}
+
+void InputProcessor::ValidateParams(SamplingParams& params) const {
+  // Upstream _validate_params calls params.verify(model_config, ...) after
+  // __post_init__ already ran at construction. Our SamplingParams deferred
+  // __post_init__ to this constructing unit (M1.1), so PostInit() both
+  // normalizes the params AND runs Verify() — closing that carry.
+  params.PostInit();
+}
+
+void InputProcessor::UpdateFromGenerationConfig(SamplingParams& params) const {
+  // sampling_params.py:627-655 (T0 subset). _all_stop_token_ids is deferred
+  // (M1.1), so its side of this is dropped; the observable effects are setting
+  // eos_token_id and merging the SECONDARY eos ids into stop_token_ids.
+  if (!params.ignore_eos) {
+    params.eos_token_id = eos_token_id_;
+  }
+
+  if (generation_config_eos_ids_.empty()) {
+    return;
+  }
+  std::set<int32_t> eos_ids(generation_config_eos_ids_.begin(),
+                            generation_config_eos_ids_.end());
+  // The primary eos id is handled separately for stopping; don't duplicate it.
+  if (eos_token_id_.has_value()) {
+    eos_ids.erase(*eos_token_id_);
+  }
+  if (!eos_ids.empty() && !params.ignore_eos) {
+    for (int32_t id : params.stop_token_ids) {
+      eos_ids.insert(id);
+    }
+    params.stop_token_ids.assign(eos_ids.begin(), eos_ids.end());
+  }
+}
+
+void InputProcessor::UpdateFromTokenizer(SamplingParams& params) const {
+  // sampling_params.py:657 only processes bad_words, a deferred SamplingParams
+  // field (M1.1) -> no-op at T0.
+  (void)params;
+}
+
+EngineCoreRequest InputProcessor::process_inputs(
+    const std::string& request_id, const std::string& prompt,
+    SamplingParams params, std::optional<double> arrival_time) const {
+  // _validate_params: run PostInit()/Verify() on the (cloned) params.
+  ValidateParams(params);
+
+  const double t = arrival_time.has_value() ? *arrival_time : NowSeconds();
+
+  // input_preprocessor.preprocess -> tokenize (text path only).
+  std::vector<int32_t> prompt_token_ids = tokenizer_.Encode(prompt);
+
+  // params is already our clone (passed by value). If unset max_tokens, then
+  // generate up to the max_model_len (input_processor.py:317-321).
+  if (!params.max_tokens.has_value()) {
+    const int64_t seq_len = static_cast<int64_t>(prompt_token_ids.size());
+    params.max_tokens = static_cast<int>(max_model_len_ - seq_len);
+  }
+
+  UpdateFromGenerationConfig(params);
+  UpdateFromTokenizer(params);
+
+  EngineCoreRequest request;
+  request.request_id = request_id;
+  request.prompt_token_ids = std::move(prompt_token_ids);
+  request.sampling_params = std::move(params);
+  request.arrival_time = t;
+  return request;
+}
+
+}  // namespace vllm::v1

tests/CMakeLists.txt

@@ -42,6 +42,9 @@ vllm_cpp_add_test(test_common_attn_metadata vllm/v1/attention/test_common_attn_m
 vllm_cpp_add_test(test_gdn_metadata_builder vllm/v1/attention/test_gdn_metadata_builder.cpp)
 vllm_cpp_add_test(test_engine_types vllm/test_engine_types.cpp)
 vllm_cpp_add_test(test_engine_core vllm/v1/test_engine_core.cpp)
+vllm_cpp_add_test(test_input_processor vllm/v1/test_input_processor.cpp)
+target_compile_definitions(test_input_processor PRIVATE
+  PARITY_GOLDENS_DIR="${CMAKE_SOURCE_DIR}/tests/parity/goldens")
 vllm_cpp_add_test(test_outputs vllm/test_outputs.cpp)
 vllm_cpp_add_test(test_cuda_backend vt/test_cuda_backend.cpp)
 vllm_cpp_add_test(test_cuda_ops vt/test_cuda_ops.cpp)