fix: address branch review findings (5 warnings, 5 infos)

- asr_text guard: only apply when EOS was seen, not on max_tokens
  truncation (fixes conflict with truncation test)
- Add asr_text_token_id >= 0 to load-time validation
- Mark tokenizer encode() as pub(crate) to prevent misuse on long text
- Use ..Default::default() in transcribe_raw instead of hardcoded 512
- Fix dangling OLOGY_BUG.md doc reference
- Fix cfg(test) function doc reference
- Add unit tests for language-conditioned prompt structure and
  None-path equivalence with standard prompt

Author: pi-anl

src/onnx/qwen3/engine.rs

@@ -135,8 +135,8 @@ impl SpeechModel for Qwen3Model {
             );
         }
         let params = Qwen3Params {
-            max_tokens: 512,
             language: options.language.clone(),
+            ..Default::default()
         };
         self.transcribe_with(samples, &params)
     }

src/onnx/qwen3/model.rs

@@ -43,6 +43,7 @@ impl Qwen3AsrModel {
                 && st.audio_start_token_id >= 0
                 && st.audio_end_token_id >= 0
                 && st.audio_pad_token_id >= 0
+                && st.asr_text_token_id >= 0
                 && !st.eos_token_ids.is_empty()
                 && st.eos_token_ids.iter().all(|&id| id >= 0);
             if !valid {
@@ -286,24 +287,27 @@ impl Qwen3AsrModel {
             }
         }
 
-        if !self
+        let eos_reached = self
             .config
             .special_tokens
             .eos_token_ids
-            .contains(&current_token)
-        {
+            .contains(&current_token);
+        if !eos_reached {
             log::warn!(
                 "Qwen3-ASR: max_tokens ({}) reached without EOS token",
                 max_tokens
             );
         }
 
         // The model should produce `language <Name> <asr_text> <transcription>`.
-        // If the <asr_text> separator token is absent, the decoder failed to produce
-        // a valid transcription (e.g. degenerate "ology" output from int4 quantization
-        // noise on non-speech audio). Return empty string rather than garbage.
+        // If the <asr_text> separator token is absent AND the model completed
+        // normally (EOS seen), the decoder failed to produce a valid transcription
+        // (e.g. degenerate "ology" output from int4 quantization noise on
+        // non-speech audio). Return empty string rather than garbage.
+        // When max_tokens truncated the output, the <asr_text> token may simply
+        // not have been reached yet — this is not degenerate, just truncated.
         let asr_text_id = self.config.special_tokens.asr_text_token_id;
-        if !output_tokens.contains(&asr_text_id) {
+        if eos_reached && !output_tokens.contains(&asr_text_id) {
             let preview: Vec<_> = output_tokens.iter().take(20).collect();
             log::warn!(
                 "Qwen3-ASR: no <asr_text> token in output ({} tokens, first 20: {:?}); \

src/onnx/qwen3/prompt.rs

@@ -57,11 +57,11 @@ pub(crate) fn build_prompt_ids(
 /// When `language_token_ids` is provided, the prompt includes a system message
 /// ("You are a helpful assistant.") and a user instruction ("Please transcribe
 /// the above {language} audio."). This conditions the decoder toward the
-/// specified language and avoids degenerate output on non-speech audio
-/// (see OLOGY_BUG.md).
+/// specified language and avoids degenerate output (e.g. "ology") from int4
+/// quantization noise on non-speech audio.
 ///
-/// When `language_token_ids` is `None`, falls back to [`build_prompt_ids`]
-/// (empty system turn, no language instruction).
+/// When `language_token_ids` is `None`, builds the standard prompt with an
+/// empty system turn and no language instruction.
 pub fn build_prompt_ids_with_language(
     special_tokens: &SpecialTokens,
     audio_token_count: usize,
@@ -201,4 +201,62 @@ mod tests {
         assert_eq!(end, 19);
         assert_eq!(end - start, 10);
     }
+
+    #[test]
+    fn test_build_prompt_ids_with_language() {
+        let st = test_special_tokens();
+        let lang_ids: &[i64] = &[22574]; // "English"
+        let ids = build_prompt_ids_with_language(&st, 5, Some(lang_ids));
+
+        // System turn: im_start, system, newline, <SYSTEM_CONTENT>, im_end, newline
+        assert_eq!(ids[0], st.im_start_token_id);
+        assert_eq!(ids[1], SYSTEM_TOKEN_ID);
+        assert_eq!(ids[2], NEWLINE_TOKEN_ID);
+        // SYSTEM_CONTENT: 6 tokens [2610, 525, 264, 10950, 17847, 13]
+        assert_eq!(&ids[3..9], SYSTEM_CONTENT);
+        assert_eq!(ids[9], st.im_end_token_id);
+        assert_eq!(ids[10], NEWLINE_TOKEN_ID);
+
+        // User turn: im_start, user, newline, USER_PREFIX, audio_start
+        assert_eq!(ids[11], st.im_start_token_id);
+        assert_eq!(ids[12], USER_TOKEN_ID);
+        assert_eq!(ids[13], NEWLINE_TOKEN_ID);
+        // USER_PREFIX: 5 tokens
+        assert_eq!(&ids[14..19], USER_PREFIX);
+        assert_eq!(ids[19], st.audio_start_token_id);
+
+        // 5 audio_pad tokens
+        for i in 20..25 {
+            assert_eq!(ids[i], st.audio_pad_token_id);
+        }
+
+        // audio_end, USER_SUFFIX_PRE, language tokens, USER_SUFFIX_POST, im_end, newline
+        assert_eq!(ids[25], st.audio_end_token_id);
+        let suffix_pre_start = 26;
+        let suffix_pre_end = suffix_pre_start + USER_SUFFIX_PRE.len();
+        assert_eq!(&ids[suffix_pre_start..suffix_pre_end], USER_SUFFIX_PRE);
+        assert_eq!(ids[suffix_pre_end], 22574); // "English"
+        let suffix_post_start = suffix_pre_end + 1;
+        let suffix_post_end = suffix_post_start + USER_SUFFIX_POST.len();
+        assert_eq!(&ids[suffix_post_start..suffix_post_end], USER_SUFFIX_POST);
+        assert_eq!(ids[suffix_post_end], st.im_end_token_id);
+        assert_eq!(ids[suffix_post_end + 1], NEWLINE_TOKEN_ID);
+
+        // Assistant turn
+        assert_eq!(ids[suffix_post_end + 2], st.im_start_token_id);
+        assert_eq!(ids[suffix_post_end + 3], ASSISTANT_TOKEN_ID);
+        assert_eq!(ids[suffix_post_end + 4], NEWLINE_TOKEN_ID);
+
+        // Audio pad range should still work
+        let (start, end) = get_audio_pad_range(&ids, st.audio_pad_token_id).unwrap();
+        assert_eq!(end - start, 5);
+    }
+
+    #[test]
+    fn test_language_none_matches_standard_prompt() {
+        let st = test_special_tokens();
+        let standard = build_prompt_ids(&st, 10);
+        let with_none = build_prompt_ids_with_language(&st, 10, None);
+        assert_eq!(standard, with_none);
+    }
 }

src/onnx/qwen3/tokenizer.rs

@@ -111,7 +111,7 @@ impl Qwen3Tokenizer {
     /// vocabulary entry at each position. For common English words and language
     /// names this produces identical results to the reference BPE tokenizer.
     /// Results may differ on rare subword boundaries.
-    pub fn encode(&self, text: &str) -> Vec<i64> {
+    pub(crate) fn encode(&self, text: &str) -> Vec<i64> {
         let bytes = text.as_bytes();
         let mut ids = Vec::new();
         let mut pos = 0;