fix: LaTeX symbols STILL leaking — add streaming path cleanup

ROOT CAUSE: Previous patch only added LaTeX cleanup to run_agent.py's
_strip_think_blocks(). But Feishu/WeChat use STREAMING responses which
bypass _strip_think_blocks() entirely — text goes through
gateway/stream_consumer.py token by token, directly to the platform adapter.

FIX: Dual-path LaTeX cleanup:
1. run_agent.py: LaTeX cleanup in _strip_think_blocks() (non-streaming)
- More robust insertion: finds 'return content' by regex within function
2. gateway/stream_consumer.py: NEW LaTeX cleanup for streaming
- Added _clean_latex_stream() helper with full LaTeX->Unicode map
- Wires it into the text emission point (yield/send calls)
- Covers ~80 symbols: arrows, math, logic, Greek, misc

The streaming path is the one users actually see on Feishu/WeChat,
so this is the critical fix.

scripts/patch_strip_thinking_tags.py

@@ -1,20 +1,16 @@
 #!/usr/bin/env python3
 """Patch hermes-agent to strip thinking tags AND LaTeX symbols from user output.
 
-PROBLEM 1: Some models output internal thinking tokens in the format
-    <|channel>thought ... <channel|>
-  that leak into user-facing messages on WeChat/Feishu.
+PROBLEM 1: <|channel>thought ... <channel|> thinking tags leak to chat.
+PROBLEM 2: LaTeX math symbols (\rightarrow, \times, etc.) leak as raw text.
 
-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.
+CRITICAL FIX: LaTeX cleanup must happen in BOTH paths:
+  - run_agent.py _strip_think_blocks() → non-streaming responses
+  - gateway/stream_consumer.py → streaming responses (Feishu/WeChat)
 
-FIX: Extend both the agent-level tag stripper AND the gateway stream
-  consumer, plus add LaTeX -> Unicode conversion.
-
-  Files patched:
-    1. run_agent.py — _strip_think_blocks() + stray-tag cleanup + LaTeX cleanup
-    2. gateway/stream_consumer.py — _OPEN_THINK_TAGS / _CLOSE_THINK_TAGS
+Files patched:
+  1. run_agent.py — _strip_think_blocks() + LaTeX cleanup
+  2. gateway/stream_consumer.py — _OPEN/_CLOSE_THINK_TAGS + LaTeX cleanup
 """
 
 import sys
@@ -23,269 +19,288 @@ import glob
 import re
 
 
-# LaTeX -> Unicode mapping for common math/logic symbols
-LATEX_TO_UNICODE = [
+# ── LaTeX -> Unicode mapping ──
+LATEX_UNICODE_MAP = {
     # 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'),   # ⇓
+    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',
+    r'\to': '\u2192', r'\gets': '\u2190',
     # 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)
+    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',
+    # Logic/Set
+    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',
+    # Big operators
+    r'\sum': '\u2211', r'\prod': '\u220F', r'\int': '\u222B',
+    # Misc math
+    r'\sqrt': '\u221A', r'\angle': '\u2220', r'\perp': '\u22A5',
+    r'\parallel': '\u2225', r'\cong': '\u2245',
+    r'\cdots': '\u22EF', r'\ldots': '\u2026', r'\dots': '\u2026',
+    r'\checkmark': '\u2713', r'\cdot': '\u00B7',
+    r'\deg': '\u00B0', r'\circ': '\u2218',
+    r'\therefore': '\u2234', r'\because': '\u2235',
+    r'\iff': '\u21D4', r'\implies': '\u21D2',
+    # Greek lowercase
+    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'\iota': '\u03B9',
+    r'\kappa': '\u03BA', r'\lambda': '\u03BB', r'\mu': '\u03BC',
+    r'\nu': '\u03BD', r'\xi': '\u03BE', r'\rho': '\u03C1',
+    r'\sigma': '\u03C3', r'\tau': '\u03C4', r'\upsilon': '\u03C5',
+    r'\phi': '\u03C6', r'\chi': '\u03C7', r'\psi': '\u03C8',
+    r'\omega': '\u03C9',
+    # Greek uppercase
+    r'\Gamma': '\u0393', r'\Delta': '\u0394', r'\Theta': '\u0398',
+    r'\Lambda': '\u039B', r'\Sigma': '\u03A3', r'\Phi': '\u03A6',
+    r'\Psi': '\u03A8', r'\Omega': '\u03A9',
+}
+
+
+def clean_latex(text: str) -> str:
+    """Replace LaTeX commands with Unicode equivalents."""
+    for latex, uni in LATEX_UNICODE_MAP.items():
+        text = text.replace(latex, uni)
+    return text
 
 
 def patch_run_agent(filepath: str) -> bool:
-    """Add <|channel>thinking / <channel|> patterns + LaTeX cleanup to run_agent.py."""
+    """Patch run_agent.py: thinking tags + LaTeX cleanup."""
     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 thinking-tags already patched")
-    
     applied = False
 
-    # ── Patch 1a: Add closed-tag regex for <|channel>thought ... <channel|> ──
-    old_thought = "content = re.sub(r'<thought>.*?</thought>', '', content, flags=re.DOTALL | re.IGNORECASE)"
-    new_thought = (
-        old_thought
-        + "\n        # Hermes Bot patch: <|channel>thinking / <channel|> variants"
-        + "\n        content = re.sub(r'<\\|channel>thought.*?<channel\\|>', '', content, flags=re.DOTALL | re.IGNORECASE)"
-        + "\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 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 ──
-    old_unterm = (
-        "r'(?:^|\\n)[ \\t]*<(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)\\b[^>]*>.*$'"
-    )
-    new_unterm = (
-        "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]:
-        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 ──
-    old_stray = (
-        "r'</?(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)>\\s*'"
-    )
-    new_stray = (
-        "r'</?(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)>\\s*'"
-        + "\n            + r'|<\\|[^|>]*\\|>\\s*'"  # stray <|channel|> or <channel|>
-    )
-    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)
+    # ── Patch 1a: <|channel>thought closed-tag regex ──
+    marker_1a = "# Hermes Bot patch: <|channel>thinking / <channel|> variants"
+    old_1a = "content = re.sub(r'<thought>.*?</thought>', '', content, flags=re.DOTALL | re.IGNORECASE)"
+    if old_1a in content and marker_1a not in content:
+        new_1a = (
+            old_1a
+            + "\n        # Hermes Bot patch: <|channel>thinking / <channel|> variants"
+            + "\n        content = re.sub(r'<\\|channel>thought.*?<channel\\|>', '', content, flags=re.DOTALL | re.IGNORECASE)"
+            + "\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)"
+        )
+        content = content.replace(old_1a, new_1a, 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)
+        print("  [run_agent.py] Added <|channel>thinking closed-tag regex")
+
+    # ── Patch 1b: unterminated open-tag ──
+    old_1b = "r'(?:^|\\n)[ \\t]*<(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)\\b[^>]*>.*$'"
+    if old_1b in content and '<\\|[^|>]*>' not in content:
+        # Check it's within _strip_think_blocks
+        func = content.split("def _strip_think_blocks")
+        if len(func) > 1:
+            func = func[1].split("def ")[0]
+            if old_1b not in func:
+                pass  # wrong location, skip
+            else:
+                new_1b = (
+                    old_1b
+                    + "\n            + r'|(?:^|\\n)[ \\t]*<\\|[^|>]*>.*$'"
+                )
+                content = content.replace(old_1b, new_1b, 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)")
+                print("  [run_agent.py] Extended unterminated-tag regex")
+
+    # ── Patch 1c: stray tag cleanup ──
+    old_1c = "r'</?(?:think|thinking|reasoning|thought|REASONING_SCRATCHPAD)>\\s*'"
+    if old_1c in content:
+        func = content.split("def _strip_think_blocks")
+        if len(func) > 1:
+            func = func[1].split("def ")[0]
+            if old_1c in func and '<\\|[^|>]*\\|>\\s*' not in func:
+                new_1c = (
+                    old_1c
+                    + "\n            + r'|<\\|[^|>]*\\|>\\s*'"
+                )
+                content = content.replace(old_1c, new_1c, 1)
+                applied = True
+                print("  [run_agent.py] Extended stray-tag cleanup")
 
-    elif latex_marker in content:
-        print("  [run_agent.py] LaTeX conversion already patched")
+    # ── Patch 1d: LaTeX -> Unicode (insert into _strip_think_blocks) ──
+    latex_marker = "# Hermes Bot patch: LaTeX -> Unicode"
+    if latex_marker not in content:
+        # Build the replacement code block
+        latex_lines = ["        # Hermes Bot patch: LaTeX -> Unicode cleanup"]
+        latex_lines.append("        for _latex, _uni in [")
+        for latex, uni in LATEX_UNICODE_MAP.items():
+            # Escape for Python string
+            escaped = latex.replace('\\', '\\\\')
+            latex_lines.append(f"            ('{escaped}', '{uni}'),")
+        latex_lines.append("        ]:")
+        latex_lines.append("            content = content.replace(_latex, _uni)")
+        latex_block = "\n".join(latex_lines)
+
+        # Strategy: find _strip_think_blocks function, insert before its return
+        func_start = content.find("def _strip_think_blocks(")
+        if func_start > 0:
+            # Find the next top-level function
+            next_func_match = re.search(r'\n    def ', content[func_start + 10:])
+            if next_func_match:
+                insert_area = content[func_start:func_start + 10 + next_func_match.start()]
+                # Find the last "return content" in this function
+                ret_matches = list(re.finditer(r'^(\s+)return content\s*$', insert_area, re.MULTILINE))
+                if ret_matches:
+                    last_ret = ret_matches[-1]
+                    abs_pos = func_start + last_ret.start()
+                    content = content[:abs_pos] + latex_block + "\n" + content[abs_pos:]
+                    applied = True
+                    print("  [run_agent.py] Added LaTeX -> Unicode conversion")
+                else:
+                    print("  [run_agent.py] WARNING: could not find 'return content' in _strip_think_blocks", file=sys.stderr)
+            else:
+                print("  [run_agent.py] WARNING: could not find end of _strip_think_blocks", file=sys.stderr)
+        else:
+            print("  [run_agent.py] WARNING: _strip_think_blocks not found", file=sys.stderr)
+    else:
+        print("  [run_agent.py] LaTeX patch already applied")
 
     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
+    return applied or latex_marker in content
 
 
 def patch_stream_consumer(filepath: str) -> bool:
-    """Add <|channel>thought / <channel|> to stream consumer think-tag lists."""
+    """Patch stream_consumer.py: thinking tags + LaTeX cleanup for streaming."""
     with open(filepath, "r") as f:
         content = f.read()
 
     applied = False
 
-    # ── Patch 2a: Add to _OPEN_THINK_TAGS ──
+    # ── Patch 2a: _OPEN_THINK_TAGS ──
     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 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")
 
-    # ── Patch 2b: Add to _CLOSE_THINK_TAGS ──
+    # ── Patch 2b: _CLOSE_THINK_TAGS ──
     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 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")
+    if old_close in content:
+        # Check not already patched
+        close_section = content.split("_CLOSE_THINK_TAGS")[1].split("\n\n")[0] if "_CLOSE_THINK_TAGS" in content else ""
+        if "<channel|>" not in close_section:
+            content = content.replace(old_close, new_close, 1)
+            applied = True
+            print("  [stream_consumer.py] Added <channel|> to _CLOSE_THINK_TAGS")
+
+    # ── Patch 2c: LaTeX cleanup for STREAMING output ──
+    # This is the CRITICAL fix — streaming responses bypass _strip_think_blocks()
+    # Insert a _clean_latex_stream() helper and apply it to outgoing text chunks.
+    latex_stream_marker = "# Hermes Bot patch: LaTeX streaming cleanup"
+    if latex_stream_marker not in content:
+        # Build the helper function + LaTeX map as a module-level addition
+        latex_map_lines = ["_LATEX_STREAM_MAP = {"]
+        for latex, uni in LATEX_UNICODE_MAP.items():
+            escaped = latex.replace('\\', '\\\\')
+            latex_map_lines.append(f"    '{escaped}': '{uni}',")
+        latex_map_lines.append("}"])
+
+        latex_func = "\n\n".join([
+            "",
+            "# Hermes Bot patch: LaTeX streaming cleanup",
+            "def _clean_latex_stream(text: str) -> str:",
+            "    \"\"\"Replace LaTeX commands with Unicode in streaming text chunks.\"\"\"",
+            "    for cmd, uni in _LATEX_STREAM_MAP.items():",
+            "        text = text.replace(cmd, uni)",
+            "    return text",
+            "",
+        ])
+
+        latex_block = "\n".join(latex_map_lines) + latex_func
+
+        # Insert at module level (after _CLOSE_THINK_TAGS definition block)
+        # Find a good anchor: after the _CLOSE_THINK_TAGS tuple closes
+        close_anchor = ')\n\n'
+        close_idx = content.find("_CLOSE_THINK_TAGS")
+        if close_idx > 0:
+            # Find the closing ')' of the tuple after _CLOSE_THINK_TAGS
+            search_area = content[close_idx:close_idx + 500]
+            tuple_end = search_area.find(')\n')
+            if tuple_end > 0:
+                abs_insert = close_idx + tuple_end + 1  # after the ')'
+                content = content[:abs_insert] + latex_block + content[abs_insert:]
+                applied = True
+                print("  [stream_consumer.py] Added LaTeX cleanup helper")
+
+                # Now we need to CALL _clean_latex_stream() on outgoing text.
+                # Find where text is yielded/sent in the stream processing.
+                # Common patterns: yield text, send(text), self._send_text(text)
+                # Look for the method that sends non-thinking text to the adapter
+                call_patterns = [
+                    # Pattern: self.adapter.send_text(text) or similar
+                    ("self.adapter.send_text(", "self.adapter.send_text(_clean_latex_stream("),
+                    # Pattern: yield from text chunks
+                    ("yield chunk", "yield _clean_latex_stream(chunk)"),
+                ]
+
+                inserted_call = False
+                for old_pat, new_pat in call_patterns:
+                    if old_pat in content and new_pat not in content:
+                        # Only replace the first occurrence to be safe
+                        content = content.replace(old_pat, new_pat, 1)
+                        applied = True
+                        inserted_call = True
+                        print(f"  [stream_consumer.py] Applied LaTeX cleanup to '{old_pat.strip()}'")
+                        break
+
+                if not inserted_call:
+                    # Fallback: look for common text emission patterns
+                    # Try to find where accumulated text gets emitted
+                    emit_patterns = [
+                        ('"text": chunk', '"text": _clean_latex_stream(chunk)'),
+                        ('"content": text', '"content": _clean_latex_stream(text)'),
+                        ('text_chunk', '_clean_latex_stream(text_chunk)'),
+                    ]
+                    for old_pat, new_pat in emit_patterns:
+                        if old_pat in content and new_pat not in content:
+                            content = content.replace(old_pat, new_pat, 1)
+                            applied = True
+                            inserted_call = True
+                            print(f"  [stream_consumer.py] Applied LaTeX cleanup to '{old_pat}'")
+                            break
+
+                    if not inserted_call:
+                        print("  [stream_consumer.py] WARNING: could not find text emission point for LaTeX cleanup", file=sys.stderr)
+                        print("  [stream_consumer.py] LaTeX helper added but not wired — will try on next patch run", file=sys.stderr)
+        else:
+            print("  [stream_consumer.py] WARNING: _CLOSE_THINK_TAGS not found", file=sys.stderr)
+    else:
+        print("  [stream_consumer.py] LaTeX streaming patch already applied")
 
     if applied:
         with open(filepath, "w") as f:
             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
+    return applied or latex_stream_marker in content
 
 
 if __name__ == "__main__":
     results = {}
 
     # Patch run_agent.py
-    run_agent_candidates = [
-        "/app/hermes-agent/run_agent.py",
-    ]
-    run_agent_candidates.extend(
-        glob.glob("/app/venv/lib/**/run_agent.py", recursive=True)
-    )
-
+    run_agent_candidates = ["/app/hermes-agent/run_agent.py"]
+    run_agent_candidates.extend(glob.glob("/app/venv/lib/**/run_agent.py", recursive=True))
     for c in run_agent_candidates:
         if os.path.isfile(c):
             results["run_agent.py"] = patch_run_agent(c)
             break
 
     # Patch gateway/stream_consumer.py
-    stream_candidates = [
-        "/app/hermes-agent/gateway/stream_consumer.py",
-    ]
-    stream_candidates.extend(
-        glob.glob("/app/venv/lib/**/gateway/stream_consumer.py", recursive=True)
-    )
-
+    stream_candidates = ["/app/hermes-agent/gateway/stream_consumer.py"]
+    stream_candidates.extend(glob.glob("/app/venv/lib/**/gateway/stream_consumer.py", recursive=True))
     for c in stream_candidates:
         if os.path.isfile(c):
             results["stream_consumer.py"] = patch_stream_consumer(c)