feat: markdown-to-HTML formatting + response cleanup

- Convert OLMo markdown to Telegram HTML (bold, italic, links, code, headings)
- Fallback to plain text if HTML parsing fails
- Truncate hallucinated multi-turn artifacts from responses

Author: Endogen

bot.py

@@ -33,6 +33,7 @@
     VISION_MODELS,
     WEB2API_URL,
 )
+from formatting import md_to_telegram_html
 from pointing import draw_points_on_image, has_points, parse_points, strip_points
 
 logging.basicConfig(
@@ -53,6 +54,19 @@
 # Typing indicator
 # ---------------------------------------------------------------------------
 
+async def send_formatted(msg, text: str) -> None:
+    """Send a message with markdown→HTML conversion, falling back to plain text."""
+    formatted = md_to_telegram_html(text)
+    chunks = [formatted[i:i + 4096] for i in range(0, len(formatted), 4096)]
+    for chunk in chunks:
+        try:
+            await msg.reply_text(chunk, parse_mode=ParseMode.HTML, disable_web_page_preview=True)
+        except Exception:
+            # If HTML parsing fails, send as plain text
+            plain = text[chunks.index(chunk) * 4096:(chunks.index(chunk) + 1) * 4096] if len(chunks) > 1 else text
+            await msg.reply_text(plain[:4096])
+
+
 @asynccontextmanager
 async def keep_typing(chat):
     """Send typing indicator every 4 seconds until the block exits."""
@@ -153,6 +167,15 @@ async def query_model(
 
     fields = items[0].get("fields", {})
     answer = fields.get("response") or fields.get("answer") or fields.get("text") or str(fields)
+
+    # OLMo sometimes generates fake follow-up conversations — truncate at first
+    # occurrence of a role marker that indicates hallucinated multi-turn output.
+    for marker in ("\nuser\n", "\nassistant\n", "\n<function_calls>"):
+        idx = answer.find(marker)
+        if idx > 0:
+            answer = answer[:idx].rstrip()
+            break
+
     return answer
 
 
@@ -362,11 +385,7 @@ async def handle_media(update: Update, context: ContextTypes.DEFAULT_TYPE) -> No
                 pointed_path = None
 
         if not pointed_path:
-            if len(answer) <= 4096:
-                await msg.reply_text(answer)
-            else:
-                for i in range(0, len(answer), 4096):
-                    await msg.reply_text(answer[i:i + 4096])
+            await send_formatted(msg, answer)
 
     except httpx.ReadTimeout:
         await msg.reply_text("⏳ Request timed out. Vision analysis can be slow — try again.")
@@ -408,11 +427,7 @@ async def cmd_search(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None
             if len(user_history[uid]) > MAX_HISTORY * 2:
                 user_history[uid] = user_history[uid][-(MAX_HISTORY * 2):]
 
-        if len(answer) <= 4096:
-            await update.message.reply_text(answer)
-        else:
-            for i in range(0, len(answer), 4096):
-                await update.message.reply_text(answer[i:i + 4096])
+        await send_formatted(update.message, answer)
 
     except httpx.HTTPStatusError as e:
         logger.error("HTTP error: %s", e)
@@ -449,14 +464,7 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
             if len(user_history[uid]) > MAX_HISTORY * 2:
                 user_history[uid] = user_history[uid][-(MAX_HISTORY * 2):]
 
-        # Telegram has a 4096 char limit
-        if len(answer) <= 4096:
-            await update.message.reply_text(answer)
-        else:
-            # Split into chunks
-            for i in range(0, len(answer), 4096):
-                chunk = answer[i:i + 4096]
-                await update.message.reply_text(chunk)
+        await send_formatted(update.message, answer)
 
     except httpx.HTTPStatusError as e:
         logger.error("HTTP error: %s", e)

formatting.py

@@ -0,0 +1,61 @@
+"""Convert markdown to Telegram-safe HTML."""
+
+from __future__ import annotations
+
+import html
+import re
+
+
+def md_to_telegram_html(text: str) -> str:
+    """Convert common markdown to Telegram HTML.
+
+    Handles: **bold**, *italic*, `inline code`, ```code blocks```,
+    [text](url), and # headings.  Everything else is HTML-escaped.
+    """
+    # Extract code blocks first to protect their content
+    code_blocks: list[str] = []
+
+    def _save_code_block(m: re.Match) -> str:
+        lang = m.group(1) or ""
+        code = html.escape(m.group(2))
+        code_blocks.append(f"<pre>{code}</pre>")
+        return f"\x00CODEBLOCK{len(code_blocks) - 1}\x00"
+
+    text = re.sub(r"```(\w*)\n?(.*?)```", _save_code_block, text, flags=re.DOTALL)
+
+    # Extract inline code
+    inline_codes: list[str] = []
+
+    def _save_inline_code(m: re.Match) -> str:
+        code = html.escape(m.group(1))
+        inline_codes.append(f"<code>{code}</code>")
+        return f"\x00INLINE{len(inline_codes) - 1}\x00"
+
+    text = re.sub(r"`([^`]+)`", _save_inline_code, text)
+
+    # HTML-escape the rest
+    text = html.escape(text)
+
+    # Links: [text](url)
+    text = re.sub(
+        r"\[([^\]]+)\]\(([^)]+)\)",
+        r'<a href="\2">\1</a>',
+        text,
+    )
+
+    # Bold: **text**
+    text = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", text)
+
+    # Italic: *text* (but not inside words like file*name)
+    text = re.sub(r"(?<!\w)\*(.+?)\*(?!\w)", r"<i>\1</i>", text)
+
+    # Headings: # Title → bold
+    text = re.sub(r"^#{1,6}\s+(.+)$", r"<b>\1</b>", text, flags=re.MULTILINE)
+
+    # Restore code blocks and inline code
+    for i, block in enumerate(code_blocks):
+        text = text.replace(f"\x00CODEBLOCK{i}\x00", block)
+    for i, code in enumerate(inline_codes):
+        text = text.replace(f"\x00INLINE{i}\x00", code)
+
+    return text