yes

app.py

@@ -150,11 +150,17 @@ def _load_model_on(device_map: Optional[str]) -> AutoModelForCausalLM:
 # Harmony formatting
 # -----------------------
 
-def create_harmony_prompt(messages: List[Dict[str, str]], reasoning_effort: str = "high") -> Any:
-    """Create a proper Harmony-formatted prompt using openai_harmony."""
-    if not HARMONY_AVAILABLE:
-        # Fallback to tokenizer's chat template
-        return tokenizer.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+def create_harmony_prompt(messages: List[Dict[str, str]], reasoning_effort: str = "high") -> str:
+    """Build Harmony-formatted prompt using the *tokenizer chat template* (per model card).
+    Always returns a string; HF will tokenize to ensure IDs match the checkpoint.
+    """
+    if not messages or messages[0].get("role") != "system":
+        messages = [{"role": "system", "content": SYSTEM_DEF}] + (messages or [])
+    return tokenizer.apply_chat_template(
+        messages,
+        add_generation_prompt=True,
+        tokenize=False
+    )
     
     # Map reasoning effort
     effort_map = {
@@ -223,24 +229,40 @@ def parse_harmony_response(tokens: List[int]) -> Dict[str, str]:
     return channels
 
 def extract_final_channel_fallback(text: str) -> str:
-    """Fallback extraction when harmony library isn't available."""
-    # Look for the final channel marker
-    final_marker = "<|channel|>final<|message|>"
-    
-    if final_marker in text:
-        parts = text.split(final_marker)
-        if len(parts) > 1:
-            final_text = parts[-1]
-            
-            # Clean up end markers
-            end_markers = ["<|return|>", "<|end|>", "<|endoftext|>"]
-            for marker in end_markers:
-                if marker in final_text:
-                    final_text = final_text.split(marker)[0]
-            
-            return final_text.strip()
-    
-    # If no channel markers found, return cleaned text
+    """Robustly extract the <final> channel from decoded Harmony text.
+    Works even if parsing fails or the model emits extra headers.
+    """
+    try:
+        chunks: Dict[str, str] = {}
+        pieces = text.split("<|channel|>")
+        for seg in pieces[1:]:
+            name_end = seg.find("<|message|>")
+            if name_end <= 0:
+                continue
+            ch = seg[:name_end].strip()
+            body_start = name_end + len("<|message|>")
+            # end at next channel/end/return marker
+            next_pos = len(seg)
+            for delim in ("<|channel|>", "<|end|>", "<|return|>"):
+                p = seg.find(delim, body_start)
+                if p != -1:
+                    next_pos = min(next_pos, p)
+            body = seg[body_start:next_pos]
+            chunks[ch] = chunks.get(ch, "") + body
+        final_txt = (chunks.get("final", "").strip())
+        if final_txt:
+            return final_txt
+        # Fallback: everything after last final marker up to a terminator
+        if "<|channel|>final<|message|>" in text:
+            tail = text.split("<|channel|>final<|message|>")[-1]
+            for delim in ("<|return|>", "<|end|>", "<|channel|>"):
+                idx = tail.find(delim)
+                if idx != -1:
+                    tail = tail[:idx]
+                    break
+            return tail.strip()
+    except Exception:
+        pass
     return text.strip()
 
 # -----------------------
@@ -319,9 +341,7 @@ def zerogpu_generate(full_prompt,
             top_p=float(gen_kwargs.get("top_p", 0.9)),
             top_k=(int(gen_kwargs.get("top_k")) if gen_kwargs.get("top_k") and int(gen_kwargs.get("top_k")) > 0 else None),
             max_new_tokens=int(gen_kwargs.get("max_new_tokens", MAX_DEF)),
-            pad_token_id=model.config.pad_token_id,
-            eos_token_id=eos_ids,
-            logits_processor=logits_processor,
+            pad_token_id=model.config.pad_token_id,            logits_processor=logits_processor,
             repetition_penalty=float(gen_kwargs.get("repetition_penalty", 1.1)),
             no_repeat_ngram_size=int(gen_kwargs.get("no_repeat_ngram_size", 6)),
             min_new_tokens=1,