fix(windows): close Logprobs shadow review gaps (#465)

Rename the slice length parameter without changing its function type, and cover both installed declaration and source definition independently. Characterize a nonzero row slice whose width differs from its requested row count so a wrong stride cannot pass.

FOLLOWING_AGENTS_PROTOCOL

Following-Agents-Protocol: true

AI-Assisted: true

Assisted-by: Codex:GPT-5 [Codex]

Author: mudler

.agents/specs/windows-msvc-logprobs-shadow.md

@@ -81,4 +81,32 @@ complete native log contains any other diagnostic family.
 
 ## Outcome
 
-Pending RED, implementation, and immutable gate evidence.
+The structural regression failed first with the exact shadowing declaration
+`LogprobsTensors::slice_request(int req_idx, int num_positions) const`. The
+implementation renames only that parameter to `request_num_positions` in the
+declaration and definition, assigns `out.num_positions` explicitly from it, and
+uses it for the slice end. The function types, public symbol, selected rows,
+payload values, warning gates, and release surfaces remain unchanged.
+
+The first structural regression read only `outputs.cpp`, so restoring the
+shadowing parameter in the installed header alone passed both the focused test
+and direct checker. The final regression recognizes the exact `slice_request`
+declaration and definition independently, limits the C4458 assertion to those
+two scopes, and ignores comments and the valid `empty_cpu` parameter of the
+same name. Header-only and source-only mutations each fail their own subtest;
+mutating both fails both.
+
+The first semantic fixture also made the row width and requested row count both
+`2`, so using `request_num_positions` as the flat-vector stride passed. The
+final payload has width `3`, requests two rows from nonzero offset `1`, and
+checks all six token IDs and logprobs. The wrong-stride mutation selects four
+values beginning in the previous row and fails both payload assertions, while
+the correct member assignment, slice end, offset, and width pass.
+
+The focused structural test and direct production portability checker pass, as
+does the complete 69-test Windows portability suite. Clean Release CPU and
+Vulkan source closures built the focused linked tests; in both configurations,
+`test_sampling_metadata` passes 7/7 cases and 61/61 assertions, while
+`test_outputs` passes 9/9 cases and 48/48 assertions. Native MSVC CPU and Vulkan
+reruns remain the authoritative C4458 `/W4 /WX` validation and are not inferred
+from Linux.

docs/USAGE.md

@@ -1295,6 +1295,11 @@ SAMPLED from — a token top-k masked away reads `-inf` there and its true value
 under the raw pair. It is selectable by constructing a `Sampler` directly; there
 is no config, CLI or request field for it yet.
 
+`LogprobsTensors::slice_request(req_idx, request_num_positions)` cuts that
+batch-wide payload by rows. The second argument is the requested row count;
+each row keeps the source tensor's independent `num_tokens_per_position`
+width.
+
 The LoRA adapter headers ([`lora/lora_weights.h`](../include/vllm/lora/lora_weights.h),
 [`lora/punica.h`](../include/vllm/lora/punica.h),
 [`lora/layers.h`](../include/vllm/lora/layers.h)) are present but **not yet wired

include/vllm/v1/outputs.h

@@ -56,7 +56,8 @@ struct LogprobsTensors {
   // token per request per step) and cu_num_generated_tokens is None, so req_idx
   // indexes positions directly. (Our host-vector LogprobsTensors doubles as the
   // numpy LogprobsLists twin — no torch/numpy split.)
-  LogprobsTensors slice_request(int req_idx, int num_positions) const;
+  LogprobsTensors slice_request(int req_idx,
+                                int request_num_positions) const;
 };
 
 }  // namespace vllm::v1

src/vllm/v1/outputs.cpp

@@ -21,13 +21,13 @@ LogprobsTensors LogprobsTensors::empty_cpu(int num_positions,
 }
 
 LogprobsTensors LogprobsTensors::slice_request(int req_idx,
-                                               int num_positions) const {
+                                               int request_num_positions) const {
   LogprobsTensors out;
-  out.num_positions = num_positions;
+  out.num_positions = request_num_positions;
   out.num_tokens_per_position = num_tokens_per_position;
   const size_t w = static_cast<size_t>(num_tokens_per_position);
   const size_t begin = static_cast<size_t>(req_idx);
-  const size_t end = begin + static_cast<size_t>(num_positions);
+  const size_t end = begin + static_cast<size_t>(request_num_positions);
   out.logprob_token_ids.assign(logprob_token_ids.begin() + static_cast<std::ptrdiff_t>(begin * w),
                                logprob_token_ids.begin() + static_cast<std::ptrdiff_t>(end * w));
   out.logprobs.assign(logprobs.begin() + static_cast<std::ptrdiff_t>(begin * w),

tests/scripts/test_check_windows_portability.py

@@ -468,6 +468,55 @@ def test_real_tree_closes_observed_msvc_source_warnings(self) -> None:
             with self.subTest(contract=contract):
                 self.assertRegex(active_deepseek, contract)
 
+    def test_logprobs_slice_parameter_does_not_shadow_member(self) -> None:
+        header = (REPO / "include/vllm/v1/outputs.h").read_text(
+            encoding="utf-8"
+        )
+        active_header = checker._cpp_structural_view(header)
+        header_signature = r"\bLogprobsTensors\s+slice_request\s*\("
+        header_matches = list(re.finditer(header_signature, active_header))
+        self.assertEqual(
+            len(header_matches),
+            1,
+            "LogprobsTensors::slice_request declaration",
+        )
+        header_match = header_matches[0]
+        header_end = re.match(
+            r"(?:[^()]|\([^()]*\))*\)\s*const\s*;",
+            active_header[header_match.end():],
+        )
+        self.assertIsNotNone(
+            header_end,
+            "LogprobsTensors::slice_request declaration",
+        )
+        assert header_end is not None
+        header_declaration = active_header[
+            header_match.start():header_match.end() + header_end.end()
+        ]
+
+        source = (REPO / "src/vllm/v1/outputs.cpp").read_text(
+            encoding="utf-8"
+        )
+        active_source = checker._cpp_structural_view(source)
+        source_signature = r"\bLogprobsTensors::slice_request\s*\("
+        span = checker._cpp_function_body_span(source, source_signature)
+        self.assertIsNotNone(span, "LogprobsTensors::slice_request")
+        assert span is not None
+        source_matches = list(re.finditer(source_signature, active_source))
+        self.assertEqual(
+            len(source_matches),
+            1,
+            "LogprobsTensors::slice_request definition",
+        )
+        source_declaration = active_source[source_matches[0].start():span[1]]
+
+        for location, declaration in (
+            ("header", header_declaration),
+            ("source", source_declaration),
+        ):
+            with self.subTest(location=location):
+                self.assertNotRegex(declaration, r"\bint\s+num_positions\b")
+
     def test_posix_cache_source_requires_exact_not_win32_cmake_guard(self) -> None:
         source = "src/vt/cuda/nvfp4_persistent_cache.cpp"
         for condition, expected in (("NOT WIN32", {source}), ("WIN32", set()), ("NOT APPLE", set())):

tests/vllm/v1/sample/test_metadata.cpp

@@ -187,6 +187,27 @@ TEST_CASE("LogprobsTensors::empty_cpu has the right shapes") {
   CHECK(lt.selected_token_ranks.size() == 3);
 }
 
+TEST_CASE("LogprobsTensors::slice_request preserves a multi-row payload") {
+  LogprobsTensors lt = LogprobsTensors::empty_cpu(/*num_positions=*/4,
+                                                  /*num_tokens=*/3);
+  lt.logprob_token_ids = {10, 11, 12, 20, 21, 22,
+                          30, 31, 32, 40, 41, 42};
+  lt.logprobs = {-1.0f, -1.1f, -1.2f, -2.0f, -2.1f, -2.2f,
+                 -3.0f, -3.1f, -3.2f, -4.0f, -4.1f, -4.2f};
+  lt.selected_token_ranks = {1, 2, 3, 4};
+
+  const LogprobsTensors slice = lt.slice_request(/*req_idx=*/1,
+                                                  /*num_positions=*/2);
+
+  CHECK(slice.num_positions == 2);
+  CHECK(slice.num_tokens_per_position == 3);
+  CHECK(slice.logprob_token_ids ==
+        std::vector<int32_t>{20, 21, 22, 30, 31, 32});
+  CHECK(slice.logprobs ==
+        std::vector<float>{-2.0f, -2.1f, -2.2f, -3.0f, -3.1f, -3.2f});
+  CHECK(slice.selected_token_ranks == std::vector<int32_t>{2, 3});
+}
+
 TEST_CASE("SamplerOutput now carries an optional LogprobsTensors payload") {
   SamplerOutput out;
   out.sampled_token_ids = {{42}, {7}};