fix: LaTeX symbols leaking to user chat (\rightarrow etc.)

PROBLEM: gemma-4-31b-it outputs LaTeX math expressions like
\rightarrow, \Rightarrow, \times, \alpha, \sum, etc. in responses.
These raw LaTeX commands show up as literal text on WeChat/Feishu
instead of being rendered as Unicode symbols.

FIX: Extended patch_strip_thinking_tags.py to also convert common
LaTeX math/logic symbols to their Unicode equivalents before the
response is sent to users.

Coverage: ~80 symbols including:
- Arrows: \rightarrow→ →, \Rightarrow→ ⇒, \to→ →, etc.
- Math: \times→ ×, \leq→ ≤, \geq→ ≥, \neq→ ≠, etc.
- Greek: \alpha→ α, \beta→ β, \pi→ π, etc.
- Logic: \forall→ ∀, \exists→ ∃, \in→ ∈, etc.
- Misc: \cdots→ ⋯, \sqrt→ √, \angle→ ∠, etc.

Also improved idempotency: skip patches already applied
to avoid duplicate insertions on repeated runs.

scripts/patch_strip_thinking_tags.py

@@ -1,17 +1,19 @@
 #!/usr/bin/env python3
-"""Patch hermes-agent to strip <|channel>thought / <channel|> thinking tags.
+"""Patch hermes-agent to strip thinking tags AND LaTeX symbols from user output.
 
-PROBLEM: Some models output internal thinking tokens in the format
+PROBLEM 1: Some models output internal thinking tokens in the format
     <|channel>thought ... <channel|>
-  that leak into user-facing messages on WeChat/Feishu. The existing
-  _strip_think_blocks() in run_agent.py handles <thought>, <thinking>,
-  <reasoning> etc., but NOT this <|...> pipe-delimited variant.
+  that leak into user-facing messages on WeChat/Feishu.
+
+PROBLEM 2: Some models output LaTeX math expressions like \rightarrow,
+  \leftarrow, \Rightarrow, \times, etc. that should be rendered as Unicode
+  arrows/symbols but instead show up as raw \command text.
 
 FIX: Extend both the agent-level tag stripper AND the gateway stream
-  consumer to recognise and suppress these tags.
+  consumer, plus add LaTeX -> Unicode conversion.
 
   Files patched:
-    1. run_agent.py — _strip_think_blocks() + stray-tag cleanup
+    1. run_agent.py — _strip_think_blocks() + stray-tag cleanup + LaTeX cleanup
     2. gateway/stream_consumer.py — _OPEN_THINK_TAGS / _CLOSE_THINK_TAGS
 """
 
@@ -21,22 +23,113 @@ import glob
 import re
 
 
+# LaTeX -> Unicode mapping for common math/logic symbols
+LATEX_TO_UNICODE = [
+    # Arrows
+    (r'\\rightarrow',  '\u2192'),   # →
+    (r'\\leftarrow',   '\u2190'),   # ←
+    (r'\\Rightarrow',  '\u21D2'),   # ⇒
+    (r'\\Leftarrow',   '\u21D0'),   # ⇐
+    (r'\\leftrightarrow', '\u2194'), # ↔
+    (r'\\Leftrightarrow', '\u21D4'), # ⇔
+    (r'\\mapsto',      '\u21A6'),   # ↦
+    (r'\\uparrow',     '\u2191'),   # ↑
+    (r'\\downarrow',   '\u2193'),   # ↓
+    (r'\\Uparrow',     '\u21D1'),   # ⇑
+    (r'\\Downarrow',   '\u21D3'),   # ⇓
+    # Math operators
+    (r'\\times',       '\u00D7'),   # ×
+    (r'\\div',         '\u00F7'),   # ÷
+    (r'\\pm',          '\u00B1'),   # ±
+    (r'\\leq',         '\u2264'),   # ≤
+    (r'\\geq',         '\u2265'),   # ≥
+    (r'\\neq',         '\u2260'),   # ≠
+    (r'\\approx',      '\u2248'),   # ≈
+    (r'\\equiv',       '\u2261'),   # ≡
+    (r'\\sim',         '\u223C'),   # ∼
+    (r'\\simeq',       '\u2243'),   # ≃
+    (r'\\propto',      '\u221D'),   # ∝
+    (r'\\infty',       '\u221E'),   # ∞
+    (r'\\partial',     '\u2202'),   # ∂
+    (r'\\nabla',       '\u2207'),   # ∇
+    (r'\\forall',      '\u2200'),   # ∀
+    (r'\\exists',      '\u2203'),   # ∃
+    (r'\\in',          '\u2208'),   # ∈
+    (r'\\notin',       '\u2209'),   # ∉
+    (r'\\subset',      '\u2282'),   # ⊂
+    (r'\\supset',      '\u2283'),   # ⊃
+    (r'\\cup',         '\u222A'),   # ∪
+    (r'\\cap',         '\u2229'),   # ∩
+    (r'\\emptyset',    '\u2205'),   # ∅
+    (r'\\sum',         '\u2211'),   # ∑
+    (r'\\prod',        '\u220F'),   # ∏
+    (r'\\int',         '\u222B'),   # ∫
+    (r'\\sqrt',        '\u221A'),   # √
+    (r'\\angle',       '\u2220'),   # ∠
+    (r'\\perp',        '\u22A5'),   # ⊥
+    (r'\\parallel',    '\u2225'),   # ∥
+    (r'\\cong',        '\u2245'),   # ≅
+    (r'\\to',          '\u2192'),   # →
+    (r'\\gets',        '\u2190'),   # ←
+    # Greek letters (common)
+    (r'\\alpha',       '\u03B1'),   # α
+    (r'\\beta',        '\u03B2'),   # β
+    (r'\\gamma',       '\u03B3'),   # γ
+    (r'\\delta',       '\u03B4'),   # δ
+    (r'\\epsilon',     '\u03B5'),   # ε
+    (r'\\zeta',        '\u03B6'),   # ζ
+    (r'\\eta',         '\u03B7'),   # η
+    (r'\\theta',       '\u03B8'),   # θ
+    (r'\\lambda',      '\u03BB'),   # λ
+    (r'\\mu',          '\u03BC'),   # μ
+    (r'\\sigma',       '\u03C3'),   # σ
+    (r'\\omega',       '\u03C9'),   # ω
+    (r'\\pi',          '\u03C0'),   # π
+    (r'\\phi',         '\u03C6'),   # φ
+    (r'\\psi',         '\u03C8'),   # ψ
+    (r'\\rho',         '\u03C1'),   # ρ
+    (r'\\tau',         '\u03C4'),   # τ
+    # Special
+    (r'\\cdots',       '\u22EF'),   # ⋯
+    (r'\\ldots',       '\u2026'),   # …
+    (r'\\dots',        '\u2026'),   # …
+    (r'\\Rightarrow',  '\u21D2'),   # ⇒
+    (r'\\iff',         '\u21D4'),   # ⇔
+    (r'\\implies',     '\u21D2'),   # ⇒
+    (r'\\therefore',   '\u2234'),   # ∴
+    (r'\\because',     '\u2235'),   # ∵
+    (r'\\checkmark',   '\u2713'),   # ✓
+    (r'\\times',       '\u00D7'),   # ×
+    (r'\\deg',         '\u00B0'),   # °
+    (r'\\cdot',        '\u00B7'),   # ·
+]
+
+
+def _build_latex_replacements() -> str:
+    """Build the re.sub chain for LaTeX -> Unicode conversion."""
+    lines = []
+    for latex, unicode_char in LATEX_TO_UNICODE:
+        # Escape backslashes for Python string
+        escaped = latex.replace('\\', '\\\\')
+        lines.append(
+            f"        content = content.replace('{escaped}', '{unicode_char}')"
+        )
+    return "\n".join(lines)
+
+
 def patch_run_agent(filepath: str) -> bool:
-    """Add <|channel>thinking / <channel|> patterns to _strip_think_blocks."""
+    """Add <|channel>thinking / <channel|> patterns + LaTeX cleanup to run_agent.py."""
     with open(filepath, "r") as f:
         content = f.read()
 
     if "<|channel" in content and "_strip_think_blocks" in content:
         # Check if already patched by looking for our specific addition
-        if '<|channel>thought' in content or '<|' in content and 'hermes-bot patch' in content:
-            print(f"  run_agent.py already patched, skipping")
-            return True
-
+        if '<|channel>thought' in content or ('<|' in content and 'hermes-bot patch' in content):
+            print(f"  run_agent.py thinking-tags already patched")
+    
     applied = False
 
     # ── Patch 1a: Add closed-tag regex for <|channel>thought ... <channel|> ──
-    # Find the block of re.sub calls for closed tag pairs.
-    # We add our pattern right after the <thought>.*?</thought> line.
     old_thought = "content = re.sub(r'<thought>.*?</thought>', '', content, flags=re.DOTALL | re.IGNORECASE)"
     new_thought = (
         old_thought
@@ -45,13 +138,12 @@ def patch_run_agent(filepath: str) -> bool:
         + "\n        content = re.sub(r'<\\|channel\\|>thought.*?<\\|channel\\|>', '', content, flags=re.DOTALL | re.IGNORECASE)"
         + "\n        content = re.sub(r'<\\|[^|>]*\\|>.*?<\\|/[^|>]*\\|>', '', content, flags=re.DOTALL | re.IGNORECASE)"
     )
-    if old_thought in content:
+    if old_thought in content and 'hermes-bot patch: <|channel' not in content:
         content = content.replace(old_thought, new_thought, 1)
         applied = True
         print("  [run_agent.py] Added closed-tag regex for <|...> thinking blocks")
 
     # ── Patch 1b: Add unterminated open-tag pattern ──
-    # Find the unterminated block regex and extend it.
     old_unterm = (
         "r'(?:^|\\n)[ \\t]*<(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)\\b[^>]*>.*$'"
     )
@@ -59,13 +151,12 @@ def patch_run_agent(filepath: str) -> bool:
         "r'(?:^|\\n)[ \\t]*<(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)\\b[^>]*>.*$'"
         + "\n            + r'|(?:^|\\n)[ \\t]*<\\|[^|>]*>.*$'"  # <|channel>thought
     )
-    if old_unterm in content and not "<\\|[^|>]*>" in content.split("def _has_natural_response_ending")[0].split("def _strip_think_blocks")[1]:
+    if old_unterm in content and '<\\|[^|>]*>' not in content.split("def _has_natural_response_ending")[0].split("def _strip_think_blocks")[1]:
         content = content.replace(old_unterm, new_unterm, 1)
         applied = True
         print("  [run_agent.py] Extended unterminated-tag regex for <|...> variants")
 
     # ── Patch 1c: Add stray orphan tag cleanup ──
-    # Find the stray tag cleanup and extend it.
     old_stray = (
         "r'</?(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)>\\s*'"
     )
@@ -73,16 +164,63 @@ def patch_run_agent(filepath: str) -> bool:
         "r'</?(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)>\\s*'"
         + "\n            + r'|<\\|[^|>]*\\|>\\s*'"  # stray <|channel|> or <channel|>
     )
-    if old_stray in content:
+    if old_stray in content and '<\\|[^|>]*\\|>\\s*' not in content.split("def _has_natural_response_ending")[0].split("def _strip_think_blocks")[1]:
         content = content.replace(old_stray, new_stray, 1)
         applied = True
         print("  [run_agent.py] Extended stray-tag cleanup for <|...> variants")
 
+    # ── Patch 1d: Add LaTeX -> Unicode conversion after _strip_think_blocks ──
+    # Insert right before the final "return content" in _strip_think_blocks
+    latex_marker = "        # Hermes Bot patch: LaTeX -> Unicode conversion"
+    if latex_marker not in content:
+        # Find the return statement at end of _strip_think_blocks
+        # Look for "return content" that's indented with spaces (inside a function)
+        import_pattern = "        # Hermes Bot patch: LaTeX -> Unicode cleanup\n"
+        import_pattern += _build_latex_replacements()
+
+        # Try multiple patterns for where to insert
+        return_patterns = [
+            "        return content\n    def ",
+            "        return content\n\n    def ",
+        ]
+        for pat in return_patterns:
+            if pat in content:
+                content = content.replace(pat, import_pattern + "\n" + pat, 1)
+                applied = True
+                print("  [run_agent.py] Added LaTeX -> Unicode conversion")
+                break
+
+        # Fallback: insert before any "return content" in the function
+        if 'LaTeX -> Unicode' not in content:
+            # Use a simpler approach: find the function end
+            idx = content.find("def _strip_think_blocks")
+            if idx > 0:
+                # Find the next function definition after _strip_think_blocks
+                next_def = content.find("\n    def ", idx + 10)
+                if next_def > 0:
+                    # Find the last "return content" before next_def
+                    search_area = content[idx:next_def]
+                    # Find return content
+                    ret_idx = search_area.rfind("return content")
+                    if ret_idx > 0:
+                        abs_ret_idx = idx + ret_idx
+                        insert_pos = content.rfind("\n", 0, abs_ret_idx) + 1
+                        content = content[:insert_pos] + import_pattern + "\n" + content[insert_pos:]
+                        applied = True
+                        print("  [run_agent.py] Added LaTeX -> Unicode conversion (fallback)")
+
+    elif latex_marker in content:
+        print("  [run_agent.py] LaTeX conversion already patched")
+
     if applied:
         with open(filepath, "w") as f:
             f.write(content)
         return True
     else:
+        # Even if no new patches applied, existing ones may be present
+        if 'hermes-bot patch' in content:
+            print(f"  run_agent.py: existing patches found, no new changes needed")
+            return True
         print(f"  WARNING: Could not patch {filepath}", file=sys.stderr)
         return False
 
@@ -98,7 +236,7 @@ def patch_stream_consumer(filepath: str) -> bool:
     old_open = '    _OPEN_THINK_TAGS = (\n        "<REASONING_SCRATCHPAD>", "\U0001f9ae", "<reasoning>",\n        "<THINKING>", "<thinking>", "<thought>",\n    )'
     new_open = '    _OPEN_THINK_TAGS = (\n        "<REASONING_SCRATCHPAD>", "\U0001f9ae", "<reasoning>",\n        "<THINKING>", "<thinking>", "<thought>",\n        # Hermes Bot patch: <|...> thinking variants\n        "<|channel>thought", "<|channel|>",\n    )'
 
-    if old_open in content:
+    if old_open in content and '<|channel>thought' not in content:
         content = content.replace(old_open, new_open, 1)
         applied = True
         print("  [stream_consumer.py] Added <|channel>thought to _OPEN_THINK_TAGS")
@@ -107,7 +245,7 @@ def patch_stream_consumer(filepath: str) -> bool:
     old_close = '    _CLOSE_THINK_TAGS = (\n        "</REASONING_SCRATCHPAD>", "\U0001f9d0", "</reasoning>",\n        "</THINKING>", "</thinking>", "</thought>",\n    )'
     new_close = '    _CLOSE_THINK_TAGS = (\n        "</REASONING_SCRATCHPAD>", "\U0001f9d0", "</reasoning>",\n        "</THINKING>", "</thinking>", "</thought>",\n        # Hermes Bot patch: <|...> thinking variants\n        "<channel|>",\n    )'
 
-    if old_close in content:
+    if old_close in content and '<channel|>' not in content.split('_CLOSE_THINK_TAGS')[1].split('\n\n')[0]:
         content = content.replace(old_close, new_close, 1)
         applied = True
         print("  [stream_consumer.py] Added <channel|> to _CLOSE_THINK_TAGS")
@@ -117,6 +255,9 @@ def patch_stream_consumer(filepath: str) -> bool:
             f.write(content)
         return True
     else:
+        if '<|channel>thought' in content or '<channel|>' in content:
+            print("  stream_consumer.py: existing patches found, no new changes needed")
+            return True
         print(f"  WARNING: Could not patch {filepath}", file=sys.stderr)
         return False