[BugFix] Fix stop token sequence pointer offset and actual length computation (#7721)

Co-authored-by: songyuxing <songyuxing@baidu.com>

Author: TBD1

custom_ops/gpu_ops/stop_generation_multi_ends.cu

@@ -79,8 +79,9 @@ __global__ void set_value_by_flags(bool *stop_flags,
     // dealing stop_seqs
     const int stop_seq_len = (stop_seqs_len + bid * stop_seqs_bs)[tid];
     if (stop_seq_len <= 0) return;
-    const int64_t *stop_seq_now =
-        stop_seqs + bid * stop_seqs_bs + tid * stop_seqs_max_len;
+    const int64_t *stop_seq_now = stop_seqs +
+                                  bid * stop_seqs_bs * stop_seqs_max_len +
+                                  tid * stop_seqs_max_len;
     const int64_t *pre_ids_now =
         token_ids_all + bid * max_model_len + prompt_lens[bid];
     const int64_t step_idx_now = step_idx[bid];

fastdeploy/input/utils.py

@@ -82,24 +82,27 @@ def process_stop_token_ids(
     update_stop_seq_fn: Callable[[List[str]], Tuple[List[List[int]], List[int]]],
 ) -> None:
     stop_token_ids_final = []
+    stop_seqs_len_final = []
 
     if request.get("stop_token_ids") is not None:
         stop_token_ids = request.get("stop_token_ids")
         if isinstance(stop_token_ids, list) and len(stop_token_ids) > 0:
             if isinstance(stop_token_ids[0], int):
                 # List[int] -> List[List[int]]
                 stop_token_ids_final.extend([[t] for t in stop_token_ids])
+                stop_seqs_len_final.extend([1] * len(stop_token_ids))
             elif isinstance(stop_token_ids[0], list):
                 # Already List[List[int]]
                 stop_token_ids_final.extend(stop_token_ids)
+                stop_seqs_len_final.extend([len(seq) for seq in stop_token_ids])
 
     stop_sequences = request.get("stop", [])
     if stop_sequences:
-        stop_seqs, _ = update_stop_seq_fn(stop_sequences)
+        stop_seqs, stop_seqs_actual_lens = update_stop_seq_fn(stop_sequences)
         stop_token_ids_final.extend(stop_seqs)
+        stop_seqs_len_final.extend(stop_seqs_actual_lens)
 
     # Update request
     if stop_token_ids_final:
-        stop_seqs_len = [len(seq) for seq in stop_token_ids_final]
         request["stop_token_ids"] = stop_token_ids_final
-        request["stop_seqs_len"] = stop_seqs_len
+        request["stop_seqs_len"] = stop_seqs_len_final

tests/input/test_process_stop_token_ids.py

@@ -0,0 +1,118 @@
+# Copyright (c) 2025 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for process_stop_token_ids in fastdeploy.input.utils.common."""
+
+from fastdeploy.input.utils.common import process_stop_token_ids
+
+
+def _mock_update_stop_seq_fn(stop_sequences):
+    """Mock update_stop_seq that simulates tokenization and padding.
+
+    Simulates: "```" -> [101], "end" -> [201, 202]
+    Returns padded sequences and actual lengths.
+    """
+    token_map = {
+        "```": [101],
+        "end": [201, 202],
+        "\n\n": [301, 302, 303],
+        "stop": [401],
+    }
+    seqs = [token_map.get(s, [999]) for s in stop_sequences]
+    actual_lens = [len(s) for s in seqs]
+    # Simulate pad_batch_data: pad to max length with -1
+    max_len = max(len(s) for s in seqs) if seqs else 0
+    padded = [s + [-1] * (max_len - len(s)) for s in seqs]
+    return padded, actual_lens
+
+
+def test_stop_token_ids_list_int():
+    """stop_token_ids as List[int] should produce length-1 sequences."""
+    request = {"stop_token_ids": [100, 200, 300]}
+    process_stop_token_ids(request, _mock_update_stop_seq_fn)
+
+    assert request["stop_token_ids"] == [[100], [200], [300]]
+    assert request["stop_seqs_len"] == [1, 1, 1]
+
+
+def test_stop_token_ids_list_list_int():
+    """stop_token_ids as List[List[int]] should preserve actual lengths."""
+    request = {"stop_token_ids": [[10, 20], [30]]}
+    process_stop_token_ids(request, _mock_update_stop_seq_fn)
+
+    assert request["stop_token_ids"] == [[10, 20], [30]]
+    assert request["stop_seqs_len"] == [2, 1]
+
+
+def test_stop_strings_uses_actual_lengths():
+    """stop strings with different tokenized lengths should use actual lengths, not padded."""
+    request = {"stop": ["```", "end"]}
+    process_stop_token_ids(request, _mock_update_stop_seq_fn)
+
+    # "```" -> [101, -1] (padded), actual len 1
+    # "end" -> [201, 202], actual len 2
+    assert request["stop_token_ids"] == [[101, -1], [201, 202]]
+    assert request["stop_seqs_len"] == [1, 2]
+
+
+def test_mixed_stop_token_ids_and_stop_strings():
+    """Both stop_token_ids and stop strings should have correct lengths."""
+    request = {
+        "stop_token_ids": [100],
+        "stop": ["```", "\n\n"],
+    }
+    process_stop_token_ids(request, _mock_update_stop_seq_fn)
+
+    # stop_token_ids: [100] -> [[100]], len [1]
+    # "```" -> [101, -1, -1] (padded to 3), actual len 1
+    # "\n\n" -> [301, 302, 303], actual len 3
+    assert request["stop_token_ids"] == [[100], [101, -1, -1], [301, 302, 303]]
+    assert request["stop_seqs_len"] == [1, 1, 3]
+
+
+def test_empty_request():
+    """No stop tokens or strings should leave request unchanged."""
+    request = {}
+    process_stop_token_ids(request, _mock_update_stop_seq_fn)
+
+    assert "stop_token_ids" not in request
+    assert "stop_seqs_len" not in request
+
+
+def test_stop_token_ids_none():
+    """stop_token_ids=None should be treated as absent."""
+    request = {"stop_token_ids": None, "stop": ["stop"]}
+    process_stop_token_ids(request, _mock_update_stop_seq_fn)
+
+    assert request["stop_token_ids"] == [[401]]
+    assert request["stop_seqs_len"] == [1]
+
+
+def test_stop_token_ids_empty_list():
+    """stop_token_ids=[] should be treated as absent."""
+    request = {"stop_token_ids": []}
+    process_stop_token_ids(request, _mock_update_stop_seq_fn)
+
+    assert "stop_seqs_len" not in request
+
+
+if __name__ == "__main__":
+    test_stop_token_ids_list_int()
+    test_stop_token_ids_list_list_int()
+    test_stop_strings_uses_actual_lengths()
+    test_mixed_stop_token_ids_and_stop_strings()
+    test_empty_request()
+    test_stop_token_ids_none()
+    test_stop_token_ids_empty_list()
+    print("All tests passed.")