fix(frontend): select the earliest matching stop sequence

lib/llm/src/backend.rs

 pub fn process_token_ids(&mut self, token_ids: &[TokenIdType]) -> Result<SeqResult> { 
     let mut text: Option<String> = None; 
     let mut tokens = Vec::with_capacity(token_ids.len()); 
     for token_id in token_ids { 
         let StepResult { 
             token, 
             released_text, 
             stop_trigger, 
         } = self.step(*token_id)?; 
         // `text` accumulates the caller-visible content, which can lag behind and later 
         // release more than one step's worth at once. `tokens[i]` always reports 
         // token_ids[i]'s own decoded text, independent of that withholding, so per-token 
         // consumers (logprobs) stay aligned with token_ids. 
         if let Some(released_text) = &released_text { 
             text.get_or_insert_with(|| String::with_capacity(token_ids.len())) 
                 .push_str(released_text); 
         } 
         tokens.push(token); 
         if let Some(stop_trigger) = stop_trigger { 
             return Ok(SeqResult { 
                 tokens, 
                 text, 
                 stop_trigger: Some(stop_trigger), 
             }); 
         } 
     } 
@@ -860,51 +860,58 @@ impl Decoder {
             let release_start = self.jail.len() - self.jailed_bytes;
             self.jail.push_str(token_text);
 
+            // Select the earliest match, preserving stop-list order for ties.
             // Check hidden stop sequences first (excluded from output)
-            for seq in &self.hidden_stop_sequences {
-                if let Some(offset) = galil_seiferas::gs_find(self.jail.as_bytes(), seq.as_bytes())
-                {
-                    // return only new bytes after release_start .. offset (excluding stop sequence)
-                    // example: seq = "ox", token = "boxes", return "b"
-                    //
-                    // we might have returned a partial match, if so, then offset < release_start
-                    // in that case, we return no text
-                    let partial_token = (offset >= release_start)
-                        .then(|| self.jail[release_start..offset].to_string())
-                        .filter(|s| !s.is_empty());
-                    self.jailed_bytes = 0;
-                    // `token` (this step's own raw decoded text) is reported unchanged so
-                    // that SeqResult.tokens[i] keeps describing token_ids[i] for logprobs;
-                    // only the caller-visible `released_text` excludes the matched sequence.
-                    // `token_text`'s last use was the `push_str` above, so `token` itself
-                    // (not yet borrowed at this point) can move here instead of cloning.
-                    return Ok(StepResult::with_stop_trigger(
-                        token,
-                        partial_token,
-                        StopTrigger::HiddenStopSequenceDetected(seq.to_string()),
-                    ));
-                }
+            if let Some((seq, offset)) = self
+                .hidden_stop_sequences
+                .iter()
+                .filter_map(|seq| {
+                    galil_seiferas::gs_find(self.jail.as_bytes(), seq.as_bytes())
+                        .map(|offset| (seq, offset))
+                })
+                .min_by_key(|(_, offset)| *offset)
+            {
+                // return only new bytes after release_start .. offset (excluding stop sequence)
+                // example: seq = "ox", token = "boxes", return "b"
+                //
+                // we might have returned a partial match, if so, then offset < release_start
+                // in that case, we return no text
+                let partial_token = (offset >= release_start)
+                    .then(|| self.jail[release_start..offset].to_string())
+                    .filter(|s| !s.is_empty());
+                self.jailed_bytes = 0;
+                // `token` (this step's own raw decoded text) is reported unchanged so
+                // that SeqResult.tokens[i] keeps describing token_ids[i] for logprobs;
+                // only the caller-visible `released_text` excludes the matched sequence.
+                return Ok(StepResult::with_stop_trigger(
+                    token,
+                    partial_token,
+                    StopTrigger::HiddenStopSequenceDetected(seq.to_string()),
+                ));
             }
 
             // Check visible stop sequences (included in output)
-            for seq in &self.visible_stop_sequences {
-                if let Some(offset) = galil_seiferas::gs_find(self.jail.as_bytes(), seq.as_bytes())
-                {
-                    // For visible stop sequences, include the stop string in the output
-                    // Return all text from release_start up to and including the stop sequence
-                    let stop_end = offset + seq.len();
-                    let token_with_stop = (stop_end > release_start)
-                        .then(|| self.jail[release_start..stop_end].to_string())
-                        .filter(|s| !s.is_empty());
-                    self.jailed_bytes = 0;
-                    // Same reasoning as the hidden-sequence branch above: `token` can move
-                    // here instead of cloning.
-                    return Ok(StepResult::with_stop_trigger(
-                        token,
-                        token_with_stop,
-                        StopTrigger::VisibleStopSequenceDetected(seq.to_string()),
-                    ));
-                }
+            if let Some((seq, offset)) = self
+                .visible_stop_sequences
+                .iter()
+                .filter_map(|seq| {
+                    galil_seiferas::gs_find(self.jail.as_bytes(), seq.as_bytes())
+                        .map(|offset| (seq, offset))
+                })
+                .min_by_key(|(_, offset)| *offset)
+            {
+                // For visible stop sequences, include the stop string in the output
+                // Return all text from release_start up to and including the stop sequence
+                let stop_end = offset + seq.len();
+                let token_with_stop = (stop_end > release_start)
+                    .then(|| self.jail[release_start..stop_end].to_string())
+                    .filter(|s| !s.is_empty());
+                self.jailed_bytes = 0;
+                return Ok(StepResult::with_stop_trigger(
+                    token,
+                    token_with_stop,
+                    StopTrigger::VisibleStopSequenceDetected(seq.to_string()),
+                ));
             }
 
             // No complete match. Withhold the longest tail of `jail` that is still a viable

lib/llm/tests/test_stop_behavior.rs

@@ -344,3 +344,25 @@ fn hidden_stop_sequence_survives_self_similar_prefix_run() {
         "one token report per input token id"
     );
 }
+
+#[test]
+fn earliest_stop_sequence_wins_over_list_order() {
+    for include_stop_str in [false, true] {
+        let mut decoder = make_decoder(None, None, None, Some(vec!["re", "he"]), include_stop_str);
+        let result = decoder.process_token_ids(&[THERE]).unwrap();
+
+        assert_eq!(
+            result.text.as_deref(),
+            Some(if include_stop_str { "the" } else { "t" }),
+        );
+        match result.stop_trigger {
+            Some(StopTrigger::VisibleStopSequenceDetected(stop)) if include_stop_str => {
+                assert_eq!(stop, "he");
+            }
+            Some(StopTrigger::HiddenStopSequenceDetected(stop)) if !include_stop_str => {
+                assert_eq!(stop, "he");
+            }
+            trigger => panic!("unexpected stop trigger: {trigger:?}"),
+        }
+    }
+}